@tamagui/react-native-web-lite 1.112.5

package/dist/cjs/ScrollView/ScrollViewBase.native.js

@@ -0,0 +1,114 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: !0 }) : target,
+  mod
+)), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var ScrollViewBase_exports = {};
+__export(ScrollViewBase_exports, {
+  default: () => ScrollViewBase_default
+});
+module.exports = __toCommonJS(ScrollViewBase_exports);
+var import_jsx_runtime = require("react/jsx-runtime"), React = __toESM(require("react")), import_react_native_web_internals = require("@tamagui/react-native-web-internals"), import_View = __toESM(require("../View/index"));
+function normalizeScrollEvent(e) {
+  return {
+    nativeEvent: {
+      contentOffset: {
+        get x() {
+          return e.target.scrollLeft;
+        },
+        get y() {
+          return e.target.scrollTop;
+        }
+      },
+      contentSize: {
+        get height() {
+          return e.target.scrollHeight;
+        },
+        get width() {
+          return e.target.scrollWidth;
+        }
+      },
+      layoutMeasurement: {
+        get height() {
+          return e.target.offsetHeight;
+        },
+        get width() {
+          return e.target.offsetWidth;
+        }
+      }
+    },
+    timeStamp: Date.now()
+  };
+}
+function shouldEmitScrollEvent(lastTick, eventThrottle) {
+  var timeSinceLastTick = Date.now() - lastTick;
+  return eventThrottle > 0 && timeSinceLastTick >= eventThrottle;
+}
+var ScrollViewBase = /* @__PURE__ */ React.forwardRef(function(props, forwardedRef) {
+  var { onScroll, onTouchMove, onWheel, scrollEnabled = !0, scrollEventThrottle = 0, showsHorizontalScrollIndicator, showsVerticalScrollIndicator, style, ...rest } = props, scrollState = React.useRef({
+    isScrolling: !1,
+    scrollLastTick: 0
+  }), scrollTimeout = React.useRef(null), scrollRef = React.useRef(null);
+  function createPreventableScrollHandler(handler) {
+    return function(e) {
+      scrollEnabled && handler && handler(e);
+    };
+  }
+  function handleScroll(e) {
+    e.stopPropagation(), e.target === scrollRef.current && (e.persist(), scrollTimeout.current != null && clearTimeout(scrollTimeout.current), scrollTimeout.current = setTimeout(function() {
+      handleScrollEnd(e);
+    }, 100), scrollState.current.isScrolling ? shouldEmitScrollEvent(scrollState.current.scrollLastTick, scrollEventThrottle) && handleScrollTick(e) : handleScrollStart(e));
+  }
+  function handleScrollStart(e) {
+    scrollState.current.isScrolling = !0, handleScrollTick(e);
+  }
+  function handleScrollTick(e) {
+    scrollState.current.scrollLastTick = Date.now(), onScroll && onScroll(normalizeScrollEvent(e));
+  }
+  function handleScrollEnd(e) {
+    scrollState.current.isScrolling = !1, onScroll && onScroll(normalizeScrollEvent(e));
+  }
+  var hideScrollbar = showsHorizontalScrollIndicator === !1 || showsVerticalScrollIndicator === !1;
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_View.default, {
+    ...rest,
+    onScroll: handleScroll,
+    onTouchMove: createPreventableScrollHandler(onTouchMove),
+    onWheel: createPreventableScrollHandler(onWheel),
+    ref: (0, import_react_native_web_internals.useMergeRefs)(scrollRef, forwardedRef),
+    style: [
+      style,
+      // @ts-ignore
+      !scrollEnabled && styles.scrollDisabled,
+      // @ts-ignore
+      hideScrollbar && styles.hideScrollbar
+    ]
+  });
+}), styles = {
+  scrollDisabled: {
+    overflowX: "hidden",
+    overflowY: "hidden",
+    touchAction: "none"
+  },
+  hideScrollbar: {
+    scrollbarWidth: "none"
+  }
+}, ScrollViewBase_default = ScrollViewBase;
+//# sourceMappingURL=ScrollViewBase.js.map

package/dist/cjs/ScrollView/ScrollViewBase.native.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/ScrollView/Users/n8/tamagui/code/packages/react-native-web-lite/src/ScrollView/ScrollViewBase.tsx"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;AAAA;;;;;AAOC,yBAAA,8BAED,QAAuB,2BACvB,oCAAyC,gDAGzC,cAAiB;AAgBjB,SAASA,qBAAqBC,GAAC;AAC7B,SAAO;IACLC,aAAa;MACXC,eAAe;QACb,IAAIC,IAAI;AACN,iBAAOH,EAAEI,OAAOC;QAClB;QACA,IAAIC,IAAI;AACN,iBAAON,EAAEI,OAAOG;QAClB;MACF;MACAC,aAAa;QACX,IAAIC,SAAS;AACX,iBAAOT,EAAEI,OAAOM;QAClB;QACA,IAAIC,QAAQ;AACV,iBAAOX,EAAEI,OAAOQ;QAClB;MACF;MACAC,mBAAmB;QACjB,IAAIJ,SAAS;AACX,iBAAOT,EAAEI,OAAOU;QAClB;QACA,IAAIH,QAAQ;AACV,iBAAOX,EAAEI,OAAOW;QAClB;MACF;IACF;IACAC,WAAWC,KAAKC,IAAG;EACrB;AACF;AAEA,SAASC,sBAAsBC,UAAkBC,eAAqB;AACpE,MAAMC,oBAAoBL,KAAKC,IAAG,IAAKE;AACvC,SAAOC,gBAAgB,KAAKC,qBAAqBD;AACnD;AAKA,IAAME,iBAAiBC,sBAAMC,WAAW,SAACC,OAAcC,cAAAA;AACrD,MAAM,EACJC,UACAC,aACAC,SACAC,gBAAgB,IAChBC,sBAAsB,GACtBC,gCACAC,8BACAC,OACA,GAAGC,KAAAA,IACDV,OAEEW,cAAcb,MAAMc,OAAO;IAAEC,aAAa;IAAOC,gBAAgB;EAAE,CAAA,GACnEC,gBAAgBjB,MAAMc,OAAO,IAAA,GAC7BI,YAAYlB,MAAMc,OAAO,IAAA;AAE/B,WAASK,+BAA+BC,SAAiB;AACvD,WAAO,SAAC5C,GAAAA;AACN,MAAI+B,iBACEa,WACFA,QAAQ5C,CAAAA;IAGd;EACF;AAEA,WAAS6C,aAAa7C,GAAM;AAC1BA,MAAE8C,gBAAe,GACb9C,EAAEI,WAAWsC,UAAUK,YACzB/C,EAAEgD,QAAO,GAELP,cAAcM,WAAW,QAC3BE,aAAaR,cAAcM,OAAO,GAGpCN,cAAcM,UAAUG,WAAW,WAAA;AACjCC,sBAAgBnD,CAAAA;IAClB,GAAG,GAAA,GACCqC,YAAYU,QAAQR,cAGpBpB,sBAAsBkB,YAAYU,QAAQP,gBAAgBR,mBAAAA,KAE1DoB,iBAAiBpD,CAAAA,IAInBqD,kBAAkBrD,CAAAA;EAGxB;AAEA,WAASqD,kBAAkBrD,GAAS;AAClCqC,gBAAYU,QAAQR,cAAc,IAClCa,iBAAiBpD,CAAAA;EACnB;AAEA,WAASoD,iBAAiBpD,GAAS;AACjCqC,gBAAYU,QAAQP,iBAAiBvB,KAAKC,IAAG,GACzCU,YACFA,SAAS7B,qBAAqBC,CAAAA,CAAAA;EAElC;AAEA,WAASmD,gBAAgBnD,GAAS;AAChCqC,gBAAYU,QAAQR,cAAc,IAC9BX,YACFA,SAAS7B,qBAAqBC,CAAAA,CAAAA;EAElC;AAEA,MAAMsD,gBACJrB,mCAAmC,MAASC,iCAAiC;AAE/E,SACE,uCAAAqB,KAACC,YAAAA,SAAAA;IACE,GAAGpB;IACJR,UAAUiB;IACVhB,aAAac,+BAA+Bd,WAAAA;IAC5CC,SAASa,+BAA+Bb,OAAAA;IACxC2B,SAAKC,gDAAahB,WAAWf,YAAAA;IAC7BQ,OAAO;MACLA;;MAEA,CAACJ,iBAAiB4B,OAAOC;;MAEzBN,iBAAiBK,OAAOL;;;AAIhC,CAAA,GAKMK,SAAS;EACbC,gBAAgB;IACdC,WAAW;IACXC,WAAW;IACXC,aAAa;EACf;EACAT,eAAe;IACbU,gBAAgB;EAClB;AACF,GAEA,yBAAezC;",
+  "names": ["normalizeScrollEvent", "e", "nativeEvent", "contentOffset", "x", "target", "scrollLeft", "y", "scrollTop", "contentSize", "height", "scrollHeight", "width", "scrollWidth", "layoutMeasurement", "offsetHeight", "offsetWidth", "timeStamp", "Date", "now", "shouldEmitScrollEvent", "lastTick", "eventThrottle", "timeSinceLastTick", "ScrollViewBase", "React", "forwardRef", "props", "forwardedRef", "onScroll", "onTouchMove", "onWheel", "scrollEnabled", "scrollEventThrottle", "showsHorizontalScrollIndicator", "showsVerticalScrollIndicator", "style", "rest", "scrollState", "useRef", "isScrolling", "scrollLastTick", "scrollTimeout", "scrollRef", "createPreventableScrollHandler", "handler", "handleScroll", "stopPropagation", "current", "persist", "clearTimeout", "setTimeout", "handleScrollEnd", "handleScrollTick", "handleScrollStart", "hideScrollbar", "_jsx", "View", "ref", "useMergeRefs", "styles", "scrollDisabled", "overflowX", "overflowY", "touchAction", "scrollbarWidth"]
+}

package/dist/cjs/ScrollView/index.js

@@ -0,0 +1,517 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: !0 }) : target,
+  mod
+)), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+var ScrollView_exports = {};
+__export(ScrollView_exports, {
+  default: () => ScrollView_default
+});
+module.exports = __toCommonJS(ScrollView_exports);
+var import_react = __toESM(require("react")), import_react_native_web_internals = require("@tamagui/react-native-web-internals"), import_Dimensions = __toESM(require("../Dimensions/index")), import_View = __toESM(require("../View/index")), import_ScrollViewBase = __toESM(require("./ScrollViewBase")), import_jsx_runtime = require("react/jsx-runtime");
+const emptyObject = {}, IS_ANIMATING_TOUCH_START_THRESHOLD_MS = 16;
+class ScrollView extends import_react.default.Component {
+  _scrollNodeRef;
+  _innerViewRef;
+  keyboardWillOpenTo = null;
+  additionalScrollOffset = 0;
+  isTouching = !1;
+  lastMomentumScrollBeginTime = 0;
+  lastMomentumScrollEndTime = 0;
+  // Reset to false every time becomes responder. This is used to:
+  // - Determine if the scroll view has been scrolled and therefore should
+  // refuse to give up its responder lock.
+  // - Determine if releasing should dismiss the keyboard when we are in
+  // tap-to-dismiss mode (!this.props.keyboardShouldPersistTaps).
+  observedScrollSinceBecomingResponder = !1;
+  becameResponderWhileAnimating = !1;
+  flashScrollIndicators() {
+    this.scrollResponderFlashScrollIndicators();
+  }
+  /**
+   * Returns a reference to the underlying scroll responder, which supports
+   * operations like `scrollTo`. All ScrollView-like components should
+   * implement this method so that they can be composed while providing access
+   * to the underlying scroll responder's methods.
+   */
+  getScrollResponder() {
+    return this.mixin;
+  }
+  getScrollableNode() {
+    return this._scrollNodeRef;
+  }
+  getInnerViewRef() {
+    return this._innerViewRef;
+  }
+  getInnerViewNode() {
+    return this._innerViewRef;
+  }
+  getNativeScrollRef() {
+    return this._scrollNodeRef;
+  }
+  /**
+   * Scrolls to a given x, y offset, either immediately or with a smooth animation.
+   * Syntax:
+   *
+   * scrollTo(options: {x: number = 0; y: number = 0; animated: boolean = true})
+   *
+   * Note: The weird argument signature is due to the fact that, for historical reasons,
+   * the function also accepts separate arguments as as alternative to the options object.
+   * This is deprecated due to ambiguity (y before x), and SHOULD NOT BE USED.
+   */
+  scrollTo(y, x, animated) {
+    typeof y == "number" ? console.warn(
+      "`scrollTo(y, x, animated)` is deprecated. Use `scrollTo({x: 5, y: 5, animated: true})` instead."
+    ) : { x, y, animated } = y || emptyObject, this.getScrollResponder().scrollResponderScrollTo({
+      x: x || 0,
+      y: y || 0,
+      animated: animated !== !1
+    });
+  }
+  /**
+   * If this is a vertical ScrollView scrolls to the bottom.
+   * If this is a horizontal ScrollView scrolls to the right.
+   *
+   * Use `scrollToEnd({ animated: true })` for smooth animated scrolling,
+   * `scrollToEnd({ animated: false })` for immediate scrolling.
+   * If no options are passed, `animated` defaults to true.
+   */
+  scrollToEnd(options) {
+    const animated = (options && options.animated) !== !1, { horizontal } = this.props, scrollResponder = this.getScrollResponder(), scrollResponderNode = this._scrollNodeRef, x = horizontal ? scrollResponderNode.scrollWidth : 0, y = horizontal ? 0 : scrollResponderNode.scrollHeight;
+    scrollResponder.scrollResponderScrollTo({ x, y, animated });
+  }
+  render() {
+    const {
+      contentContainerStyle,
+      horizontal,
+      onContentSizeChange,
+      refreshControl,
+      stickyHeaderIndices,
+      pagingEnabled,
+      /* eslint-disable */
+      forwardedRef,
+      keyboardDismissMode,
+      onScroll,
+      centerContent,
+      /* eslint-enable */
+      ...other
+    } = this.props;
+    if (process.env.NODE_ENV !== "production" && this.props.style) {
+      const style = import_react_native_web_internals.StyleSheet.flatten(this.props.style), childLayoutProps = ["alignItems", "justifyContent"].filter(
+        (prop) => style && style[prop] !== void 0
+      );
+      (0, import_react_native_web_internals.invariant)(
+        childLayoutProps.length === 0,
+        `ScrollView child layout (${JSON.stringify(childLayoutProps)}) must be applied through the contentContainerStyle prop.`
+      );
+    }
+    let contentSizeChangeProps = {};
+    onContentSizeChange && (contentSizeChangeProps = {
+      onLayout: this._handleContentOnLayout.bind(this)
+    });
+    const hasStickyHeaderIndices = !horizontal && Array.isArray(stickyHeaderIndices), children = hasStickyHeaderIndices || pagingEnabled ? import_react.default.Children.map(this.props.children, (child, i) => {
+      const isSticky = hasStickyHeaderIndices && stickyHeaderIndices.indexOf(i) > -1;
+      return child != null && (isSticky || pagingEnabled) ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        import_View.default,
+        {
+          style: import_react_native_web_internals.StyleSheet.compose(
+            isSticky && styles.stickyHeader,
+            pagingEnabled && styles.pagingEnabledChild
+          ),
+          children: child
+        }
+      ) : child;
+    }) : this.props.children, contentContainer = /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+      import_View.default,
+      {
+        ...contentSizeChangeProps,
+        collapsable: !1,
+        ref: this._setInnerViewRef.bind(this),
+        style: [
+          horizontal && styles.contentContainerHorizontal,
+          centerContent && styles.contentContainerCenterContent,
+          contentContainerStyle
+        ],
+        children
+      }
+    ), baseStyle = horizontal ? styles.baseHorizontal : styles.baseVertical, pagingEnabledStyle = horizontal ? styles.pagingEnabledHorizontal : styles.pagingEnabledVertical, props = {
+      ...other,
+      style: [baseStyle, pagingEnabled && pagingEnabledStyle, this.props.style],
+      onTouchStart: this.scrollResponderHandleTouchStart.bind(this),
+      onTouchMove: this.scrollResponderHandleTouchMove.bind(this),
+      onTouchEnd: this.scrollResponderHandleTouchEnd.bind(this),
+      onScrollBeginDrag: this.scrollResponderHandleScrollBeginDrag.bind(this),
+      onScrollEndDrag: this.scrollResponderHandleScrollEndDrag.bind(this),
+      onMomentumScrollBegin: this.scrollResponderHandleMomentumScrollBegin.bind(this),
+      onMomentumScrollEnd: this.scrollResponderHandleMomentumScrollEnd.bind(this),
+      onStartShouldSetResponder: this.scrollResponderHandleStartShouldSetResponder.bind(this),
+      onStartShouldSetResponderCapture: this.scrollResponderHandleStartShouldSetResponderCapture.bind(this),
+      onScrollShouldSetResponder: this.scrollResponderHandleScrollShouldSetResponder.bind(this),
+      onScroll: this._handleScroll.bind(this),
+      onResponderGrant: this.scrollResponderHandleResponderGrant.bind(this),
+      onResponderTerminationRequest: this.scrollResponderHandleTerminationRequest.bind(this),
+      onResponderRelease: this.scrollResponderHandleResponderRelease.bind(this),
+      onResponderReject: this.scrollResponderHandleResponderReject.bind(this)
+    }, ScrollViewClass = import_ScrollViewBase.default;
+    (0, import_react_native_web_internals.invariant)(ScrollViewClass !== void 0, "ScrollViewClass must not be undefined");
+    const scrollView = /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ScrollViewClass, { ...props, ref: this._setScrollNodeRef.bind(this), children: contentContainer });
+    return refreshControl ? import_react.default.cloneElement(refreshControl, { style: props.style }, scrollView) : scrollView;
+  }
+  _handleContentOnLayout(e) {
+    const { width, height } = e.nativeEvent.layout;
+    this.props.onContentSizeChange(width, height);
+  }
+  _handleScroll(e) {
+    process.env.NODE_ENV !== "production" && this.props.onScroll && this.props.scrollEventThrottle == null && console.info(
+      "You specified `onScroll` on a <ScrollView> but not `scrollEventThrottle`. You will only receive one event. Using `16` you get all the events but be aware that it may cause frame drops, use a bigger number if you don't need as much precision."
+    ), this.props.keyboardDismissMode === "on-drag" && (0, import_react_native_web_internals.dismissKeyboard)(), this.scrollResponderHandleScroll(e);
+  }
+  _setInnerViewRef(node) {
+    this._innerViewRef = node;
+  }
+  _setScrollNodeRef(node) {
+    this._scrollNodeRef = node, node != null && (node.getScrollResponder = this.getScrollResponder, node.getInnerViewNode = this.getInnerViewNode, node.getInnerViewRef = this.getInnerViewRef, node.getNativeScrollRef = this.getNativeScrollRef, node.getScrollableNode = this.getScrollableNode, node.scrollTo = this.scrollTo, node.scrollToEnd = this.scrollToEnd, node.flashScrollIndicators = this.flashScrollIndicators, node.scrollResponderZoomTo = this.scrollResponderZoomTo, node.scrollResponderScrollNativeHandleToKeyboard = this.scrollResponderScrollNativeHandleToKeyboard), (0, import_react_native_web_internals.mergeRefs)(this.props.forwardedRef)(node);
+  }
+  /**
+   * Invoke this from an `onScroll` event.
+   */
+  scrollResponderHandleScrollShouldSetResponder() {
+    return this.isTouching;
+  }
+  /**
+   * Merely touch starting is not sufficient for a scroll view to become the
+   * responder. Being the "responder" means that the very next touch move/end
+   * event will result in an action/movement.
+   *
+   * Invoke this from an `onStartShouldSetResponder` event.
+   *
+   * `onStartShouldSetResponder` is used when the next move/end will trigger
+   * some UI movement/action, but when you want to yield priority to views
+   * nested inside of the view.
+   *
+   * There may be some cases where scroll views actually should return `true`
+   * from `onStartShouldSetResponder`: Any time we are detecting a standard tap
+   * that gives priority to nested views.
+   *
+   * - If a single tap on the scroll view triggers an action such as
+   *   recentering a map style view yet wants to give priority to interaction
+   *   views inside (such as dropped pins or labels), then we would return true
+   *   from this method when there is a single touch.
+   *
+   * - Similar to the previous case, if a two finger "tap" should trigger a
+   *   zoom, we would check the `touches` count, and if `>= 2`, we would return
+   *   true.
+   *
+   */
+  scrollResponderHandleStartShouldSetResponder() {
+    return !1;
+  }
+  /**
+   * There are times when the scroll view wants to become the responder
+   * (meaning respond to the next immediate `touchStart/touchEnd`), in a way
+   * that *doesn't* give priority to nested views (hence the capture phase):
+   *
+   * - Currently animating.
+   * - Tapping anywhere that is not the focused input, while the keyboard is
+   *   up (which should dismiss the keyboard).
+   *
+   * Invoke this from an `onStartShouldSetResponderCapture` event.
+   */
+  scrollResponderHandleStartShouldSetResponderCapture(e) {
+    return this.scrollResponderIsAnimating();
+  }
+  /**
+   * Invoke this from an `onResponderReject` event.
+   *
+   * Some other element is not yielding its role as responder. Normally, we'd
+   * just disable the `UIScrollView`, but a touch has already began on it, the
+   * `UIScrollView` will not accept being disabled after that. The easiest
+   * solution for now is to accept the limitation of disallowing this
+   * altogether. To improve this, find a way to disable the `UIScrollView` after
+   * a touch has already started.
+   */
+  scrollResponderHandleResponderReject() {
+    (0, import_react_native_web_internals.warning)(!1, "ScrollView doesn't take rejection well - scrolls anyway");
+  }
+  /**
+   * We will allow the scroll view to give up its lock iff it acquired the lock
+   * during an animation. This is a very useful default that happens to satisfy
+   * many common user experiences.
+   *
+   * - Stop a scroll on the left edge, then turn that into an outer view's
+   *   backswipe.
+   * - Stop a scroll mid-bounce at the top, continue pulling to have the outer
+   *   view dismiss.
+   * - However, without catching the scroll view mid-bounce (while it is
+   *   motionless), if you drag far enough for the scroll view to become
+   *   responder (and therefore drag the scroll view a bit), any backswipe
+   *   navigation of a swipe gesture higher in the view hierarchy, should be
+   *   rejected.
+   */
+  scrollResponderHandleTerminationRequest() {
+    return !this.observedScrollSinceBecomingResponder;
+  }
+  /**
+   * Invoke this from an `onTouchEnd` event.
+   *
+   * @param {SyntheticEvent} e Event.
+   */
+  scrollResponderHandleTouchEnd(e) {
+    const nativeEvent = e.nativeEvent;
+    this.isTouching = nativeEvent.touches.length !== 0, this.props.onTouchEnd && this.props.onTouchEnd(e);
+  }
+  /**
+   * Invoke this from an `onResponderRelease` event.
+   */
+  scrollResponderHandleResponderRelease(e) {
+    this.props.onResponderRelease && this.props.onResponderRelease(e);
+    const currentlyFocusedTextInput = import_react_native_web_internals.TextInputState.currentlyFocusedField();
+    !this.props.keyboardShouldPersistTaps && currentlyFocusedTextInput != null && e.target !== currentlyFocusedTextInput && !this.observedScrollSinceBecomingResponder && !this.becameResponderWhileAnimating && (this.props.onScrollResponderKeyboardDismissed && this.props.onScrollResponderKeyboardDismissed(e), import_react_native_web_internals.TextInputState.blurTextInput(currentlyFocusedTextInput));
+  }
+  scrollResponderHandleScroll(e) {
+    this.observedScrollSinceBecomingResponder = !0, this.props.onScroll && this.props.onScroll(e);
+  }
+  /**
+   * Invoke this from an `onResponderGrant` event.
+   */
+  scrollResponderHandleResponderGrant(e) {
+    this.observedScrollSinceBecomingResponder = !1, this.props.onResponderGrant && this.props.onResponderGrant(e), this.becameResponderWhileAnimating = this.scrollResponderIsAnimating();
+  }
+  /**
+   * Unfortunately, `onScrollBeginDrag` also fires when *stopping* the scroll
+   * animation, and there's not an easy way to distinguish a drag vs. stopping
+   * momentum.
+   *
+   * Invoke this from an `onScrollBeginDrag` event.
+   */
+  scrollResponderHandleScrollBeginDrag(e) {
+    this.props.onScrollBeginDrag && this.props.onScrollBeginDrag(e);
+  }
+  /**
+   * Invoke this from an `onScrollEndDrag` event.
+   */
+  scrollResponderHandleScrollEndDrag(e) {
+    this.props.onScrollEndDrag && this.props.onScrollEndDrag(e);
+  }
+  /**
+   * Invoke this from an `onMomentumScrollBegin` event.
+   */
+  scrollResponderHandleMomentumScrollBegin(e) {
+    this.lastMomentumScrollBeginTime = Date.now(), this.props.onMomentumScrollBegin && this.props.onMomentumScrollBegin(e);
+  }
+  /**
+   * Invoke this from an `onMomentumScrollEnd` event.
+   */
+  scrollResponderHandleMomentumScrollEnd(e) {
+    this.lastMomentumScrollEndTime = Date.now(), this.props.onMomentumScrollEnd && this.props.onMomentumScrollEnd(e);
+  }
+  /**
+   * Invoke this from an `onTouchStart` event.
+   *
+   * Since we know that the `SimpleEventPlugin` occurs later in the plugin
+   * order, after `ResponderEventPlugin`, we can detect that we were *not*
+   * permitted to be the responder (presumably because a contained view became
+   * responder). The `onResponderReject` won't fire in that case - it only
+   * fires when a *current* responder rejects our request.
+   *
+   * @param {SyntheticEvent} e Touch Start event.
+   */
+  scrollResponderHandleTouchStart(e) {
+    this.isTouching = !0, this.props.onTouchStart && this.props.onTouchStart(e);
+  }
+  /**
+   * Invoke this from an `onTouchMove` event.
+   *
+   * Since we know that the `SimpleEventPlugin` occurs later in the plugin
+   * order, after `ResponderEventPlugin`, we can detect that we were *not*
+   * permitted to be the responder (presumably because a contained view became
+   * responder). The `onResponderReject` won't fire in that case - it only
+   * fires when a *current* responder rejects our request.
+   *
+   * @param {SyntheticEvent} e Touch Start event.
+   */
+  scrollResponderHandleTouchMove(e) {
+    this.props.onTouchMove && this.props.onTouchMove(e);
+  }
+  /**
+   * A helper function for this class that lets us quickly determine if the
+   * view is currently animating. This is particularly useful to know when
+   * a touch has just started or ended.
+   */
+  scrollResponderIsAnimating() {
+    return Date.now() - this.lastMomentumScrollEndTime < IS_ANIMATING_TOUCH_START_THRESHOLD_MS || this.lastMomentumScrollEndTime < this.lastMomentumScrollBeginTime;
+  }
+  /**
+   * A helper function to scroll to a specific point in the scrollview.
+   * This is currently used to help focus on child textviews, but can also
+   * be used to quickly scroll to any element we want to focus. Syntax:
+   *
+   * scrollResponderScrollTo(options: {x: number = 0; y: number = 0; animated: boolean = true})
+   *
+   * Note: The weird argument signature is due to the fact that, for historical reasons,
+   * the function also accepts separate arguments as as alternative to the options object.
+   * This is deprecated due to ambiguity (y before x), and SHOULD NOT BE USED.
+   */
+  scrollResponderScrollTo(x, y, animated) {
+    typeof x == "number" ? console.warn(
+      "`scrollResponderScrollTo(x, y, animated)` is deprecated. Use `scrollResponderScrollTo({x: 5, y: 5, animated: true})` instead."
+    ) : { x, y, animated } = x || emptyObject;
+    const node = this.options.getScrollableNode(), left = x || 0, top = y || 0;
+    typeof node.scroll == "function" ? node.scroll({ top, left, behavior: animated ? "smooth" : "auto" }) : (node.scrollLeft = left, node.scrollTop = top);
+  }
+  /**
+   * A helper function to zoom to a specific rect in the scrollview. The argument has the shape
+   * {x: number; y: number; width: number; height: number; animated: boolean = true}
+   *
+   * @platform ios
+   */
+  scrollResponderZoomTo(rect, animated) {
+    import_react_native_web_internals.Platform.OS !== "ios" && (0, import_react_native_web_internals.invariant)("zoomToRect is not implemented");
+  }
+  /**
+   * Displays the scroll indicators momentarily.
+   */
+  scrollResponderFlashScrollIndicators() {
+  }
+  /**
+   * This method should be used as the callback to onFocus in a TextInputs'
+   * parent view. Note that any module using this mixin needs to return
+   * the parent view's ref in getScrollViewRef() in order to use this method.
+   * @param {any} nodeHandle The TextInput node handle
+   * @param {number} additionalOffset The scroll view's top "contentInset".
+   *        Default is 0.
+   * @param {bool} preventNegativeScrolling Whether to allow pulling the content
+   *        down to make it meet the keyboard's top. Default is false.
+   */
+  scrollResponderScrollNativeHandleToKeyboard = (nodeHandle, additionalOffset, preventNegativeScrollOffset) => {
+    this.additionalScrollOffset = additionalOffset || 0, this.preventNegativeScrollOffset = !!preventNegativeScrollOffset, import_react_native_web_internals.UIManager.measureLayout(
+      nodeHandle,
+      this.options.getInnerViewNode(),
+      this.scrollResponderTextInputFocusError,
+      this.scrollResponderInputMeasureAndScrollToKeyboard
+    );
+  };
+  /**
+   * The calculations performed here assume the scroll view takes up the entire
+   * screen - even if has some content inset. We then measure the offsets of the
+   * keyboard, and compensate both for the scroll view's "contentInset".
+   *
+   * @param {number} left Position of input w.r.t. table view.
+   * @param {number} top Position of input w.r.t. table view.
+   * @param {number} width Width of the text input.
+   * @param {number} height Height of the text input.
+   */
+  scrollResponderInputMeasureAndScrollToKeyboard = (left, top, width, height) => {
+    let keyboardScreenY = import_Dimensions.default.get("window").height;
+    this.keyboardWillOpenTo && (keyboardScreenY = this.keyboardWillOpenTo.endCoordinates.screenY);
+    let scrollOffsetY = top - keyboardScreenY + height + this.additionalScrollOffset;
+    this.preventNegativeScrollOffset && (scrollOffsetY = Math.max(0, scrollOffsetY)), this.scrollResponderScrollTo({ x: 0, y: scrollOffsetY, animated: !0 }), this.additionalOffset = 0, this.preventNegativeScrollOffset = !1;
+  };
+  scrollResponderTextInputFocusError(e) {
+    console.error("Error measuring text field: ", e);
+  }
+  /**
+   * Warning, this may be called several times for a single keyboard opening.
+   * It's best to store the information in this method and then take any action
+   * at a later point (either in `keyboardDidShow` or other).
+   *
+   * Here's the order that events occur in:
+   * - focus
+   * - willShow {startCoordinates, endCoordinates} several times
+   * - didShow several times
+   * - blur
+   * - willHide {startCoordinates, endCoordinates} several times
+   * - didHide several times
+   *
+   * The `ScrollResponder` providesModule callbacks for each of these events.
+   * Even though any user could have easily listened to keyboard events
+   * themselves, using these `props` callbacks ensures that ordering of events
+   * is consistent - and not dependent on the order that the keyboard events are
+   * subscribed to. This matters when telling the scroll view to scroll to where
+   * the keyboard is headed - the scroll responder better have been notified of
+   * the keyboard destination before being instructed to scroll to where the
+   * keyboard will be. Stick to the `ScrollResponder` callbacks, and everything
+   * will work.
+   *
+   * WARNING: These callbacks will fire even if a keyboard is displayed in a
+   * different navigation pane. Filter out the events to determine if they are
+   * relevant to you. (For example, only if you receive these callbacks after
+   * you had explicitly focused a node etc).
+   */
+  scrollResponderKeyboardWillShow(e) {
+    this.keyboardWillOpenTo = e, this.props.onKeyboardWillShow && this.props.onKeyboardWillShow(e);
+  }
+  scrollResponderKeyboardWillHide(e) {
+    this.keyboardWillOpenTo = null, this.props.onKeyboardWillHide && this.props.onKeyboardWillHide(e);
+  }
+  scrollResponderKeyboardDidShow(e) {
+    e && (this.keyboardWillOpenTo = e), this.props.onKeyboardDidShow && this.props.onKeyboardDidShow(e);
+  }
+  scrollResponderKeyboardDidHide(e) {
+    this.keyboardWillOpenTo = null, this.props.onKeyboardDidHide && this.props.onKeyboardDidHide(e);
+  }
+}
+const commonStyle = {
+  flexGrow: 1,
+  flexShrink: 1,
+  // Enable hardware compositing in modern browsers.
+  // Creates a new layer with its own backing surface that can significantly
+  // improve scroll performance.
+  transform: [{ translateZ: 0 }],
+  // iOS native scrolling
+  WebkitOverflowScrolling: "touch"
+}, styles = {
+  baseVertical: {
+    ...commonStyle,
+    flexDirection: "column",
+    overflowX: "hidden",
+    overflowY: "auto"
+  },
+  baseHorizontal: {
+    ...commonStyle,
+    flexDirection: "row",
+    overflowX: "auto",
+    overflowY: "hidden"
+  },
+  contentContainerHorizontal: {
+    flexDirection: "row"
+  },
+  contentContainerCenterContent: {
+    justifyContent: "center",
+    flexGrow: 1
+  },
+  stickyHeader: {
+    position: "sticky",
+    top: 0,
+    zIndex: 10
+  },
+  pagingEnabledHorizontal: {
+    scrollSnapType: "x mandatory"
+  },
+  pagingEnabledVertical: {
+    scrollSnapType: "y mandatory"
+  },
+  pagingEnabledChild: {
+    scrollSnapAlign: "start"
+  }
+}, ForwardedScrollView = import_react.default.forwardRef((props, forwardedRef) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ScrollView, { ...props, forwardedRef }));
+ForwardedScrollView.displayName = "ScrollView";
+var ScrollView_default = ForwardedScrollView;
+//# sourceMappingURL=index.js.map

package/dist/cjs/ScrollView/index.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../src/ScrollView/index.tsx"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAWA,mBAAkB,2BAClB,oCASO,gDAEP,oBAAuB,yCACvB,cAAiB,mCACjB,wBAA2B,sCAoJX;AAlJhB,MAAM,cAAc,CAAC,GACf,wCAAwC;AAI9C,MAAM,mBAAmB,aAAAA,QAAM,UAAe;AAAA,EAC5C;AAAA,EACA;AAAA,EAEA,qBAA0B;AAAA,EAC1B,yBAAyB;AAAA,EACzB,aAAa;AAAA,EACb,8BAA8B;AAAA,EAC9B,4BAA4B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAO5B,uCAAuC;AAAA,EACvC,gCAAgC;AAAA,EAEhC,wBAAwB;AACtB,SAAK,qCAAqC;AAAA,EAC5C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,qBAAqB;AACnB,WAAO,KAAK;AAAA,EACd;AAAA,EAEA,oBAAoB;AAClB,WAAO,KAAK;AAAA,EACd;AAAA,EAEA,kBAAkB;AAChB,WAAO,KAAK;AAAA,EACd;AAAA,EAEA,mBAAmB;AACjB,WAAO,KAAK;AAAA,EACd;AAAA,EAEA,qBAAqB;AACnB,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYA,SACE,GACA,GACA,UACA;AACA,IAAI,OAAO,KAAM,WACf,QAAQ;AAAA,MACN;AAAA,IACF,IAGE,EAAE,GAAG,GAAG,SAAS,IAAI,KAAK,aAG9B,KAAK,mBAAmB,EAAE,wBAAwB;AAAA,MAChD,GAAG,KAAK;AAAA,MACR,GAAG,KAAK;AAAA,MACR,UAAU,aAAa;AAAA,IACzB,CAAC;AAAA,EACH;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUA,YAAY,SAAkC;AAE5C,UAAM,YAAY,WAAW,QAAQ,cAAc,IAC7C,EAAE,WAAW,IAAI,KAAK,OACtB,kBAAkB,KAAK,mBAAmB,GAC1C,sBAAsB,KAAK,gBAC3B,IAAI,aAAa,oBAAoB,cAAc,GACnD,IAAI,aAAa,IAAI,oBAAoB;AAC/C,oBAAgB,wBAAwB,EAAE,GAAG,GAAG,SAAS,CAAC;AAAA,EAC5D;AAAA,EAEA,SAAS;AACP,UAAM;AAAA,MACJ;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA;AAAA,MAEA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA;AAAA,MAEA,GAAG;AAAA,IACL,IAAI,KAAK;AAET,QAAI,QAAQ,IAAI,aAAa,gBAAgB,KAAK,MAAM,OAAO;AAC7D,YAAM,QAAQ,6CAAW,QAAQ,KAAK,MAAM,KAAK,GAC3C,mBAAmB,CAAC,cAAc,gBAAgB,EAAE;AAAA,QACxD,CAAC,SAAS,SAAS,MAAM,IAAI,MAAM;AAAA,MACrC;AACA;AAAA,QACE,iBAAiB,WAAW;AAAA,QAC5B,4BAA4B,KAAK,UAAU,gBAAgB,CAAC;AAAA,MAE9D;AAAA,IACF;AAEA,QAAI,yBAAyB,CAAC;AAC9B,IAAI,wBACF,yBAAyB;AAAA,MACvB,UAAU,KAAK,uBAAuB,KAAK,IAAI;AAAA,IACjD;AAGF,UAAM,yBAAyB,CAAC,cAAc,MAAM,QAAQ,mBAAmB,GACzE,WACJ,0BAA0B,gBACtB,aAAAA,QAAM,SAAS,IAAI,KAAK,MAAM,UAAU,CAAC,OAAO,MAAM;AACpD,YAAM,WAAW,0BAA0B,oBAAoB,QAAQ,CAAC,IAAI;AAC5E,aAAI,SAAS,SAAS,YAAY,iBAE9B;AAAA,QAAC,YAAAC;AAAA,QAAA;AAAA,UACC,OAAO,6CAAW;AAAA,YAChB,YAAY,OAAO;AAAA,YACnB,iBAAiB,OAAO;AAAA,UAC1B;AAAA,UAEC;AAAA;AAAA,MACH,IAGK;AAAA,IAEX,CAAC,IACD,KAAK,MAAM,UAEX,mBACJ;AAAA,MAAC,YAAAA;AAAA,MAAA;AAAA,QACE,GAAG;AAAA,QAEJ,aAAa;AAAA,QACb,KAAK,KAAK,iBAAiB,KAAK,IAAI;AAAA,QACpC,OAAO;AAAA,UACL,cAAc,OAAO;AAAA,UACrB,iBAAiB,OAAO;AAAA,UACxB;AAAA,QACF;AAAA,QAEC;AAAA;AAAA,IACH,GAGI,YAAY,aAAa,OAAO,iBAAiB,OAAO,cACxD,qBAAqB,aACvB,OAAO,0BACP,OAAO,uBAEL,QAAQ;AAAA,MACZ,GAAG;AAAA,MACH,OAAO,CAAC,WAAW,iBAAiB,oBAAoB,KAAK,MAAM,KAAK;AAAA,MACxE,cAAc,KAAK,gCAAgC,KAAK,IAAI;AAAA,MAC5D,aAAa,KAAK,+BAA+B,KAAK,IAAI;AAAA,MAC1D,YAAY,KAAK,8BAA8B,KAAK,IAAI;AAAA,MACxD,mBAAmB,KAAK,qCAAqC,KAAK,IAAI;AAAA,MACtE,iBAAiB,KAAK,mCAAmC,KAAK,IAAI;AAAA,MAClE,uBAAuB,KAAK,yCAAyC,KAAK,IAAI;AAAA,MAC9E,qBAAqB,KAAK,uCAAuC,KAAK,IAAI;AAAA,MAC1E,2BACE,KAAK,6CAA6C,KAAK,IAAI;AAAA,MAC7D,kCACE,KAAK,oDAAoD,KAAK,IAAI;AAAA,MACpE,4BACE,KAAK,8CAA8C,KAAK,IAAI;AAAA,MAC9D,UAAU,KAAK,cAAc,KAAK,IAAI;AAAA,MACtC,kBAAkB,KAAK,oCAAoC,KAAK,IAAI;AAAA,MACpE,+BACE,KAAK,wCAAwC,KAAK,IAAI;AAAA,MACxD,oBAAoB,KAAK,sCAAsC,KAAK,IAAI;AAAA,MACxE,mBAAmB,KAAK,qCAAqC,KAAK,IAAI;AAAA,IACxE,GAEM,kBAAkB,sBAAAC;AAExB,qDAAU,oBAAoB,QAAW,uCAAuC;AAEhF,UAAM,aACJ,4CAAC,mBAAiB,GAAG,OAAO,KAAK,KAAK,kBAAkB,KAAK,IAAI,GAC9D,4BACH;AAGF,WAAI,iBACK,aAAAF,QAAM,aAAa,gBAAgB,EAAE,OAAO,MAAM,MAAM,GAAG,UAAU,IAGvE;AAAA,EACT;AAAA,EAEA,uBAAuB,GAAQ;AAC7B,UAAM,EAAE,OAAO,OAAO,IAAI,EAAE,YAAY;AACxC,SAAK,MAAM,oBAAoB,OAAO,MAAM;AAAA,EAC9C;AAAA,EAEA,cAAc,GAAW;AACvB,IAAI,QAAQ,IAAI,aAAa,gBACvB,KAAK,MAAM,YAAY,KAAK,MAAM,uBAAuB,QAC3D,QAAQ;AAAA,MACN;AAAA,IAKF,GAIA,KAAK,MAAM,wBAAwB,iBACrC,mDAAgB,GAGlB,KAAK,4BAA4B,CAAC;AAAA,EACpC;AAAA,EAEA,iBAAiB,MAAM;AACrB,SAAK,gBAAgB;AAAA,EACvB;AAAA,EAEA,kBAAkB,MAAM;AACtB,SAAK,iBAAiB,MAIlB,QAAQ,SACV,KAAK,qBAAqB,KAAK,oBAC/B,KAAK,mBAAmB,KAAK,kBAC7B,KAAK,kBAAkB,KAAK,iBAC5B,KAAK,qBAAqB,KAAK,oBAC/B,KAAK,oBAAoB,KAAK,mBAC9B,KAAK,WAAW,KAAK,UACrB,KAAK,cAAc,KAAK,aACxB,KAAK,wBAAwB,KAAK,uBAClC,KAAK,wBAAwB,KAAK,uBAClC,KAAK,8CACH,KAAK,kDAEG,6CAAU,KAAK,MAAM,YAAY,EACzC,IAAI;AAAA,EACV;AAAA;AAAA;AAAA;AAAA,EAKA,gDAAyD;AACvD,WAAO,KAAK;AAAA,EACd;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EA2BA,+CAAwD;AACtD,WAAO;AAAA,EACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAaA,oDAAoD,GAAmB;AAQrE,WAAO,KAAK,2BAA2B;AAAA,EACzC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYA,uCAAuC;AACrC,mDAAQ,IAAO,yDAAyD;AAAA,EAC1E;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAiBA,0CAAmD;AACjD,WAAO,CAAC,KAAK;AAAA,EACf;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,8BAA8B,GAAU;AACtC,UAAM,cAAc,EAAE;AACtB,SAAK,aAAa,YAAY,QAAQ,WAAW,GACjD,KAAK,MAAM,cAAc,KAAK,MAAM,WAAW,CAAC;AAAA,EAClD;AAAA;AAAA;AAAA;AAAA,EAKA,sCAAsC,GAAU;AAC9C,SAAK,MAAM,sBAAsB,KAAK,MAAM,mBAAmB,CAAC;AAIhE,UAAM,4BAA4B,iDAAe,sBAAsB;AACvE,IACE,CAAC,KAAK,MAAM,6BACZ,6BAA6B,QAC7B,EAAE,WAAW,6BACb,CAAC,KAAK,wCACN,CAAC,KAAK,kCAEN,KAAK,MAAM,sCACT,KAAK,MAAM,mCAAmC,CAAC,GACjD,iDAAe,cAAc,yBAAyB;AAAA,EAE1D;AAAA,EAEA,4BAA4B,GAAU;AACpC,SAAK,uCAAuC,IAC5C,KAAK,MAAM,YAAY,KAAK,MAAM,SAAS,CAAC;AAAA,EAC9C;AAAA;AAAA;AAAA;AAAA,EAKA,oCAAoC,GAAU;AAC5C,SAAK,uCAAuC,IAC5C,KAAK,MAAM,oBAAoB,KAAK,MAAM,iBAAiB,CAAC,GAC5D,KAAK,gCAAgC,KAAK,2BAA2B;AAAA,EACvE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,qCAAqC,GAAU;AAC7C,SAAK,MAAM,qBAAqB,KAAK,MAAM,kBAAkB,CAAC;AAAA,EAChE;AAAA;AAAA;AAAA;AAAA,EAKA,mCAAmC,GAAU;AAC3C,SAAK,MAAM,mBAAmB,KAAK,MAAM,gBAAgB,CAAC;AAAA,EAC5D;AAAA;AAAA;AAAA;AAAA,EAKA,yCAAyC,GAAU;AACjD,SAAK,8BAA8B,KAAK,IAAI,GAC5C,KAAK,MAAM,yBAAyB,KAAK,MAAM,sBAAsB,CAAC;AAAA,EACxE;AAAA;AAAA;AAAA;AAAA,EAKA,uCAAuC,GAAU;AAC/C,SAAK,4BAA4B,KAAK,IAAI,GAC1C,KAAK,MAAM,uBAAuB,KAAK,MAAM,oBAAoB,CAAC;AAAA,EACpE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAaA,gCAAgC,GAAU;AACxC,SAAK,aAAa,IAClB,KAAK,MAAM,gBAAgB,KAAK,MAAM,aAAa,CAAC;AAAA,EACtD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAaA,+BAA+B,GAAU;AACvC,SAAK,MAAM,eAAe,KAAK,MAAM,YAAY,CAAC;AAAA,EACpD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,6BAAsC;AAMpC,WALY,KAAK,IAAI,IACwB,KAAK,4BAEf,yCACjC,KAAK,4BAA4B,KAAK;AAAA,EAE1C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAaA,wBACE,GAOA,GACA,UACA;AACA,IAAI,OAAO,KAAM,WACf,QAAQ;AAAA,MACN;AAAA,IACF,IAEE,EAAE,GAAG,GAAG,SAAS,IAAI,KAAK;AAE9B,UAAM,OAAO,KAAK,QAAQ,kBAAkB,GACtC,OAAO,KAAK,GACZ,MAAM,KAAK;AACjB,IAAI,OAAO,KAAK,UAAW,aACzB,KAAK,OAAO,EAAE,KAAK,MAAM,UAAW,WAAoB,WAAT,OAAkB,CAAC,KAElE,KAAK,aAAa,MAClB,KAAK,YAAY;AAAA,EAErB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,sBACE,MAOA,UACA;AACA,IAAI,2CAAS,OAAO,aAClB,6CAAU,+BAA+B;AAAA,EAE7C;AAAA;AAAA;AAAA;AAAA,EAKA,uCAAuC;AAAA,EAAC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYxC,8CAA8C,CAC5C,YACA,kBACA,gCACG;AACH,SAAK,yBAAyB,oBAAoB,GAClD,KAAK,8BAA8B,CAAC,CAAC,6BACrC,4CAAU;AAAA,MACR;AAAA,MACA,KAAK,QAAQ,iBAAiB;AAAA,MAC9B,KAAK;AAAA,MACL,KAAK;AAAA,IACP;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYA,iDAAiD,CAC/C,MACA,KACA,OACA,WACG;AACH,QAAI,kBAAkB,kBAAAG,QAAW,IAAI,QAAQ,EAAE;AAC/C,IAAI,KAAK,uBACP,kBAAkB,KAAK,mBAAmB,eAAe;AAE3D,QAAI,gBAAgB,MAAM,kBAAkB,SAAS,KAAK;AAM1D,IAAI,KAAK,gCACP,gBAAgB,KAAK,IAAI,GAAG,aAAa,IAE3C,KAAK,wBAAwB,EAAE,GAAG,GAAG,GAAG,eAAe,UAAU,GAAK,CAAC,GAEvE,KAAK,mBAAmB,GACxB,KAAK,8BAA8B;AAAA,EACrC;AAAA,EAEA,mCAAmC,GAAU;AAC3C,YAAQ,MAAM,gCAAgC,CAAC;AAAA,EACjD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EA8BA,gCAAgC,GAAU;AACxC,SAAK,qBAAqB,GAC1B,KAAK,MAAM,sBAAsB,KAAK,MAAM,mBAAmB,CAAC;AAAA,EAClE;AAAA,EAEA,gCAAgC,GAAU;AACxC,SAAK,qBAAqB,MAC1B,KAAK,MAAM,sBAAsB,KAAK,MAAM,mBAAmB,CAAC;AAAA,EAClE;AAAA,EAEA,+BAA+B,GAAU;AAGvC,IAAI,MACF,KAAK,qBAAqB,IAE5B,KAAK,MAAM,qBAAqB,KAAK,MAAM,kBAAkB,CAAC;AAAA,EAChE;AAAA,EAEA,+BAA+B,GAAU;AACvC,SAAK,qBAAqB,MAC1B,KAAK,MAAM,qBAAqB,KAAK,MAAM,kBAAkB,CAAC;AAAA,EAChE;AACF;AAEA,MAAM,cAAc;AAAA,EAClB,UAAU;AAAA,EACV,YAAY;AAAA;AAAA;AAAA;AAAA,EAIZ,WAAW,CAAC,EAAE,YAAY,EAAE,CAAC;AAAA;AAAA,EAE7B,yBAAyB;AAC3B,GAEM,SAAS;AAAA,EACb,cAAc;AAAA,IACZ,GAAG;AAAA,IACH,eAAe;AAAA,IACf,WAAW;AAAA,IACX,WAAW;AAAA,EACb;AAAA,EACA,gBAAgB;AAAA,IACd,GAAG;AAAA,IACH,eAAe;AAAA,IACf,WAAW;AAAA,IACX,WAAW;AAAA,EACb;AAAA,EACA,4BAA4B;AAAA,IAC1B,eAAe;AAAA,EACjB;AAAA,EACA,+BAA+B;AAAA,IAC7B,gBAAgB;AAAA,IAChB,UAAU;AAAA,EACZ;AAAA,EACA,cAAc;AAAA,IACZ,UAAU;AAAA,IACV,KAAK;AAAA,IACL,QAAQ;AAAA,EACV;AAAA,EACA,yBAAyB;AAAA,IACvB,gBAAgB;AAAA,EAClB;AAAA,EACA,uBAAuB;AAAA,IACrB,gBAAgB;AAAA,EAClB;AAAA,EACA,oBAAoB;AAAA,IAClB,iBAAiB;AAAA,EACnB;AACF,GAEM,sBAAsB,aAAAH,QAAM,WAAW,CAAC,OAAO,iBAC5C,4CAAC,cAAY,GAAG,OAAO,cAA4B,CAC3D;AAED,oBAAoB,cAAc;AAElC,IAAO,qBAAQ;",
+  "names": ["React", "View", "ScrollViewBase", "Dimensions"]
+}