yeet

node_modules/react-native/Libraries/Components/AccessibilityInfo/AccessibilityInfo.android.js

@@ -0,0 +1,162 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @flow
+ */
+
+'use strict';
+
+const RCTDeviceEventEmitter = require('../../EventEmitter/RCTDeviceEventEmitter');
+const UIManager = require('../../ReactNative/UIManager');
+
+import NativeAccessibilityInfo from './NativeAccessibilityInfo';
+
+const REDUCE_MOTION_EVENT = 'reduceMotionDidChange';
+const TOUCH_EXPLORATION_EVENT = 'touchExplorationDidChange';
+
+type ChangeEventName = $Keys<{
+  change: string,
+  reduceMotionChanged: string,
+  screenReaderChanged: string,
+  ...
+}>;
+
+const _subscriptions = new Map();
+
+/**
+ * Sometimes it's useful to know whether or not the device has a screen reader
+ * that is currently active. The `AccessibilityInfo` API is designed for this
+ * purpose. You can use it to query the current state of the screen reader as
+ * well as to register to be notified when the state of the screen reader
+ * changes.
+ *
+ * See https://reactnative.dev/docs/accessibilityinfo.html
+ */
+
+const AccessibilityInfo = {
+  /**
+   * iOS only
+   */
+  isBoldTextEnabled: function(): Promise<boolean> {
+    return Promise.resolve(false);
+  },
+
+  /**
+   * iOS only
+   */
+  isGrayscaleEnabled: function(): Promise<boolean> {
+    return Promise.resolve(false);
+  },
+
+  /**
+   * iOS only
+   */
+  isInvertColorsEnabled: function(): Promise<boolean> {
+    return Promise.resolve(false);
+  },
+
+  isReduceMotionEnabled: function(): Promise<boolean> {
+    return new Promise((resolve, reject) => {
+      if (NativeAccessibilityInfo) {
+        NativeAccessibilityInfo.isReduceMotionEnabled(resolve);
+      } else {
+        reject(false);
+      }
+    });
+  },
+
+  /**
+   * iOS only
+   */
+  isReduceTransparencyEnabled: function(): Promise<boolean> {
+    return Promise.resolve(false);
+  },
+
+  isScreenReaderEnabled: function(): Promise<boolean> {
+    return new Promise((resolve, reject) => {
+      if (NativeAccessibilityInfo) {
+        NativeAccessibilityInfo.isTouchExplorationEnabled(resolve);
+      } else {
+        reject(false);
+      }
+    });
+  },
+
+  /**
+   * Deprecated
+   *
+   * Same as `isScreenReaderEnabled`
+   */
+  get fetch(): () => Promise<boolean> {
+    console.warn(
+      'AccessibilityInfo.fetch is deprecated, call AccessibilityInfo.isScreenReaderEnabled instead',
+    );
+    return this.isScreenReaderEnabled;
+  },
+
+  addEventListener: function(
+    eventName: ChangeEventName,
+    handler: Function,
+  ): void {
+    let listener;
+
+    if (eventName === 'change' || eventName === 'screenReaderChanged') {
+      listener = RCTDeviceEventEmitter.addListener(
+        TOUCH_EXPLORATION_EVENT,
+        enabled => {
+          handler(enabled);
+        },
+      );
+    } else if (eventName === 'reduceMotionChanged') {
+      listener = RCTDeviceEventEmitter.addListener(
+        REDUCE_MOTION_EVENT,
+        enabled => {
+          handler(enabled);
+        },
+      );
+    }
+
+    _subscriptions.set(handler, listener);
+  },
+
+  removeEventListener: function(
+    eventName: ChangeEventName,
+    handler: Function,
+  ): void {
+    const listener = _subscriptions.get(handler);
+    if (!listener) {
+      return;
+    }
+    listener.remove();
+    _subscriptions.delete(handler);
+  },
+
+  /**
+   * Set accessibility focus to a react component.
+   *
+   * See https://reactnative.dev/docs/accessibilityinfo.html#setaccessibilityfocus
+   */
+  setAccessibilityFocus: function(reactTag: number): void {
+    UIManager.sendAccessibilityEvent(
+      reactTag,
+      UIManager.getConstants().AccessibilityEventTypes.typeViewFocused,
+    );
+  },
+
+  /**
+   * Post a string to be announced by the screen reader.
+   *
+   * See https://reactnative.dev/docs/accessibilityinfo.html#announceforaccessibility
+   */
+  announceForAccessibility: function(announcement: string): void {
+    if (NativeAccessibilityInfo) {
+      NativeAccessibilityInfo.announceForAccessibility(announcement);
+    }
+  },
+};
+
+module.exports = AccessibilityInfo;

node_modules/react-native/Libraries/Components/AccessibilityInfo/AccessibilityInfo.ios.js

@@ -0,0 +1,271 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @flow
+ */
+
+'use strict';
+
+const Promise = require('../../Promise');
+const RCTDeviceEventEmitter = require('../../EventEmitter/RCTDeviceEventEmitter');
+
+import NativeAccessibilityManager from './NativeAccessibilityManager';
+
+const CHANGE_EVENT_NAME = {
+  announcementFinished: 'announcementFinished',
+  boldTextChanged: 'boldTextChanged',
+  grayscaleChanged: 'grayscaleChanged',
+  invertColorsChanged: 'invertColorsChanged',
+  reduceMotionChanged: 'reduceMotionChanged',
+  reduceTransparencyChanged: 'reduceTransparencyChanged',
+  screenReaderChanged: 'screenReaderChanged',
+};
+
+type ChangeEventName = $Keys<{
+  announcementFinished: string,
+  boldTextChanged: string,
+  change: string,
+  grayscaleChanged: string,
+  invertColorsChanged: string,
+  reduceMotionChanged: string,
+  reduceTransparencyChanged: string,
+  screenReaderChanged: string,
+  ...
+}>;
+
+const _subscriptions = new Map();
+
+/**
+ * Sometimes it's useful to know whether or not the device has a screen reader
+ * that is currently active. The `AccessibilityInfo` API is designed for this
+ * purpose. You can use it to query the current state of the screen reader as
+ * well as to register to be notified when the state of the screen reader
+ * changes.
+ *
+ * See https://reactnative.dev/docs/accessibilityinfo.html
+ */
+const AccessibilityInfo = {
+  /**
+   * Query whether bold text is currently enabled.
+   *
+   * Returns a promise which resolves to a boolean.
+   * The result is `true` when bold text is enabled and `false` otherwise.
+   *
+   * See https://reactnative.dev/docs/accessibilityinfo.html#isBoldTextEnabled
+   */
+  isBoldTextEnabled: function(): Promise<boolean> {
+    return new Promise((resolve, reject) => {
+      if (NativeAccessibilityManager) {
+        NativeAccessibilityManager.getCurrentBoldTextState(resolve, reject);
+      } else {
+        reject(reject);
+      }
+    });
+  },
+
+  /**
+   * Query whether grayscale is currently enabled.
+   *
+   * Returns a promise which resolves to a boolean.
+   * The result is `true` when grayscale is enabled and `false` otherwise.
+   *
+   * See https://reactnative.dev/docs/accessibilityinfo.html#isGrayscaleEnabled
+   */
+  isGrayscaleEnabled: function(): Promise<boolean> {
+    return new Promise((resolve, reject) => {
+      if (NativeAccessibilityManager) {
+        NativeAccessibilityManager.getCurrentGrayscaleState(resolve, reject);
+      } else {
+        reject(reject);
+      }
+    });
+  },
+
+  /**
+   * Query whether inverted colors are currently enabled.
+   *
+   * Returns a promise which resolves to a boolean.
+   * The result is `true` when invert color is enabled and `false` otherwise.
+   *
+   * See https://reactnative.dev/docs/accessibilityinfo.html#isInvertColorsEnabled
+   */
+  isInvertColorsEnabled: function(): Promise<boolean> {
+    return new Promise((resolve, reject) => {
+      if (NativeAccessibilityManager) {
+        NativeAccessibilityManager.getCurrentInvertColorsState(resolve, reject);
+      } else {
+        reject(reject);
+      }
+    });
+  },
+
+  /**
+   * Query whether reduced motion is currently enabled.
+   *
+   * Returns a promise which resolves to a boolean.
+   * The result is `true` when a reduce motion is enabled and `false` otherwise.
+   *
+   * See https://reactnative.dev/docs/accessibilityinfo.html#isReduceMotionEnabled
+   */
+  isReduceMotionEnabled: function(): Promise<boolean> {
+    return new Promise((resolve, reject) => {
+      if (NativeAccessibilityManager) {
+        NativeAccessibilityManager.getCurrentReduceMotionState(resolve, reject);
+      } else {
+        reject(reject);
+      }
+    });
+  },
+
+  /**
+   * Query whether reduced transparency is currently enabled.
+   *
+   * Returns a promise which resolves to a boolean.
+   * The result is `true` when a reduce transparency is enabled and `false` otherwise.
+   *
+   * See https://reactnative.dev/docs/accessibilityinfo.html#isReduceTransparencyEnabled
+   */
+  isReduceTransparencyEnabled: function(): Promise<boolean> {
+    return new Promise((resolve, reject) => {
+      if (NativeAccessibilityManager) {
+        NativeAccessibilityManager.getCurrentReduceTransparencyState(
+          resolve,
+          reject,
+        );
+      } else {
+        reject(reject);
+      }
+    });
+  },
+
+  /**
+   * Query whether a screen reader is currently enabled.
+   *
+   * Returns a promise which resolves to a boolean.
+   * The result is `true` when a screen reader is enabled and `false` otherwise.
+   *
+   * See https://reactnative.dev/docs/accessibilityinfo.html#isScreenReaderEnabled
+   */
+  isScreenReaderEnabled: function(): Promise<boolean> {
+    return new Promise((resolve, reject) => {
+      if (NativeAccessibilityManager) {
+        NativeAccessibilityManager.getCurrentVoiceOverState(resolve, reject);
+      } else {
+        reject(reject);
+      }
+    });
+  },
+
+  /**
+   * Deprecated
+   *
+   * Same as `isScreenReaderEnabled`
+   */
+  get fetch(): $FlowFixMe {
+    console.warn(
+      'AccessibilityInfo.fetch is deprecated, call AccessibilityInfo.isScreenReaderEnabled instead',
+    );
+    return this.isScreenReaderEnabled;
+  },
+
+  /**
+   * Add an event handler. Supported events:
+   *
+   * - `boldTextChanged`: iOS-only event. Fires when the state of the bold text toggle changes.
+   *   The argument to the event handler is a boolean. The boolean is `true` when a bold text
+   *   is enabled and `false` otherwise.
+   * - `grayscaleChanged`: iOS-only event. Fires when the state of the gray scale toggle changes.
+   *   The argument to the event handler is a boolean. The boolean is `true` when a gray scale
+   *   is enabled and `false` otherwise.
+   * - `invertColorsChanged`: iOS-only event. Fires when the state of the invert colors toggle
+   *   changes. The argument to the event handler is a boolean. The boolean is `true` when a invert
+   *   colors is enabled and `false` otherwise.
+   * - `reduceMotionChanged`: Fires when the state of the reduce motion toggle changes.
+   *   The argument to the event handler is a boolean. The boolean is `true` when a reduce
+   *   motion is enabled (or when "Transition Animation Scale" in "Developer options" is
+   *   "Animation off") and `false` otherwise.
+   * - `reduceTransparencyChanged`: iOS-only event. Fires when the state of the reduce transparency
+   *   toggle changes.  The argument to the event handler is a boolean. The boolean is `true`
+   *   when a reduce transparency is enabled and `false` otherwise.
+   * - `screenReaderChanged`: Fires when the state of the screen reader changes. The argument
+   *   to the event handler is a boolean. The boolean is `true` when a screen
+   *   reader is enabled and `false` otherwise.
+   * - `announcementFinished`: iOS-only event. Fires when the screen reader has
+   *   finished making an announcement. The argument to the event handler is a
+   *   dictionary with these keys:
+   *     - `announcement`: The string announced by the screen reader.
+   *     - `success`: A boolean indicating whether the announcement was
+   *       successfully made.
+   *
+   * See https://reactnative.dev/docs/accessibilityinfo.html#addeventlistener
+   */
+  addEventListener: function(
+    eventName: ChangeEventName,
+    handler: Function,
+  ): Object {
+    let listener;
+
+    if (eventName === 'change') {
+      listener = RCTDeviceEventEmitter.addListener(
+        CHANGE_EVENT_NAME.screenReaderChanged,
+        handler,
+      );
+    } else if (CHANGE_EVENT_NAME[eventName]) {
+      listener = RCTDeviceEventEmitter.addListener(eventName, handler);
+    }
+
+    _subscriptions.set(handler, listener);
+    return {
+      remove: AccessibilityInfo.removeEventListener.bind(
+        null,
+        eventName,
+        handler,
+      ),
+    };
+  },
+
+  /**
+   * Set accessibility focus to a react component.
+   *
+   * See https://reactnative.dev/docs/accessibilityinfo.html#setaccessibilityfocus
+   */
+  setAccessibilityFocus: function(reactTag: number): void {
+    if (NativeAccessibilityManager) {
+      NativeAccessibilityManager.setAccessibilityFocus(reactTag);
+    }
+  },
+
+  /**
+   * Post a string to be announced by the screen reader.
+   *
+   * See https://reactnative.dev/docs/accessibilityinfo.html#announceforaccessibility
+   */
+  announceForAccessibility: function(announcement: string): void {
+    if (NativeAccessibilityManager) {
+      NativeAccessibilityManager.announceForAccessibility(announcement);
+    }
+  },
+
+  /**
+   * Remove an event handler.
+   *
+   * See https://reactnative.dev/docs/accessibilityinfo.html#removeeventlistener
+   */
+  removeEventListener: function(
+    eventName: ChangeEventName,
+    handler: Function,
+  ): void {
+    const listener = _subscriptions.get(handler);
+    if (!listener) {
+      return;
+    }
+    listener.remove();
+    _subscriptions.delete(handler);
+  },
+};
+
+module.exports = AccessibilityInfo;

node_modules/react-native/Libraries/Components/AccessibilityInfo/NativeAccessibilityInfo.js

@@ -0,0 +1,27 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+'use strict';
+
+import type {TurboModule} from '../../TurboModule/RCTExport';
+import * as TurboModuleRegistry from '../../TurboModule/TurboModuleRegistry';
+
+export interface Spec extends TurboModule {
+  +isReduceMotionEnabled: (
+    onSuccess: (isReduceMotionEnabled: boolean) => void,
+  ) => void;
+  +isTouchExplorationEnabled: (
+    onSuccess: (isScreenReaderEnabled: boolean) => void,
+  ) => void;
+  +setAccessibilityFocus: (reactTag: number) => void;
+  +announceForAccessibility: (announcement: string) => void;
+}
+
+export default (TurboModuleRegistry.get<Spec>('AccessibilityInfo'): ?Spec);

node_modules/react-native/Libraries/Components/AccessibilityInfo/NativeAccessibilityManager.js

@@ -0,0 +1,59 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow
+ * @format
+ */
+
+'use strict';
+
+import type {TurboModule} from '../../TurboModule/RCTExport';
+import * as TurboModuleRegistry from '../../TurboModule/TurboModuleRegistry';
+
+export interface Spec extends TurboModule {
+  +getCurrentBoldTextState: (
+    onSuccess: (isBoldTextEnabled: boolean) => void,
+    onError: (error: Object) => void,
+  ) => void;
+  +getCurrentGrayscaleState: (
+    onSuccess: (isGrayscaleEnabled: boolean) => void,
+    onError: (error: Object) => void,
+  ) => void;
+  +getCurrentInvertColorsState: (
+    onSuccess: (isInvertColorsEnabled: boolean) => void,
+    onError: (error: Object) => void,
+  ) => void;
+  +getCurrentReduceMotionState: (
+    onSuccess: (isReduceMotionEnabled: boolean) => void,
+    onError: (error: Object) => void,
+  ) => void;
+  +getCurrentReduceTransparencyState: (
+    onSuccess: (isReduceTransparencyEnabled: boolean) => void,
+    onError: (error: Object) => void,
+  ) => void;
+  +getCurrentVoiceOverState: (
+    onSuccess: (isScreenReaderEnabled: boolean) => void,
+    onError: (error: Object) => void,
+  ) => void;
+  +setAccessibilityContentSizeMultipliers: (JSMultipliers: {|
+    +extraSmall?: ?number,
+    +small?: ?number,
+    +medium?: ?number,
+    +large?: ?number,
+    +extraLarge?: ?number,
+    +extraExtraLarge?: ?number,
+    +extraExtraExtraLarge?: ?number,
+    +accessibilityMedium?: ?number,
+    +accessibilityLarge?: ?number,
+    +accessibilityExtraLarge?: ?number,
+    +accessibilityExtraExtraLarge?: ?number,
+    +accessibilityExtraExtraExtraLarge?: ?number,
+  |}) => void;
+  +setAccessibilityFocus: (reactTag: number) => void;
+  +announceForAccessibility: (announcement: string) => void;
+}
+
+export default (TurboModuleRegistry.get<Spec>('AccessibilityManager'): ?Spec);

node_modules/react-native/Libraries/Components/ActivityIndicator/ActivityIndicator.js

@@ -0,0 +1,152 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @flow
+ */
+
+'use strict';
+
+const Platform = require('../../Utilities/Platform');
+const React = require('react');
+const StyleSheet = require('../../StyleSheet/StyleSheet');
+const View = require('../View/View');
+import type {HostComponent} from '../../Renderer/shims/ReactNativeTypes';
+import type {ViewProps} from '../View/ViewPropTypes';
+import type {ColorValue} from '../../StyleSheet/StyleSheetTypes';
+
+const PlatformActivityIndicator =
+  Platform.OS === 'android'
+    ? require('../ProgressBarAndroid/ProgressBarAndroid')
+    : require('./ActivityIndicatorViewNativeComponent').default;
+
+const GRAY = '#999999';
+
+type IndicatorSize = number | 'small' | 'large';
+
+type IOSProps = $ReadOnly<{|
+  /**
+   * Whether the indicator should hide when not animating (true by default).
+   *
+   * See https://reactnative.dev/docs/activityindicator.html#hideswhenstopped
+   */
+  hidesWhenStopped?: ?boolean,
+|}>;
+type Props = $ReadOnly<{|
+  ...ViewProps,
+  ...IOSProps,
+
+  /**
+   * Whether to show the indicator (true, the default) or hide it (false).
+   *
+   * See https://reactnative.dev/docs/activityindicator.html#animating
+   */
+  animating?: ?boolean,
+
+  /**
+   * The foreground color of the spinner (default is gray).
+   *
+   * See https://reactnative.dev/docs/activityindicator.html#color
+   */
+  color?: ?ColorValue,
+
+  /**
+   * Size of the indicator (default is 'small').
+   * Passing a number to the size prop is only supported on Android.
+   *
+   * See https://reactnative.dev/docs/activityindicator.html#size
+   */
+  size?: ?IndicatorSize,
+|}>;
+
+/**
+ * Displays a circular loading indicator.
+ *
+ * See https://reactnative.dev/docs/activityindicator.html
+ */
+const ActivityIndicator = (props: Props, forwardedRef?: any) => {
+  const {onLayout, style, size, ...restProps} = props;
+  let sizeStyle;
+  let sizeProp;
+
+  switch (size) {
+    case 'small':
+      sizeStyle = styles.sizeSmall;
+      sizeProp = 'small';
+      break;
+    case 'large':
+      sizeStyle = styles.sizeLarge;
+      sizeProp = 'large';
+      break;
+    default:
+      sizeStyle = {height: props.size, width: props.size};
+      break;
+  }
+
+  const nativeProps = {
+    ...restProps,
+    ref: forwardedRef,
+    style: sizeStyle,
+    size: sizeProp,
+  };
+
+  const androidProps = {
+    styleAttr: 'Normal',
+    indeterminate: true,
+  };
+
+  return (
+    <View
+      onLayout={onLayout}
+      style={StyleSheet.compose(
+        styles.container,
+        style,
+      )}>
+      {Platform.OS === 'android' ? (
+        // $FlowFixMe Flow doesn't know when this is the android component
+        <PlatformActivityIndicator {...nativeProps} {...androidProps} />
+      ) : (
+        /* $FlowFixMe(>=0.106.0 site=react_native_android_fb) This comment
+         * suppresses an error found when Flow v0.106 was deployed. To see the
+         * error, delete this comment and run Flow. */
+        <PlatformActivityIndicator {...nativeProps} />
+      )}
+    </View>
+  );
+};
+
+const ActivityIndicatorWithRef: React.AbstractComponent<
+  Props,
+  HostComponent<mixed>,
+> = React.forwardRef(ActivityIndicator);
+ActivityIndicatorWithRef.displayName = 'ActivityIndicator';
+
+/* $FlowFixMe(>=0.89.0 site=react_native_fb) This comment suppresses an error
+ * found when Flow v0.89 was deployed. To see the error, delete this comment
+ * and run Flow. */
+ActivityIndicatorWithRef.defaultProps = {
+  animating: true,
+  color: Platform.OS === 'ios' ? GRAY : null,
+  hidesWhenStopped: true,
+  size: 'small',
+};
+
+const styles = StyleSheet.create({
+  container: {
+    alignItems: 'center',
+    justifyContent: 'center',
+  },
+  sizeSmall: {
+    width: 20,
+    height: 20,
+  },
+  sizeLarge: {
+    width: 36,
+    height: 36,
+  },
+});
+
+module.exports = ActivityIndicatorWithRef;

node_modules/react-native/Libraries/Components/ActivityIndicator/ActivityIndicatorViewNativeComponent.js

@@ -0,0 +1,56 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @flow strict-local
+ */
+
+'use strict';
+
+import type {WithDefault} from '../../Types/CodegenTypes';
+
+import type {ColorValue} from '../../StyleSheet/StyleSheetTypes';
+import type {ViewProps} from '../View/ViewPropTypes';
+
+import codegenNativeComponent from '../../Utilities/codegenNativeComponent';
+import type {HostComponent} from '../../Renderer/shims/ReactNativeTypes';
+
+type NativeProps = $ReadOnly<{|
+  ...ViewProps,
+
+  /**
+   * Whether the indicator should hide when not animating (true by default).
+   *
+   * See https://reactnative.dev/docs/activityindicator.html#hideswhenstopped
+   */
+  hidesWhenStopped?: WithDefault<boolean, false>,
+
+  /**
+   * Whether to show the indicator (true, the default) or hide it (false).
+   *
+   * See https://reactnative.dev/docs/activityindicator.html#animating
+   */
+  animating?: WithDefault<boolean, false>,
+
+  /**
+   * The foreground color of the spinner (default is gray).
+   *
+   * See https://reactnative.dev/docs/activityindicator.html#color
+   */
+  color?: ?ColorValue,
+
+  /**
+   * Size of the indicator (default is 'small').
+   * Passing a number to the size prop is only supported on Android.
+   *
+   * See https://reactnative.dev/docs/activityindicator.html#size
+   */
+  size?: WithDefault<'small' | 'large', 'small'>,
+|}>;
+
+export default (codegenNativeComponent<NativeProps>('ActivityIndicatorView', {
+  paperComponentName: 'RCTActivityIndicatorView',
+}): HostComponent<NativeProps>);

node_modules/react-native/Libraries/Components/AppleTV/NativeTVNavigationEventEmitter.js

@@ -0,0 +1,23 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+'use strict';
+
+import type {TurboModule} from '../../TurboModule/RCTExport';
+import * as TurboModuleRegistry from '../../TurboModule/TurboModuleRegistry';
+
+export interface Spec extends TurboModule {
+  +addListener: (eventName: string) => void;
+  +removeListeners: (count: number) => void;
+}
+
+export default (TurboModuleRegistry.get<Spec>(
+  'TVNavigationEventEmitter',
+): ?Spec);

node_modules/react-native/Libraries/Components/AppleTV/TVEventHandler.js

@@ -0,0 +1,52 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @flow
+ */
+
+'use strict';
+
+const Platform = require('../../Utilities/Platform');
+const NativeEventEmitter = require('../../EventEmitter/NativeEventEmitter');
+
+import NativeTVNavigationEventEmitter from './NativeTVNavigationEventEmitter';
+import type EmitterSubscription from '../../vendor/emitter/EmitterSubscription';
+
+class TVEventHandler {
+  __nativeTVNavigationEventListener: ?EmitterSubscription = null;
+  __nativeTVNavigationEventEmitter: ?NativeEventEmitter = null;
+
+  enable(component: ?any, callback: Function): void {
+    if (Platform.OS === 'ios' && !NativeTVNavigationEventEmitter) {
+      return;
+    }
+
+    this.__nativeTVNavigationEventEmitter = new NativeEventEmitter(
+      NativeTVNavigationEventEmitter,
+    );
+    this.__nativeTVNavigationEventListener = this.__nativeTVNavigationEventEmitter.addListener(
+      'onHWKeyEvent',
+      data => {
+        if (callback) {
+          callback(component, data);
+        }
+      },
+    );
+  }
+
+  disable(): void {
+    if (this.__nativeTVNavigationEventListener) {
+      this.__nativeTVNavigationEventListener.remove();
+      delete this.__nativeTVNavigationEventListener;
+    }
+    if (this.__nativeTVNavigationEventEmitter) {
+      delete this.__nativeTVNavigationEventEmitter;
+    }
+  }
+}
+
+module.exports = TVEventHandler;

node_modules/react-native/Libraries/Components/Button.js

@@ -0,0 +1,238 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @flow
+ */
+
+'use strict';
+
+const Platform = require('../Utilities/Platform');
+const React = require('react');
+const StyleSheet = require('../StyleSheet/StyleSheet');
+const Text = require('../Text/Text');
+const TouchableNativeFeedback = require('./Touchable/TouchableNativeFeedback');
+const TouchableOpacity = require('./Touchable/TouchableOpacity');
+const View = require('./View/View');
+
+const invariant = require('invariant');
+
+import type {PressEvent} from '../Types/CoreEventTypes';
+import type {ColorValue} from '../StyleSheet/StyleSheetTypes';
+
+type ButtonProps = $ReadOnly<{|
+  /**
+   * Text to display inside the button
+   */
+  title: string,
+
+  /**
+   * Handler to be called when the user taps the button
+   */
+  onPress: (event?: PressEvent) => mixed,
+
+  /**
+   * If true, doesn't play system sound on touch (Android Only)
+   **/
+  touchSoundDisabled?: ?boolean,
+
+  /**
+   * Color of the text (iOS), or background color of the button (Android)
+   */
+  color?: ?ColorValue,
+
+  /**
+   * TV preferred focus (see documentation for the View component).
+   */
+  hasTVPreferredFocus?: ?boolean,
+
+  /**
+   * TV next focus down (see documentation for the View component).
+   *
+   * @platform android
+   */
+  nextFocusDown?: ?number,
+
+  /**
+   * TV next focus forward (see documentation for the View component).
+   *
+   * @platform android
+   */
+  nextFocusForward?: ?number,
+
+  /**
+   * TV next focus left (see documentation for the View component).
+   *
+   * @platform android
+   */
+  nextFocusLeft?: ?number,
+
+  /**
+   * TV next focus right (see documentation for the View component).
+   *
+   * @platform android
+   */
+  nextFocusRight?: ?number,
+
+  /**
+   * TV next focus up (see documentation for the View component).
+   *
+   * @platform android
+   */
+  nextFocusUp?: ?number,
+
+  /**
+   * Text to display for blindness accessibility features
+   */
+  accessibilityLabel?: ?string,
+
+  /**
+   * If true, disable all interactions for this component.
+   */
+  disabled?: ?boolean,
+
+  /**
+   * Used to locate this view in end-to-end tests.
+   */
+  testID?: ?string,
+|}>;
+
+/**
+ * A basic button component that should render nicely on any platform. Supports
+ * a minimal level of customization.
+ *
+ * <center><img src="img/buttonExample.png"></img></center>
+ *
+ * If this button doesn't look right for your app, you can build your own
+ * button using [TouchableOpacity](docs/touchableopacity.html)
+ * or [TouchableNativeFeedback](docs/touchablenativefeedback.html).
+ * For inspiration, look at the [source code for this button component](https://github.com/facebook/react-native/blob/master/Libraries/Components/Button.js).
+ * Or, take a look at the [wide variety of button components built by the community](https://js.coach/react-native?search=button).
+ *
+ * Example usage:
+ *
+ * ```
+ * import { Button } from 'react-native';
+ * ...
+ *
+ * <Button
+ *   onPress={onPressLearnMore}
+ *   title="Learn More"
+ *   color="#841584"
+ *   accessibilityLabel="Learn more about this purple button"
+ * />
+ * ```
+ *
+ */
+
+class Button extends React.Component<ButtonProps> {
+  render(): React.Node {
+    const {
+      accessibilityLabel,
+      color,
+      onPress,
+      touchSoundDisabled,
+      title,
+      hasTVPreferredFocus,
+      nextFocusDown,
+      nextFocusForward,
+      nextFocusLeft,
+      nextFocusRight,
+      nextFocusUp,
+      disabled,
+      testID,
+    } = this.props;
+    const buttonStyles = [styles.button];
+    const textStyles = [styles.text];
+    if (color) {
+      if (Platform.OS === 'ios') {
+        textStyles.push({color: color});
+      } else {
+        buttonStyles.push({backgroundColor: color});
+      }
+    }
+    const accessibilityState = {};
+    if (disabled) {
+      buttonStyles.push(styles.buttonDisabled);
+      textStyles.push(styles.textDisabled);
+      accessibilityState.disabled = true;
+    }
+    invariant(
+      typeof title === 'string',
+      'The title prop of a Button must be a string',
+    );
+    const formattedTitle =
+      Platform.OS === 'android' ? title.toUpperCase() : title;
+    const Touchable =
+      Platform.OS === 'android' ? TouchableNativeFeedback : TouchableOpacity;
+    return (
+      <Touchable
+        accessibilityLabel={accessibilityLabel}
+        accessibilityRole="button"
+        accessibilityState={accessibilityState}
+        hasTVPreferredFocus={hasTVPreferredFocus}
+        nextFocusDown={nextFocusDown}
+        nextFocusForward={nextFocusForward}
+        nextFocusLeft={nextFocusLeft}
+        nextFocusRight={nextFocusRight}
+        nextFocusUp={nextFocusUp}
+        testID={testID}
+        disabled={disabled}
+        onPress={onPress}
+        touchSoundDisabled={touchSoundDisabled}>
+        <View style={buttonStyles}>
+          <Text style={textStyles} disabled={disabled}>
+            {formattedTitle}
+          </Text>
+        </View>
+      </Touchable>
+    );
+  }
+}
+
+const styles = StyleSheet.create({
+  button: Platform.select({
+    ios: {},
+    android: {
+      elevation: 4,
+      // Material design blue from https://material.google.com/style/color.html#color-color-palette
+      backgroundColor: '#2196F3',
+      borderRadius: 2,
+    },
+  }),
+  text: {
+    textAlign: 'center',
+    margin: 8,
+    ...Platform.select({
+      ios: {
+        // iOS blue from https://developer.apple.com/ios/human-interface-guidelines/visual-design/color/
+        color: '#007AFF',
+        fontSize: 18,
+      },
+      android: {
+        color: 'white',
+        fontWeight: '500',
+      },
+    }),
+  },
+  buttonDisabled: Platform.select({
+    ios: {},
+    android: {
+      elevation: 0,
+      backgroundColor: '#dfdfdf',
+    },
+  }),
+  textDisabled: Platform.select({
+    ios: {
+      color: '#cdcdcd',
+    },
+    android: {
+      color: '#a1a1a1',
+    },
+  }),
+});
+
+module.exports = Button;

node_modules/react-native/Libraries/Components/CheckBox/AndroidCheckBoxNativeComponent.js

@@ -0,0 +1,74 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+'use strict';
+
+import * as React from 'react';
+
+import codegenNativeCommands from 'react-native/Libraries/Utilities/codegenNativeCommands';
+
+const requireNativeComponent = require('../../ReactNative/requireNativeComponent');
+
+import type {HostComponent} from '../../Renderer/shims/ReactNativeTypes';
+import type {ViewProps} from '../View/ViewPropTypes';
+import type {SyntheticEvent} from '../../Types/CoreEventTypes';
+import type {ProcessedColorValue} from '../../StyleSheet/processColor';
+
+type CheckBoxEvent = SyntheticEvent<
+  $ReadOnly<{|
+    target: number,
+    value: boolean,
+  |}>,
+>;
+
+type NativeProps = $ReadOnly<{|
+  ...ViewProps,
+
+  /**
+   * Used in case the props change removes the component.
+   */
+  onChange?: ?(event: CheckBoxEvent) => mixed,
+
+  /**
+   * Invoked with the new value when the value changes.
+   */
+  onValueChange?: ?(value: boolean) => mixed,
+
+  /**
+   * Used to locate this view in end-to-end tests.
+   */
+  testID?: ?string,
+
+  on?: ?boolean,
+  enabled?: boolean,
+  tintColors:
+    | {|
+        true: ?ProcessedColorValue,
+        false: ?ProcessedColorValue,
+      |}
+    | typeof undefined,
+|}>;
+
+type NativeType = HostComponent<NativeProps>;
+
+interface NativeCommands {
+  +setNativeValue: (
+    viewRef: React.ElementRef<NativeType>,
+    value: boolean,
+  ) => void;
+}
+
+export const Commands: NativeCommands = codegenNativeCommands<NativeCommands>({
+  supportedCommands: ['setNativeValue'],
+});
+
+export default (requireNativeComponent<NativeProps>(
+  'AndroidCheckBox',
+): NativeType);

node_modules/react-native/Libraries/Components/CheckBox/CheckBox.android.js

@@ -0,0 +1,228 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+'use strict';
+
+const React = require('react');
+const StyleSheet = require('../../StyleSheet/StyleSheet');
+const invariant = require('invariant');
+const processColor = require('../../StyleSheet/processColor');
+
+const nullthrows = require('nullthrows');
+const setAndForwardRef = require('../../Utilities/setAndForwardRef');
+
+import AndroidCheckBoxNativeComponent, {
+  Commands as AndroidCheckBoxCommands,
+} from './AndroidCheckBoxNativeComponent';
+
+import type {ViewProps} from '../View/ViewPropTypes';
+import type {SyntheticEvent} from '../../Types/CoreEventTypes';
+import type {ColorValue} from '../../StyleSheet/StyleSheetTypes';
+
+type CheckBoxEvent = SyntheticEvent<
+  $ReadOnly<{|
+    target: number,
+    value: boolean,
+  |}>,
+>;
+
+type CommonProps = $ReadOnly<{|
+  ...ViewProps,
+
+  /**
+   * Used in case the props change removes the component.
+   */
+  onChange?: ?(event: CheckBoxEvent) => mixed,
+
+  /**
+   * Invoked with the new value when the value changes.
+   */
+  onValueChange?: ?(value: boolean) => mixed,
+
+  /**
+   * Used to locate this view in end-to-end tests.
+   */
+  testID?: ?string,
+|}>;
+
+type Props = $ReadOnly<{|
+  ...CommonProps,
+
+  /**
+   * The value of the checkbox.  If true the checkbox will be turned on.
+   * Default value is false.
+   */
+  value?: ?boolean,
+
+  /**
+   * If true the user won't be able to toggle the checkbox.
+   * Default value is false.
+   */
+  disabled?: ?boolean,
+
+  /**
+   * Used to get the ref for the native checkbox
+   */
+  forwardedRef?: ?React.Ref<typeof AndroidCheckBoxNativeComponent>,
+
+  /**
+   * Controls the colors the checkbox has in checked and unchecked states.
+   */
+  tintColors?: {|true?: ?ColorValue, false?: ?ColorValue|},
+|}>;
+
+/**
+ * Renders a boolean input (Android only).
+ *
+ * This is a controlled component that requires an `onValueChange` callback that
+ * updates the `value` prop in order for the component to reflect user actions.
+ * If the `value` prop is not updated, the component will continue to render
+ * the supplied `value` prop instead of the expected result of any user actions.
+ *
+ * ```
+ * import React from 'react';
+ * import { AppRegistry, StyleSheet, Text, View, CheckBox } from 'react-native';
+ *
+ * export default class App extends React.Component {
+ *   constructor(props) {
+ *     super(props);
+ *     this.state = {
+ *       checked: false
+ *     }
+ *   }
+ *
+ *   toggle() {
+ *     this.setState(({checked}) => {
+ *       return {
+ *         checked: !checked
+ *       };
+ *     });
+ *   }
+ *
+ *   render() {
+ *     const {checked} = this.state;
+ *     return (
+ *       <View style={styles.container}>
+ *         <Text>Checked</Text>
+ *         <CheckBox value={checked} onChange={this.toggle.bind(this)} />
+ *       </View>
+ *     );
+ *   }
+ * }
+ *
+ * const styles = StyleSheet.create({
+ *   container: {
+ *     flex: 1,
+ *     flexDirection: 'row',
+ *     alignItems: 'center',
+ *     justifyContent: 'center',
+ *   },
+ * });
+ *
+ * // skip this line if using Create React Native App
+ * AppRegistry.registerComponent('App', () => App);
+ * ```
+ *
+ * @keyword checkbox
+ * @keyword toggle
+ */
+class CheckBox extends React.Component<Props> {
+  _nativeRef: ?React.ElementRef<typeof AndroidCheckBoxNativeComponent> = null;
+  _setNativeRef = setAndForwardRef({
+    getForwardedRef: () => this.props.forwardedRef,
+    setLocalRef: ref => {
+      this._nativeRef = ref;
+    },
+  });
+
+  _onChange = (event: CheckBoxEvent) => {
+    const value = this.props.value ?? false;
+    AndroidCheckBoxCommands.setNativeValue(nullthrows(this._nativeRef), value);
+    // Change the props after the native props are set in case the props
+    // change removes the component
+    this.props.onChange && this.props.onChange(event);
+    this.props.onValueChange &&
+      this.props.onValueChange(event.nativeEvent.value);
+  };
+
+  _getTintColors(tintColors) {
+    if (tintColors) {
+      const processedTextColorTrue = processColor(tintColors.true);
+      invariant(
+        processedTextColorTrue == null ||
+          typeof processedTextColorTrue === 'number',
+        'Unexpected color given for tintColors.true',
+      );
+      const processedTextColorFalse = processColor(tintColors.true);
+      invariant(
+        processedTextColorFalse == null ||
+          typeof processedTextColorFalse === 'number',
+        'Unexpected color given for tintColors.false',
+      );
+      return {
+        true: processedTextColorTrue,
+        false: processedTextColorFalse,
+      };
+    } else {
+      return undefined;
+    }
+  }
+
+  render() {
+    const {
+      disabled: _,
+      value: __,
+      tintColors,
+      style,
+      forwardedRef,
+      ...props
+    } = this.props;
+    const disabled = this.props.disabled ?? false;
+    const value = this.props.value ?? false;
+
+    const nativeProps = {
+      ...props,
+      onStartShouldSetResponder: () => true,
+      onResponderTerminationRequest: () => false,
+      enabled: !disabled,
+      on: value,
+      tintColors: this._getTintColors(tintColors),
+      style: [styles.rctCheckBox, style],
+    };
+    return (
+      <AndroidCheckBoxNativeComponent
+        {...nativeProps}
+        ref={this._setNativeRef}
+        onChange={this._onChange}
+      />
+    );
+  }
+}
+
+const styles = StyleSheet.create({
+  rctCheckBox: {
+    height: 32,
+    width: 32,
+  },
+});
+
+type CheckBoxType = React.AbstractComponent<
+  Props,
+  React.ElementRef<typeof AndroidCheckBoxNativeComponent>,
+>;
+
+const CheckBoxWithRef = React.forwardRef<
+  Props,
+  React.ElementRef<typeof AndroidCheckBoxNativeComponent>,
+>(function CheckBoxWithRef(props, ref) {
+  return <CheckBox {...props} forwardedRef={ref} />;
+});
+
+module.exports = (CheckBoxWithRef: CheckBoxType);

node_modules/react-native/Libraries/Components/CheckBox/CheckBox.ios.js

@@ -0,0 +1,13 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+'use strict';
+
+module.exports = require('../UnimplementedViews/UnimplementedView');

node_modules/react-native/Libraries/Components/Clipboard/Clipboard.js

@@ -0,0 +1,42 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @flow strict-local
+ */
+
+'use strict';
+
+import NativeClipboard from './NativeClipboard';
+
+/**
+ * `Clipboard` gives you an interface for setting and getting content from Clipboard on both iOS and Android
+ */
+module.exports = {
+  /**
+   * Get content of string type, this method returns a `Promise`, so you can use following code to get clipboard content
+   * ```javascript
+   * async _getContent() {
+   *   var content = await Clipboard.getString();
+   * }
+   * ```
+   */
+  getString(): Promise<string> {
+    return NativeClipboard.getString();
+  },
+  /**
+   * Set content of string type. You can use following code to set clipboard content
+   * ```javascript
+   * _setContent() {
+   *   Clipboard.setString('hello world');
+   * }
+   * ```
+   * @param the content to be stored in the clipboard.
+   */
+  setString(content: string) {
+    NativeClipboard.setString(content);
+  },
+};

node_modules/react-native/Libraries/Components/Clipboard/NativeClipboard.js

@@ -0,0 +1,22 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+'use strict';
+
+import type {TurboModule} from '../../TurboModule/RCTExport';
+import * as TurboModuleRegistry from '../../TurboModule/TurboModuleRegistry';
+
+export interface Spec extends TurboModule {
+  +getConstants: () => {||};
+  +getString: () => Promise<string>;
+  +setString: (content: string) => void;
+}
+
+export default (TurboModuleRegistry.getEnforcing<Spec>('Clipboard'): Spec);

node_modules/react-native/Libraries/Components/DatePicker/DatePickerIOS.android.js

@@ -0,0 +1,46 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ */
+
+'use strict';
+
+const React = require('react');
+const StyleSheet = require('../../StyleSheet/StyleSheet');
+const Text = require('../../Text/Text');
+const View = require('../View/View');
+
+class DummyDatePickerIOS extends React.Component {
+  render() {
+    return (
+      <View style={[styles.dummyDatePickerIOS, this.props.style]}>
+        <Text style={styles.datePickerText}>
+          DatePickerIOS is not supported on this platform!
+        </Text>
+      </View>
+    );
+  }
+}
+
+const styles = StyleSheet.create({
+  dummyDatePickerIOS: {
+    height: 100,
+    width: 300,
+    backgroundColor: '#ffbcbc',
+    borderWidth: 1,
+    borderColor: 'red',
+    alignItems: 'center',
+    justifyContent: 'center',
+    margin: 10,
+  },
+  datePickerText: {
+    color: '#333333',
+    margin: 20,
+  },
+});
+
+module.exports = DummyDatePickerIOS;

node_modules/react-native/Libraries/Components/DatePicker/DatePickerIOS.ios.js

@@ -0,0 +1,189 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @flow strict-local
+ */
+
+// This is a controlled component version of RCTDatePickerIOS.
+
+'use strict';
+
+import RCTDatePickerNativeComponent, {
+  Commands as DatePickerCommands,
+} from './RCTDatePickerNativeComponent';
+const React = require('react');
+const StyleSheet = require('../../StyleSheet/StyleSheet');
+const View = require('../View/View');
+
+const invariant = require('invariant');
+
+import type {SyntheticEvent} from '../../Types/CoreEventTypes';
+import type {ViewProps} from '../View/ViewPropTypes';
+
+type Event = SyntheticEvent<
+  $ReadOnly<{|
+    timestamp: number,
+  |}>,
+>;
+
+type Props = $ReadOnly<{|
+  ...ViewProps,
+
+  /**
+   * The currently selected date.
+   */
+  date?: ?Date,
+
+  /**
+   * Provides an initial value that will change when the user starts selecting
+   * a date. It is useful for simple use-cases where you do not want to deal
+   * with listening to events and updating the date prop to keep the
+   * controlled state in sync. The controlled state has known bugs which
+   * causes it to go out of sync with native. The initialDate prop is intended
+   * to allow you to have native be source of truth.
+   */
+  initialDate?: ?Date,
+
+  /**
+   * The date picker locale.
+   */
+  locale?: ?string,
+
+  /**
+   * Maximum date.
+   *
+   * Restricts the range of possible date/time values.
+   */
+  maximumDate?: ?Date,
+
+  /**
+   * Minimum date.
+   *
+   * Restricts the range of possible date/time values.
+   */
+  minimumDate?: ?Date,
+
+  /**
+   * The interval at which minutes can be selected.
+   */
+  minuteInterval?: ?(1 | 2 | 3 | 4 | 5 | 6 | 10 | 12 | 15 | 20 | 30),
+
+  /**
+   * The date picker mode.
+   */
+  mode?: ?('date' | 'time' | 'datetime'),
+
+  /**
+   * Date change handler.
+   *
+   * This is called when the user changes the date or time in the UI.
+   * The first and only argument is an Event. For getting the date the picker
+   * was changed to, use onDateChange instead.
+   */
+  onChange?: ?(event: Event) => void,
+
+  /**
+   * Date change handler.
+   *
+   * This is called when the user changes the date or time in the UI.
+   * The first and only argument is a Date object representing the new
+   * date and time.
+   */
+  onDateChange: (date: Date) => void,
+
+  /**
+   * Timezone offset in minutes.
+   *
+   * By default, the date picker will use the device's timezone. With this
+   * parameter, it is possible to force a certain timezone offset. For
+   * instance, to show times in Pacific Standard Time, pass -7 * 60.
+   */
+  timeZoneOffsetInMinutes?: ?number,
+|}>;
+
+/**
+ * Use `DatePickerIOS` to render a date/time picker (selector) on iOS.  This is
+ * a controlled component, so you must hook in to the `onDateChange` callback
+ * and update the `date` prop in order for the component to update, otherwise
+ * the user's change will be reverted immediately to reflect `props.date` as the
+ * source of truth.
+ */
+class DatePickerIOS extends React.Component<Props> {
+  static DefaultProps: {|mode: $TEMPORARY$string<'datetime'>|} = {
+    mode: 'datetime',
+  };
+
+  _picker: ?React.ElementRef<typeof RCTDatePickerNativeComponent> = null;
+
+  componentDidUpdate() {
+    if (this.props.date) {
+      const propsTimeStamp = this.props.date.getTime();
+      if (this._picker) {
+        DatePickerCommands.setNativeDate(this._picker, propsTimeStamp);
+      }
+    }
+  }
+
+  _onChange = (event: Event) => {
+    const nativeTimeStamp = event.nativeEvent.timestamp;
+    this.props.onDateChange &&
+      this.props.onDateChange(new Date(nativeTimeStamp));
+    this.props.onChange && this.props.onChange(event);
+    this.forceUpdate();
+  };
+
+  render(): React.Node {
+    const props = this.props;
+    invariant(
+      props.date || props.initialDate,
+      'A selected date or initial date should be specified.',
+    );
+    return (
+      <View style={props.style}>
+        <RCTDatePickerNativeComponent
+          testID={props.testID}
+          ref={picker => {
+            this._picker = picker;
+          }}
+          style={styles.datePickerIOS}
+          date={
+            props.date
+              ? props.date.getTime()
+              : props.initialDate
+              ? props.initialDate.getTime()
+              : undefined
+          }
+          locale={
+            props.locale != null && props.locale !== ''
+              ? props.locale
+              : undefined
+          }
+          maximumDate={
+            props.maximumDate ? props.maximumDate.getTime() : undefined
+          }
+          minimumDate={
+            props.minimumDate ? props.minimumDate.getTime() : undefined
+          }
+          mode={props.mode}
+          minuteInterval={props.minuteInterval}
+          timeZoneOffsetInMinutes={props.timeZoneOffsetInMinutes}
+          onChange={this._onChange}
+          onStartShouldSetResponder={() => true}
+          onResponderTerminationRequest={() => false}
+        />
+      </View>
+    );
+  }
+}
+
+const styles = StyleSheet.create({
+  datePickerIOS: {
+    height: 216,
+  },
+});
+
+module.exports = DatePickerIOS;

node_modules/react-native/Libraries/Components/DatePicker/RCTDatePickerNativeComponent.js

@@ -0,0 +1,60 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @flow strict-local
+ */
+
+'use strict';
+
+import type {HostComponent} from '../../Renderer/shims/ReactNativeTypes';
+import type {ViewProps} from '../View/ViewPropTypes';
+import codegenNativeCommands from 'react-native/Libraries/Utilities/codegenNativeCommands';
+import codegenNativeComponent from 'react-native/Libraries/Utilities/codegenNativeComponent';
+import * as React from 'react';
+import type {
+  Float,
+  WithDefault,
+  BubblingEventHandler,
+} from 'react-native/Libraries/Types/CodegenTypes';
+
+type Event = $ReadOnly<{|
+  timestamp: Float,
+|}>;
+
+type NativeProps = $ReadOnly<{|
+  ...ViewProps,
+  date?: ?Float,
+  initialDate?: ?Float,
+  locale?: ?string,
+  maximumDate?: ?Float,
+  minimumDate?: ?Float,
+  minuteInterval?: WithDefault<
+    1 | 2 | 3 | 4 | 5 | 6 | 10 | 12 | 15 | 20 | 30,
+    1,
+  >,
+  mode?: WithDefault<'date' | 'time' | 'datetime', 'date'>,
+  onChange?: ?BubblingEventHandler<Event>,
+  timeZoneOffsetInMinutes?: ?Float,
+|}>;
+
+type ComponentType = HostComponent<NativeProps>;
+
+interface NativeCommands {
+  +setNativeDate: (
+    viewRef: React.ElementRef<ComponentType>,
+    date: Float,
+  ) => void;
+}
+
+export const Commands: NativeCommands = codegenNativeCommands<NativeCommands>({
+  supportedCommands: ['setNativeDate'],
+});
+
+export default (codegenNativeComponent<NativeProps>('DatePicker', {
+  paperComponentName: 'RCTDatePicker',
+  excludedPlatform: 'android',
+}): HostComponent<NativeProps>);

node_modules/react-native/Libraries/Components/DatePickerAndroid/DatePickerAndroid.android.js

@@ -0,0 +1,89 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @flow strict-local
+ */
+
+'use strict';
+
+import type {Options, DatePickerOpenAction} from './DatePickerAndroidTypes';
+import NativeDatePickerAndroid from './NativeDatePickerAndroid';
+
+/**
+ * Convert a Date to a timestamp.
+ */
+function _toMillis(options: Options, key: string) {
+  const dateVal = options[key];
+  // Is it a Date object?
+  if (typeof dateVal === 'object' && typeof dateVal.getMonth === 'function') {
+    options[key] = dateVal.getTime();
+  }
+}
+
+/**
+ * Opens the standard Android date picker dialog.
+ *
+ * ### Example
+ *
+ * ```
+ * try {
+ *   const {action, year, month, day} = await DatePickerAndroid.open({
+ *     // Use `new Date()` for current date.
+ *     // May 25 2020. Month 0 is January.
+ *     date: new Date(2020, 4, 25)
+ *   });
+ *   if (action !== DatePickerAndroid.dismissedAction) {
+ *     // Selected year, month (0-11), day
+ *   }
+ * } catch ({code, message}) {
+ *   console.warn('Cannot open date picker', message);
+ * }
+ * ```
+ */
+class DatePickerAndroid {
+  /**
+   * Opens the standard Android date picker dialog.
+   *
+   * The available keys for the `options` object are:
+   *
+   *   - `date` (`Date` object or timestamp in milliseconds) - date to show by default
+   *   - `minDate` (`Date` or timestamp in milliseconds) - minimum date that can be selected
+   *   - `maxDate` (`Date` object or timestamp in milliseconds) - maximum date that can be selected
+   *   - `mode` (`enum('calendar', 'spinner', 'default')`) - To set the date-picker mode to calendar/spinner/default
+   *     - 'calendar': Show a date picker in calendar mode.
+   *     - 'spinner': Show a date picker in spinner mode.
+   *     - 'default': Show a default native date picker(spinner/calendar) based on android versions.
+   *
+   * Returns a Promise which will be invoked an object containing `action`, `year`, `month` (0-11),
+   * `day` if the user picked a date. If the user dismissed the dialog, the Promise will
+   * still be resolved with action being `DatePickerAndroid.dismissedAction` and all the other keys
+   * being undefined. **Always** check whether the `action` before reading the values.
+   *
+   * Note the native date picker dialog has some UI glitches on Android 4 and lower
+   * when using the `minDate` and `maxDate` options.
+   */
+  static async open(options: ?Options): Promise<DatePickerOpenAction> {
+    const optionsMs = options;
+    if (optionsMs != null) {
+      _toMillis(optionsMs, 'date');
+      _toMillis(optionsMs, 'minDate');
+      _toMillis(optionsMs, 'maxDate');
+    }
+    return NativeDatePickerAndroid.open(options);
+  }
+
+  /**
+   * A date has been selected.
+   */
+  static +dateSetAction: 'dateSetAction' = 'dateSetAction';
+  /**
+   * The dialog has been dismissed.
+   */
+  static +dismissedAction: 'dismissedAction' = 'dismissedAction';
+}
+
+module.exports = DatePickerAndroid;

node_modules/react-native/Libraries/Components/DatePickerAndroid/DatePickerAndroid.ios.js

@@ -0,0 +1,30 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @flow strict-local
+ */
+
+'use strict';
+
+import type {Options, DatePickerOpenAction} from './DatePickerAndroidTypes';
+
+class DatePickerAndroid {
+  static async open(options: ?Options): Promise<DatePickerOpenAction> {
+    throw new Error('DatePickerAndroid is not supported on this platform.');
+  }
+
+  /**
+   * A date has been selected.
+   */
+  static +dateSetAction: 'dateSetAction' = 'dateSetAction';
+  /**
+   * The dialog has been dismissed.
+   */
+  static +dismissedAction: 'dismissedAction' = 'dismissedAction';
+}
+
+module.exports = DatePickerAndroid;

node_modules/react-native/Libraries/Components/DatePickerAndroid/DatePickerAndroidTypes.js

@@ -0,0 +1,30 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @flow strict-local
+ */
+
+export type Options = $ReadOnly<{|
+  date?: ?(Date | number),
+  minDate?: ?(Date | number),
+  maxDate?: ?(Date | number),
+  mode?: ?('calendar' | 'spinner' | 'default'),
+|}>;
+
+export type DatePickerOpenAction =
+  | {|
+      action: 'dateSetAction',
+      year: number,
+      month: number,
+      day: number,
+    |}
+  | {|
+      action: 'dismissedAction',
+      year: void,
+      month: void,
+      day: void,
+    |};

node_modules/react-native/Libraries/Components/DatePickerAndroid/NativeDatePickerAndroid.js

@@ -0,0 +1,22 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow
+ * @format
+ */
+
+'use strict';
+
+import type {TurboModule} from '../../TurboModule/RCTExport';
+import * as TurboModuleRegistry from '../../TurboModule/TurboModuleRegistry';
+
+export interface Spec extends TurboModule {
+  +open: (options: Object) => Promise<Object>;
+}
+
+export default (TurboModuleRegistry.getEnforcing<Spec>(
+  'DatePickerAndroid',
+): Spec);

node_modules/react-native/Libraries/Components/DrawerAndroid/AndroidDrawerLayoutNativeComponent.js

@@ -0,0 +1,125 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @flow strict-local
+ */
+
+'use strict';
+
+import type {ViewProps} from 'react-native/Libraries/Components/View/ViewPropTypes';
+import type {ColorValue} from 'react-native/Libraries/StyleSheet/StyleSheetTypes';
+import type {
+  WithDefault,
+  DirectEventHandler,
+  Int32,
+  Float,
+} from 'react-native/Libraries/Types/CodegenTypes';
+import codegenNativeCommands from 'react-native/Libraries/Utilities/codegenNativeCommands';
+import codegenNativeComponent from 'react-native/Libraries/Utilities/codegenNativeComponent';
+import type {HostComponent} from 'react-native/Libraries/Renderer/shims/ReactNativeTypes';
+import * as React from 'react';
+
+type DrawerStateEvent = $ReadOnly<{|
+  drawerState: Int32,
+|}>;
+
+type DrawerSlideEvent = $ReadOnly<{|
+  offset: Float,
+|}>;
+
+type NativeProps = $ReadOnly<{|
+  ...ViewProps,
+  /**
+   * Determines whether the keyboard gets dismissed in response to a drag.
+   *   - 'none' (the default), drags do not dismiss the keyboard.
+   *   - 'on-drag', the keyboard is dismissed when a drag begins.
+   */
+  keyboardDismissMode?: WithDefault<'none' | 'on-drag', 'none'>,
+
+  /**
+   * Specifies the background color of the drawer. The default value is white.
+   * If you want to set the opacity of the drawer, use rgba. Example:
+   *
+   * ```
+   * return (
+   *   <DrawerLayoutAndroid drawerBackgroundColor="rgba(0,0,0,0.5)">
+   *   </DrawerLayoutAndroid>
+   * );
+   * ```
+   */
+  drawerBackgroundColor: ColorValue,
+
+  /**
+   * Specifies the side of the screen from which the drawer will slide in.
+   */
+  drawerPosition?: WithDefault<'left' | 'right', 'left'>,
+
+  /**
+   * Specifies the width of the drawer, more precisely the width of the view that be pulled in
+   * from the edge of the window.
+   */
+
+  drawerWidth?: WithDefault<Float, null>,
+
+  /**
+   * Specifies the lock mode of the drawer. The drawer can be locked in 3 states:
+   * - unlocked (default), meaning that the drawer will respond (open/close) to touch gestures.
+   * - locked-closed, meaning that the drawer will stay closed and not respond to gestures.
+   * - locked-open, meaning that the drawer will stay opened and not respond to gestures.
+   * The drawer may still be opened and closed programmatically (`openDrawer`/`closeDrawer`).
+   */
+  drawerLockMode?: WithDefault<
+    'unlocked' | 'locked-closed' | 'locked-open',
+    'unlocked',
+  >,
+
+  /**
+   * Function called whenever there is an interaction with the navigation view.
+   */
+  onDrawerSlide?: ?DirectEventHandler<DrawerSlideEvent>,
+
+  /**
+   * Function called when the drawer state has changed. The drawer can be in 3 states:
+   * - Idle, meaning there is no interaction with the navigation view happening at the time
+   * - Dragging, meaning there is currently an interaction with the navigation view
+   * - Settling, meaning that there was an interaction with the navigation view, and the
+   * navigation view is now finishing its closing or opening animation
+   */
+  onDrawerStateChanged?: ?DirectEventHandler<DrawerStateEvent>,
+
+  /**
+   * Function called whenever the navigation view has been opened.
+   */
+  onDrawerOpen?: ?DirectEventHandler<null, 'topDrawerOpened'>,
+
+  /**
+   * Function called whenever the navigation view has been closed.
+   */
+  onDrawerClose?: ?DirectEventHandler<null, 'topDrawerClosed'>,
+
+  /**
+   * Make the drawer take the entire screen and draw the background of the
+   * status bar to allow it to open over the status bar. It will only have an
+   * effect on API 21+.
+   */
+  statusBarBackgroundColor?: ?ColorValue,
+|}>;
+
+type NativeType = HostComponent<NativeProps>;
+
+interface NativeCommands {
+  +openDrawer: (viewRef: React.ElementRef<NativeType>) => void;
+  +closeDrawer: (viewRef: React.ElementRef<NativeType>) => void;
+}
+
+export const Commands: NativeCommands = codegenNativeCommands<NativeCommands>({
+  supportedCommands: ['openDrawer', 'closeDrawer'],
+});
+
+export default (codegenNativeComponent<NativeProps>(
+  'AndroidDrawerLayout',
+): NativeType);

node_modules/react-native/Libraries/Components/DrawerAndroid/DrawerLayoutAndroid.android.js

@@ -0,0 +1,385 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow
+ * @format
+ */
+
+'use strict';
+
+const Platform = require('../../Utilities/Platform');
+const React = require('react');
+const StatusBar = require('../StatusBar/StatusBar');
+const StyleSheet = require('../../StyleSheet/StyleSheet');
+const View = require('../View/View');
+
+const dismissKeyboard = require('../../Utilities/dismissKeyboard');
+const nullthrows = require('nullthrows');
+
+import AndroidDrawerLayoutNativeComponent, {
+  Commands,
+} from './AndroidDrawerLayoutNativeComponent';
+
+const DRAWER_STATES = ['Idle', 'Dragging', 'Settling'];
+
+import type {ViewStyleProp} from '../../StyleSheet/StyleSheet';
+import type {ColorValue} from '../../StyleSheet/StyleSheetTypes';
+import type {DirectEventHandler} from '../../Types/CodegenTypes';
+import type {
+  MeasureOnSuccessCallback,
+  MeasureInWindowOnSuccessCallback,
+  MeasureLayoutOnSuccessCallback,
+} from '../../Renderer/shims/ReactNativeTypes';
+
+type DrawerStates = 'Idle' | 'Dragging' | 'Settling';
+
+type DrawerSlideEvent = $ReadOnly<{|
+  offset: number,
+|}>;
+
+type Props = $ReadOnly<{|
+  /**
+   * Determines whether the keyboard gets dismissed in response to a drag.
+   *   - 'none' (the default), drags do not dismiss the keyboard.
+   *   - 'on-drag', the keyboard is dismissed when a drag begins.
+   */
+  keyboardDismissMode?: ?('none' | 'on-drag'),
+
+  /**
+   * Specifies the background color of the drawer. The default value is white.
+   * If you want to set the opacity of the drawer, use rgba. Example:
+   *
+   * ```
+   * return (
+   *   <DrawerLayoutAndroid drawerBackgroundColor="rgba(0,0,0,0.5)">
+   *   </DrawerLayoutAndroid>
+   * );
+   * ```
+   */
+  drawerBackgroundColor: ColorValue,
+
+  /**
+   * Specifies the side of the screen from which the drawer will slide in.
+   */
+  drawerPosition: ?('left' | 'right'),
+
+  /**
+   * Specifies the width of the drawer, more precisely the width of the view that be pulled in
+   * from the edge of the window.
+   */
+  drawerWidth?: ?number,
+
+  /**
+   * Specifies the lock mode of the drawer. The drawer can be locked in 3 states:
+   * - unlocked (default), meaning that the drawer will respond (open/close) to touch gestures.
+   * - locked-closed, meaning that the drawer will stay closed and not respond to gestures.
+   * - locked-open, meaning that the drawer will stay opened and not respond to gestures.
+   * The drawer may still be opened and closed programmatically (`openDrawer`/`closeDrawer`).
+   */
+  drawerLockMode?: ?('unlocked' | 'locked-closed' | 'locked-open'),
+
+  /**
+   * Function called whenever there is an interaction with the navigation view.
+   */
+  onDrawerSlide?: ?DirectEventHandler<DrawerSlideEvent>,
+
+  /**
+   * Function called when the drawer state has changed. The drawer can be in 3 states:
+   * - Idle, meaning there is no interaction with the navigation view happening at the time
+   * - Dragging, meaning there is currently an interaction with the navigation view
+   * - Settling, meaning that there was an interaction with the navigation view, and the
+   * navigation view is now finishing its closing or opening animation
+   */
+  onDrawerStateChanged?: ?(state: DrawerStates) => mixed,
+
+  /**
+   * Function called whenever the navigation view has been opened.
+   */
+  onDrawerOpen?: ?() => mixed,
+
+  /**
+   * Function called whenever the navigation view has been closed.
+   */
+  onDrawerClose?: ?() => mixed,
+
+  /**
+   * The navigation view that will be rendered to the side of the screen and can be pulled in.
+   */
+  renderNavigationView: () => React.Element<any>,
+
+  /**
+   * Make the drawer take the entire screen and draw the background of the
+   * status bar to allow it to open over the status bar. It will only have an
+   * effect on API 21+.
+   */
+  statusBarBackgroundColor?: ?ColorValue,
+
+  children?: React.Node,
+  style?: ?ViewStyleProp,
+|}>;
+
+type State = {|
+  statusBarBackgroundColor: ColorValue,
+|};
+
+/**
+ * React component that wraps the platform `DrawerLayout` (Android only). The
+ * Drawer (typically used for navigation) is rendered with `renderNavigationView`
+ * and direct children are the main view (where your content goes). The navigation
+ * view is initially not visible on the screen, but can be pulled in from the
+ * side of the window specified by the `drawerPosition` prop and its width can
+ * be set by the `drawerWidth` prop.
+ *
+ * Example:
+ *
+ * ```
+ * render: function() {
+ *   var navigationView = (
+ *     <View style={{flex: 1, backgroundColor: '#fff'}}>
+ *       <Text style={{margin: 10, fontSize: 15, textAlign: 'left'}}>I'm in the Drawer!</Text>
+ *     </View>
+ *   );
+ *   return (
+ *     <DrawerLayoutAndroid
+ *       drawerWidth={300}
+ *       drawerPosition="left"
+ *       renderNavigationView={() => navigationView}>
+ *       <View style={{flex: 1, alignItems: 'center'}}>
+ *         <Text style={{margin: 10, fontSize: 15, textAlign: 'right'}}>Hello</Text>
+ *         <Text style={{margin: 10, fontSize: 15, textAlign: 'right'}}>World!</Text>
+ *       </View>
+ *     </DrawerLayoutAndroid>
+ *   );
+ * },
+ * ```
+ */
+class DrawerLayoutAndroid extends React.Component<Props, State> {
+  static get positions(): mixed {
+    console.warn(
+      'Setting DrawerLayoutAndroid drawerPosition using `DrawerLayoutAndroid.positions` is deprecated. Instead pass the string value "left" or "right"',
+    );
+
+    return {Left: 'left', Right: 'right'};
+  }
+  static defaultProps: {|
+    drawerBackgroundColor: 'white',
+  |} = {
+    drawerBackgroundColor: 'white',
+  };
+
+  _nativeRef = React.createRef<
+    React.ElementRef<typeof AndroidDrawerLayoutNativeComponent>,
+  >();
+
+  state: State = {statusBarBackgroundColor: null};
+
+  render(): React.Node {
+    const {
+      onDrawerStateChanged,
+      renderNavigationView,
+      onDrawerOpen,
+      onDrawerClose,
+      ...props
+    } = this.props;
+    const drawStatusBar =
+      Platform.Version >= 21 && this.props.statusBarBackgroundColor != null;
+    const drawerViewWrapper = (
+      <View
+        style={[
+          styles.drawerSubview,
+          {
+            width: this.props.drawerWidth,
+            backgroundColor: this.props.drawerBackgroundColor,
+          },
+        ]}
+        collapsable={false}>
+        {renderNavigationView()}
+        {drawStatusBar && <View style={styles.drawerStatusBar} />}
+      </View>
+    );
+    const childrenWrapper = (
+      <View style={styles.mainSubview} collapsable={false}>
+        {drawStatusBar && (
+          <StatusBar
+            translucent
+            backgroundColor={this.props.statusBarBackgroundColor}
+          />
+        )}
+        {drawStatusBar && (
+          <View
+            style={[
+              styles.statusBar,
+              {backgroundColor: this.props.statusBarBackgroundColor},
+            ]}
+          />
+        )}
+        {this.props.children}
+      </View>
+    );
+    return (
+      <AndroidDrawerLayoutNativeComponent
+        {...props}
+        ref={this._nativeRef}
+        drawerWidth={this.props.drawerWidth}
+        drawerPosition={this.props.drawerPosition}
+        drawerLockMode={this.props.drawerLockMode}
+        style={[styles.base, this.props.style]}
+        onDrawerSlide={this._onDrawerSlide}
+        onDrawerOpen={this._onDrawerOpen}
+        onDrawerClose={this._onDrawerClose}
+        onDrawerStateChanged={this._onDrawerStateChanged}>
+        {childrenWrapper}
+        {drawerViewWrapper}
+      </AndroidDrawerLayoutNativeComponent>
+    );
+  }
+
+  _onDrawerSlide = event => {
+    if (this.props.onDrawerSlide) {
+      this.props.onDrawerSlide(event);
+    }
+    if (this.props.keyboardDismissMode === 'on-drag') {
+      dismissKeyboard();
+    }
+  };
+
+  _onDrawerOpen = () => {
+    if (this.props.onDrawerOpen) {
+      this.props.onDrawerOpen();
+    }
+  };
+
+  _onDrawerClose = () => {
+    if (this.props.onDrawerClose) {
+      this.props.onDrawerClose();
+    }
+  };
+
+  _onDrawerStateChanged = event => {
+    if (this.props.onDrawerStateChanged) {
+      this.props.onDrawerStateChanged(
+        DRAWER_STATES[event.nativeEvent.drawerState],
+      );
+    }
+  };
+
+  /**
+   * Opens the drawer.
+   */
+  openDrawer() {
+    Commands.openDrawer(nullthrows(this._nativeRef.current));
+  }
+
+  /**
+   * Closes the drawer.
+   */
+  closeDrawer() {
+    Commands.closeDrawer(nullthrows(this._nativeRef.current));
+  }
+
+  /**
+   * Closing and opening example
+   * Note: To access the drawer you have to give it a ref
+   *
+   * Class component:
+   *
+   * render () {
+   *   this.openDrawer = () => {
+   *     this.refs.DRAWER.openDrawer()
+   *   }
+   *   this.closeDrawer = () => {
+   *     this.refs.DRAWER.closeDrawer()
+   *   }
+   *   return (
+   *     <DrawerLayoutAndroid ref={'DRAWER'}>
+   *      {children}
+   *     </DrawerLayoutAndroid>
+   *   )
+   * }
+   *
+   * Function component:
+   *
+   * const drawerRef = useRef()
+   * const openDrawer = () => {
+   *   drawerRef.current.openDrawer()
+   * }
+   * const closeDrawer = () => {
+   *   drawerRef.current.closeDrawer()
+   * }
+   * return (
+   *   <DrawerLayoutAndroid ref={drawerRef}>
+   *     {children}
+   *   </DrawerLayoutAndroid>
+   * )
+   */
+
+  /**
+   * Native methods
+   */
+  blur() {
+    nullthrows(this._nativeRef.current).blur();
+  }
+
+  focus() {
+    nullthrows(this._nativeRef.current).focus();
+  }
+
+  measure(callback: MeasureOnSuccessCallback) {
+    nullthrows(this._nativeRef.current).measure(callback);
+  }
+
+  measureInWindow(callback: MeasureInWindowOnSuccessCallback) {
+    nullthrows(this._nativeRef.current).measureInWindow(callback);
+  }
+
+  measureLayout(
+    relativeToNativeNode: number,
+    onSuccess: MeasureLayoutOnSuccessCallback,
+    onFail?: () => void,
+  ) {
+    nullthrows(this._nativeRef.current).measureLayout(
+      relativeToNativeNode,
+      onSuccess,
+      onFail,
+    );
+  }
+
+  setNativeProps(nativeProps: Object) {
+    nullthrows(this._nativeRef.current).setNativeProps(nativeProps);
+  }
+}
+
+const styles = StyleSheet.create({
+  base: {
+    flex: 1,
+    elevation: 16,
+  },
+  mainSubview: {
+    position: 'absolute',
+    top: 0,
+    left: 0,
+    right: 0,
+    bottom: 0,
+  },
+  drawerSubview: {
+    position: 'absolute',
+    top: 0,
+    bottom: 0,
+  },
+  statusBar: {
+    height: StatusBar.currentHeight,
+  },
+  drawerStatusBar: {
+    position: 'absolute',
+    top: 0,
+    left: 0,
+    right: 0,
+    height: StatusBar.currentHeight,
+    backgroundColor: 'rgba(0, 0, 0, 0.251)',
+  },
+});
+
+module.exports = DrawerLayoutAndroid;

node_modules/react-native/Libraries/Components/DrawerAndroid/DrawerLayoutAndroid.ios.js

@@ -0,0 +1,12 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ */
+
+'use strict';
+
+module.exports = require('../UnimplementedViews/UnimplementedView');

node_modules/react-native/Libraries/Components/Keyboard/Keyboard.js

@@ -0,0 +1,195 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @flow strict-local
+ */
+
+'use strict';
+
+const LayoutAnimation = require('../../LayoutAnimation/LayoutAnimation');
+const NativeEventEmitter = require('../../EventEmitter/NativeEventEmitter');
+
+const dismissKeyboard = require('../../Utilities/dismissKeyboard');
+const invariant = require('invariant');
+
+import NativeKeyboardObserver from './NativeKeyboardObserver';
+const KeyboardEventEmitter: NativeEventEmitter = new NativeEventEmitter(
+  NativeKeyboardObserver,
+);
+
+export type KeyboardEventName =
+  | 'keyboardWillShow'
+  | 'keyboardDidShow'
+  | 'keyboardWillHide'
+  | 'keyboardDidHide'
+  | 'keyboardWillChangeFrame'
+  | 'keyboardDidChangeFrame';
+
+export type KeyboardEventEasing =
+  | 'easeIn'
+  | 'easeInEaseOut'
+  | 'easeOut'
+  | 'linear'
+  | 'keyboard';
+
+export type KeyboardEventCoordinates = $ReadOnly<{|
+  screenX: number,
+  screenY: number,
+  width: number,
+  height: number,
+|}>;
+
+export type KeyboardEvent = AndroidKeyboardEvent | IOSKeyboardEvent;
+
+type BaseKeyboardEvent = {|
+  duration: number,
+  easing: KeyboardEventEasing,
+  endCoordinates: KeyboardEventCoordinates,
+|};
+
+export type AndroidKeyboardEvent = $ReadOnly<{|
+  ...BaseKeyboardEvent,
+  duration: 0,
+  easing: 'keyboard',
+|}>;
+
+export type IOSKeyboardEvent = $ReadOnly<{|
+  ...BaseKeyboardEvent,
+  startCoordinates: KeyboardEventCoordinates,
+  isEventFromThisApp: boolean,
+|}>;
+
+type KeyboardEventListener = (e: KeyboardEvent) => void;
+
+// The following object exists for documentation purposes
+// Actual work happens in
+// https://github.com/facebook/react-native/blob/master/Libraries/EventEmitter/NativeEventEmitter.js
+
+/**
+ * `Keyboard` module to control keyboard events.
+ *
+ * ### Usage
+ *
+ * The Keyboard module allows you to listen for native events and react to them, as
+ * well as make changes to the keyboard, like dismissing it.
+ *
+ *```
+ * import React, { Component } from 'react';
+ * import { Keyboard, TextInput } from 'react-native';
+ *
+ * class Example extends Component {
+ *   componentWillMount () {
+ *     this.keyboardDidShowListener = Keyboard.addListener('keyboardDidShow', this._keyboardDidShow);
+ *     this.keyboardDidHideListener = Keyboard.addListener('keyboardDidHide', this._keyboardDidHide);
+ *   }
+ *
+ *   componentWillUnmount () {
+ *     this.keyboardDidShowListener.remove();
+ *     this.keyboardDidHideListener.remove();
+ *   }
+ *
+ *   _keyboardDidShow () {
+ *     alert('Keyboard Shown');
+ *   }
+ *
+ *   _keyboardDidHide () {
+ *     alert('Keyboard Hidden');
+ *   }
+ *
+ *   render() {
+ *     return (
+ *       <TextInput
+ *         onSubmitEditing={Keyboard.dismiss}
+ *       />
+ *     );
+ *   }
+ * }
+ *```
+ */
+
+const Keyboard = {
+  /**
+   * The `addListener` function connects a JavaScript function to an identified native
+   * keyboard notification event.
+   *
+   * This function then returns the reference to the listener.
+   *
+   * @param {string} eventName The `nativeEvent` is the string that identifies the event you're listening for.  This
+   *can be any of the following:
+   *
+   * - `keyboardWillShow`
+   * - `keyboardDidShow`
+   * - `keyboardWillHide`
+   * - `keyboardDidHide`
+   * - `keyboardWillChangeFrame`
+   * - `keyboardDidChangeFrame`
+   *
+   * Note that if you set `android:windowSoftInputMode` to `adjustResize`  or `adjustNothing`,
+   * only `keyboardDidShow` and `keyboardDidHide` events will be available on Android.
+   * `keyboardWillShow` as well as `keyboardWillHide` are generally not available on Android
+   * since there is no native corresponding event.
+   *
+   * @param {function} callback function to be called when the event fires.
+   */
+  addListener(eventName: KeyboardEventName, callback: KeyboardEventListener) {
+    invariant(false, 'Dummy method used for documentation');
+  },
+
+  /**
+   * Removes a specific listener.
+   *
+   * @param {string} eventName The `nativeEvent` is the string that identifies the event you're listening for.
+   * @param {function} callback function to be called when the event fires.
+   */
+  removeListener(
+    eventName: KeyboardEventName,
+    callback: KeyboardEventListener,
+  ) {
+    invariant(false, 'Dummy method used for documentation');
+  },
+
+  /**
+   * Removes all listeners for a specific event type.
+   *
+   * @param {string} eventType The native event string listeners are watching which will be removed.
+   */
+  removeAllListeners(eventName: KeyboardEventName) {
+    invariant(false, 'Dummy method used for documentation');
+  },
+
+  /**
+   * Dismisses the active keyboard and removes focus.
+   */
+  dismiss() {
+    invariant(false, 'Dummy method used for documentation');
+  },
+
+  /**
+   * Useful for syncing TextInput (or other keyboard accessory view) size of
+   * position changes with keyboard movements.
+   */
+  scheduleLayoutAnimation(event: KeyboardEvent) {
+    invariant(false, 'Dummy method used for documentation');
+  },
+};
+
+// Throw away the dummy object and reassign it to original module
+KeyboardEventEmitter.dismiss = dismissKeyboard;
+KeyboardEventEmitter.scheduleLayoutAnimation = function(event: KeyboardEvent) {
+  const {duration, easing} = event;
+  if (duration != null && duration !== 0) {
+    LayoutAnimation.configureNext({
+      duration: duration,
+      update: {
+        duration: duration,
+        type: (easing != null && LayoutAnimation.Types[easing]) || 'keyboard',
+      },
+    });
+  }
+};
+
+module.exports = KeyboardEventEmitter;

node_modules/react-native/Libraries/Components/Keyboard/KeyboardAvoidingView.js

@@ -0,0 +1,230 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @flow
+ */
+
+'use strict';
+
+const Keyboard = require('./Keyboard');
+const LayoutAnimation = require('../../LayoutAnimation/LayoutAnimation');
+const Platform = require('../../Utilities/Platform');
+const React = require('react');
+const StyleSheet = require('../../StyleSheet/StyleSheet');
+const View = require('../View/View');
+
+import type {ViewStyleProp} from '../../StyleSheet/StyleSheet';
+import type EmitterSubscription from '../../vendor/emitter/EmitterSubscription';
+import type {
+  ViewProps,
+  ViewLayout,
+  ViewLayoutEvent,
+} from '../View/ViewPropTypes';
+import type {KeyboardEvent} from './Keyboard';
+
+type Props = $ReadOnly<{|
+  ...ViewProps,
+
+  /**
+   * Specify how to react to the presence of the keyboard.
+   */
+  behavior?: ?('height' | 'position' | 'padding'),
+
+  /**
+   * Style of the content container when `behavior` is 'position'.
+   */
+  contentContainerStyle?: ?ViewStyleProp,
+
+  /**
+   * Controls whether this `KeyboardAvoidingView` instance should take effect.
+   * This is useful when more than one is on the screen. Defaults to true.
+   */
+  enabled: ?boolean,
+
+  /**
+   * Distance between the top of the user screen and the React Native view. This
+   * may be non-zero in some cases. Defaults to 0.
+   */
+  keyboardVerticalOffset: number,
+|}>;
+
+type State = {|
+  bottom: number,
+|};
+
+/**
+ * View that moves out of the way when the keyboard appears by automatically
+ * adjusting its height, position, or bottom padding.
+ */
+class KeyboardAvoidingView extends React.Component<Props, State> {
+  static defaultProps: {|enabled: boolean, keyboardVerticalOffset: number|} = {
+    enabled: true,
+    keyboardVerticalOffset: 0,
+  };
+
+  _frame: ?ViewLayout = null;
+  _subscriptions: Array<EmitterSubscription> = [];
+  viewRef: {current: React.ElementRef<any> | null, ...};
+  _initialFrameHeight: number = 0;
+
+  constructor(props: Props) {
+    super(props);
+    this.state = {bottom: 0};
+    this.viewRef = React.createRef();
+  }
+
+  _relativeKeyboardHeight(keyboardFrame): number {
+    const frame = this._frame;
+    if (!frame || !keyboardFrame) {
+      return 0;
+    }
+
+    const keyboardY = keyboardFrame.screenY - this.props.keyboardVerticalOffset;
+
+    // Calculate the displacement needed for the view such that it
+    // no longer overlaps with the keyboard
+    return Math.max(frame.y + frame.height - keyboardY, 0);
+  }
+
+  _onKeyboardChange = (event: ?KeyboardEvent) => {
+    if (event == null) {
+      this.setState({bottom: 0});
+      return;
+    }
+
+    const {duration, easing, endCoordinates} = event;
+    const height = this._relativeKeyboardHeight(endCoordinates);
+
+    if (this.state.bottom === height) {
+      return;
+    }
+
+    if (duration && easing) {
+      LayoutAnimation.configureNext({
+        // We have to pass the duration equal to minimal accepted duration defined here: RCTLayoutAnimation.m
+        duration: duration > 10 ? duration : 10,
+        update: {
+          duration: duration > 10 ? duration : 10,
+          type: LayoutAnimation.Types[easing] || 'keyboard',
+        },
+      });
+    }
+    this.setState({bottom: height});
+  };
+
+  _onLayout = (event: ViewLayoutEvent) => {
+    this._frame = event.nativeEvent.layout;
+    if (!this._initialFrameHeight) {
+      // save the initial frame height, before the keyboard is visible
+      this._initialFrameHeight = this._frame.height;
+    }
+  };
+
+  componentDidMount(): void {
+    if (Platform.OS === 'ios') {
+      this._subscriptions = [
+        Keyboard.addListener('keyboardWillChangeFrame', this._onKeyboardChange),
+      ];
+    } else {
+      this._subscriptions = [
+        Keyboard.addListener('keyboardDidHide', this._onKeyboardChange),
+        Keyboard.addListener('keyboardDidShow', this._onKeyboardChange),
+      ];
+    }
+  }
+
+  componentWillUnmount(): void {
+    this._subscriptions.forEach(subscription => {
+      subscription.remove();
+    });
+  }
+
+  render(): React.Node {
+    const {
+      behavior,
+      children,
+      contentContainerStyle,
+      enabled,
+      keyboardVerticalOffset,
+      style,
+      ...props
+    } = this.props;
+    const bottomHeight = enabled ? this.state.bottom : 0;
+    switch (behavior) {
+      case 'height':
+        let heightStyle;
+        if (this._frame != null && this.state.bottom > 0) {
+          // Note that we only apply a height change when there is keyboard present,
+          // i.e. this.state.bottom is greater than 0. If we remove that condition,
+          // this.frame.height will never go back to its original value.
+          // When height changes, we need to disable flex.
+          heightStyle = {
+            height: this._initialFrameHeight - bottomHeight,
+            flex: 0,
+          };
+        }
+        return (
+          <View
+            ref={this.viewRef}
+            style={StyleSheet.compose(
+              style,
+              heightStyle,
+            )}
+            onLayout={this._onLayout}
+            {...props}>
+            {children}
+          </View>
+        );
+
+      case 'position':
+        return (
+          <View
+            ref={this.viewRef}
+            style={style}
+            onLayout={this._onLayout}
+            {...props}>
+            <View
+              style={StyleSheet.compose(
+                contentContainerStyle,
+                {
+                  bottom: bottomHeight,
+                },
+              )}>
+              {children}
+            </View>
+          </View>
+        );
+
+      case 'padding':
+        return (
+          <View
+            ref={this.viewRef}
+            style={StyleSheet.compose(
+              style,
+              {paddingBottom: bottomHeight},
+            )}
+            onLayout={this._onLayout}
+            {...props}>
+            {children}
+          </View>
+        );
+
+      default:
+        return (
+          <View
+            ref={this.viewRef}
+            onLayout={this._onLayout}
+            style={style}
+            {...props}>
+            {children}
+          </View>
+        );
+    }
+  }
+}
+
+module.exports = KeyboardAvoidingView;

node_modules/react-native/Libraries/Components/Keyboard/NativeKeyboardObserver.js

@@ -0,0 +1,21 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+'use strict';
+
+import type {TurboModule} from '../../TurboModule/RCTExport';
+import * as TurboModuleRegistry from '../../TurboModule/TurboModuleRegistry';
+
+export interface Spec extends TurboModule {
+  +addListener: (eventName: string) => void;
+  +removeListeners: (count: number) => void;
+}
+
+export default (TurboModuleRegistry.get<Spec>('KeyboardObserver'): ?Spec);

node_modules/react-native/Libraries/Components/MaskedView/MaskedViewIOS.android.js

@@ -0,0 +1,13 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @flow strict-local
+ */
+
+'use strict';
+
+module.exports = require('../UnimplementedViews/UnimplementedView');

node_modules/react-native/Libraries/Components/MaskedView/MaskedViewIOS.ios.js

@@ -0,0 +1,93 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @flow
+ */
+
+const React = require('react');
+const StyleSheet = require('../../StyleSheet/StyleSheet');
+const View = require('../View/View');
+
+import type {ViewProps} from '../View/ViewPropTypes';
+import RCTMaskedViewNativeComponent from './RCTMaskedViewNativeComponent';
+
+type Props = $ReadOnly<{|
+  ...ViewProps,
+
+  children: React.Node,
+  /**
+   * Should be a React element to be rendered and applied as the
+   * mask for the child element.
+   */
+  maskElement: React.Element<any>,
+|}>;
+
+/**
+ * Renders the child view with a mask specified in the `maskElement` prop.
+ *
+ * ```
+ * import React from 'react';
+ * import { MaskedViewIOS, Text, View } from 'react-native';
+ *
+ * class MyMaskedView extends React.Component {
+ *   render() {
+ *     return (
+ *       <MaskedViewIOS
+ *         style={{ flex: 1 }}
+ *         maskElement={
+ *           <View style={styles.maskContainerStyle}>
+ *             <Text style={styles.maskTextStyle}>
+ *               Basic Mask
+ *             </Text>
+ *           </View>
+ *         }
+ *       >
+ *         <View style={{ flex: 1, backgroundColor: 'blue' }} />
+ *       </MaskedViewIOS>
+ *     );
+ *   }
+ * }
+ * ```
+ *
+ * The above example will render a view with a blue background that fills its
+ * parent, and then mask that view with text that says "Basic Mask".
+ *
+ * The alpha channel of the view rendered by the `maskElement` prop determines how
+ * much of the view's content and background shows through. Fully or partially
+ * opaque pixels allow the underlying content to show through but fully
+ * transparent pixels block that content.
+ *
+ */
+class MaskedViewIOS extends React.Component<Props> {
+  _hasWarnedInvalidRenderMask = false;
+
+  render(): React.Node {
+    const {maskElement, children, ...otherViewProps} = this.props;
+
+    if (!React.isValidElement(maskElement)) {
+      if (!this._hasWarnedInvalidRenderMask) {
+        console.warn(
+          'MaskedView: Invalid `maskElement` prop was passed to MaskedView. ' +
+            'Expected a React Element. No mask will render.',
+        );
+        this._hasWarnedInvalidRenderMask = true;
+      }
+      return <View {...otherViewProps}>{children}</View>;
+    }
+
+    return (
+      <RCTMaskedViewNativeComponent {...otherViewProps}>
+        <View pointerEvents="none" style={StyleSheet.absoluteFill}>
+          {maskElement}
+        </View>
+        {children}
+      </RCTMaskedViewNativeComponent>
+    );
+  }
+}
+
+module.exports = MaskedViewIOS;

node_modules/react-native/Libraries/Components/MaskedView/RCTMaskedViewNativeComponent.js

@@ -0,0 +1,21 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @flow strict-local
+ */
+
+import type {ViewProps} from '../View/ViewPropTypes';
+import codegenNativeComponent from '../../Utilities/codegenNativeComponent';
+import type {HostComponent} from '../../Renderer/shims/ReactNativeTypes';
+
+type NativeProps = $ReadOnly<{|
+  ...ViewProps,
+|}>;
+
+export default (codegenNativeComponent<NativeProps>(
+  'RCTMaskedView',
+): HostComponent<NativeProps>);

node_modules/react-native/Libraries/Components/Picker/AndroidDialogPickerNativeComponent.js

@@ -0,0 +1,69 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @flow strict-local
+ */
+
+'use strict';
+
+import * as React from 'react';
+
+import codegenNativeCommands from '../../Utilities/codegenNativeCommands';
+import requireNativeComponent from '../../ReactNative/requireNativeComponent';
+
+import type {
+  DirectEventHandler,
+  Int32,
+  WithDefault,
+} from '../../Types/CodegenTypes';
+import type {HostComponent} from '../../Renderer/shims/ReactNativeTypes';
+import type {TextStyleProp} from '../../StyleSheet/StyleSheet';
+import type {ColorValue} from '../../StyleSheet/StyleSheetTypes';
+import type {ProcessedColorValue} from '../../StyleSheet/processColor';
+import type {ViewProps} from '../../Components/View/ViewPropTypes';
+
+type PickerItem = $ReadOnly<{|
+  label: string,
+  color?: ?ProcessedColorValue,
+|}>;
+
+type PickerItemSelectEvent = $ReadOnly<{|
+  position: Int32,
+|}>;
+
+type NativeProps = $ReadOnly<{|
+  ...ViewProps,
+  style?: ?TextStyleProp,
+
+  // Props
+  color?: ?ColorValue,
+  backgroundColor?: ?ColorValue,
+  enabled?: WithDefault<boolean, true>,
+  items: $ReadOnlyArray<PickerItem>,
+  prompt?: WithDefault<string, ''>,
+  selected: Int32,
+
+  // Events
+  onSelect?: DirectEventHandler<PickerItemSelectEvent>,
+|}>;
+
+type NativeType = HostComponent<NativeProps>;
+
+interface NativeCommands {
+  +setNativeSelectedPosition: (
+    viewRef: React.ElementRef<NativeType>,
+    index: number,
+  ) => void;
+}
+
+export const Commands: NativeCommands = codegenNativeCommands<NativeCommands>({
+  supportedCommands: ['setNativeSelectedPosition'],
+});
+
+export default (requireNativeComponent<NativeProps>(
+  'AndroidDialogPicker',
+): NativeType);

node_modules/react-native/Libraries/Components/Picker/AndroidDropdownPickerNativeComponent.js

@@ -0,0 +1,69 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @flow strict-local
+ */
+
+'use strict';
+
+import * as React from 'react';
+
+import codegenNativeCommands from '../../Utilities/codegenNativeCommands';
+import requireNativeComponent from '../../ReactNative/requireNativeComponent';
+
+import type {
+  DirectEventHandler,
+  Int32,
+  WithDefault,
+} from '../../Types/CodegenTypes';
+import type {HostComponent} from '../../Renderer/shims/ReactNativeTypes';
+import type {TextStyleProp} from '../../StyleSheet/StyleSheet';
+import type {ColorValue} from '../../StyleSheet/StyleSheetTypes';
+import type {ProcessedColorValue} from '../../StyleSheet/processColor';
+import type {ViewProps} from '../../Components/View/ViewPropTypes';
+
+type PickerItem = $ReadOnly<{|
+  label: string,
+  color?: ?ProcessedColorValue,
+|}>;
+
+type PickerItemSelectEvent = $ReadOnly<{|
+  position: Int32,
+|}>;
+
+type NativeProps = $ReadOnly<{|
+  ...ViewProps,
+  style?: ?TextStyleProp,
+
+  // Props
+  color?: ?ColorValue,
+  backgroundColor?: ?ColorValue,
+  enabled?: WithDefault<boolean, true>,
+  items: $ReadOnlyArray<PickerItem>,
+  prompt?: WithDefault<string, ''>,
+  selected: Int32,
+
+  // Events
+  onSelect?: DirectEventHandler<PickerItemSelectEvent>,
+|}>;
+
+type NativeType = HostComponent<NativeProps>;
+
+interface NativeCommands {
+  +setNativeSelectedPosition: (
+    viewRef: React.ElementRef<NativeType>,
+    index: number,
+  ) => void;
+}
+
+export const Commands: NativeCommands = codegenNativeCommands<NativeCommands>({
+  supportedCommands: ['setNativeSelectedPosition'],
+});
+
+export default (requireNativeComponent<NativeProps>(
+  'AndroidDropdownPicker',
+): NativeType);

node_modules/react-native/Libraries/Components/Picker/Picker.js

@@ -0,0 +1,165 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @flow
+ */
+
+'use strict';
+
+const PickerAndroid = require('./PickerAndroid');
+const PickerIOS = require('./PickerIOS');
+const Platform = require('../../Utilities/Platform');
+const React = require('react');
+const UnimplementedView = require('../UnimplementedViews/UnimplementedView');
+
+import type {TextStyleProp} from '../../StyleSheet/StyleSheet';
+import type {ColorValue} from '../../StyleSheet/StyleSheetTypes';
+
+const MODE_DIALOG = 'dialog';
+const MODE_DROPDOWN = 'dropdown';
+
+type PickerItemProps = $ReadOnly<{|
+  /**
+   * Text to display for this item.
+   */
+  label: string,
+
+  /**
+   * The value to be passed to picker's `onValueChange` callback when
+   * this item is selected. Can be a string or an integer.
+   */
+  value?: ?(number | string),
+
+  /**
+   * Color of this item's text.
+   * @platform android
+   */
+  color?: ColorValue,
+
+  /**
+   * Used to locate the item in end-to-end tests.
+   */
+  testID?: string,
+|}>;
+
+/**
+ * Individual selectable item in a Picker.
+ */
+export type {PickerItem};
+class PickerItem extends React.Component<PickerItemProps> {
+  render() {
+    // The items are not rendered directly
+    throw null;
+  }
+}
+
+type PickerProps = $ReadOnly<{|
+  children?: React.Node,
+  style?: ?TextStyleProp,
+
+  /**
+   * Value matching value of one of the items. Can be a string or an integer.
+   */
+  selectedValue?: ?(number | string),
+
+  /**
+   * Callback for when an item is selected. This is called with the following parameters:
+   *   - `itemValue`: the `value` prop of the item that was selected
+   *   - `itemIndex`: the index of the selected item in this picker
+   */
+  onValueChange?: ?(itemValue: string | number, itemIndex: number) => mixed,
+
+  /**
+   * If set to false, the picker will be disabled, i.e. the user will not be able to make a
+   * selection.
+   * @platform android
+   */
+  enabled?: ?boolean,
+
+  /**
+   * On Android, specifies how to display the selection items when the user taps on the picker:
+   *
+   *   - 'dialog': Show a modal dialog. This is the default.
+   *   - 'dropdown': Shows a dropdown anchored to the picker view
+   *
+   * @platform android
+   */
+  mode?: ?('dialog' | 'dropdown'),
+
+  /**
+   * Style to apply to each of the item labels.
+   * @platform ios
+   */
+  itemStyle?: ?TextStyleProp,
+
+  /**
+   * Color of the item background.
+   * @platform android
+   */
+  backgroundColor?: ColorValue,
+
+  /**
+   * Prompt string for this picker, used on Android in dialog mode as the title of the dialog.
+   * @platform android
+   */
+  prompt?: ?string,
+
+  /**
+   * Used to locate this view in end-to-end tests.
+   */
+  testID?: ?string,
+  /**
+   * The string used for the accessibility label. Will be read once focused on the picker but not on change.
+   */
+  accessibilityLabel?: ?string,
+|}>;
+
+/**
+ * Renders the native picker component on iOS and Android. Example:
+ *
+ *     <Picker
+ *       selectedValue={this.state.language}
+ *       onValueChange={(itemValue, itemIndex) => this.setState({language: itemValue})}>
+ *       <Picker.Item label="Java" value="java" />
+ *       <Picker.Item label="JavaScript" value="js" />
+ *     </Picker>
+ */
+class Picker extends React.Component<PickerProps> {
+  /**
+   * On Android, display the options in a dialog.
+   */
+  static MODE_DIALOG: $TEMPORARY$string<'dialog'> = MODE_DIALOG;
+
+  /**
+   * On Android, display the options in a dropdown (this is the default).
+   */
+  static MODE_DROPDOWN: $TEMPORARY$string<'dropdown'> = MODE_DROPDOWN;
+
+  static Item: typeof PickerItem = PickerItem;
+
+  static defaultProps: {|mode: $TEMPORARY$string<'dialog'>|} = {
+    mode: MODE_DIALOG,
+  };
+
+  render(): React.Node {
+    if (Platform.OS === 'ios') {
+      /* $FlowFixMe(>=0.81.0 site=react_native_ios_fb) This suppression was
+       * added when renaming suppression sites. */
+      return <PickerIOS {...this.props}>{this.props.children}</PickerIOS>;
+    } else if (Platform.OS === 'android') {
+      return (
+        /* $FlowFixMe(>=0.81.0 site=react_native_android_fb) This suppression
+         * was added when renaming suppression sites. */
+        <PickerAndroid {...this.props}>{this.props.children}</PickerAndroid>
+      );
+    } else {
+      return <UnimplementedView />;
+    }
+  }
+}
+
+module.exports = Picker;

node_modules/react-native/Libraries/Components/Picker/PickerAndroid.android.js

@@ -0,0 +1,149 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @flow strict-local
+ */
+
+'use strict';
+
+import AndroidDropdownPickerNativeComponent, {
+  Commands as AndroidDropdownPickerCommands,
+} from './AndroidDropdownPickerNativeComponent';
+import AndroidDialogPickerNativeComponent, {
+  Commands as AndroidDialogPickerCommands,
+} from './AndroidDialogPickerNativeComponent';
+import * as React from 'react';
+import StyleSheet from '../../StyleSheet/StyleSheet';
+import invariant from 'invariant';
+import processColor from '../../StyleSheet/processColor';
+
+import type {ColorValue} from '../../StyleSheet/StyleSheetTypes';
+import type {SyntheticEvent} from '../../Types/CoreEventTypes';
+import type {TextStyleProp} from '../../StyleSheet/StyleSheet';
+
+type PickerItemSelectSyntheticEvent = SyntheticEvent<
+  $ReadOnly<{|
+    position: number,
+  |}>,
+>;
+
+type PickerItemValue = number | string;
+
+type Props = $ReadOnly<{|
+  accessibilityLabel?: ?Stringish,
+  children?: React.Node,
+  style?: ?TextStyleProp,
+  backgroundColor?: ?ColorValue,
+  selectedValue?: ?PickerItemValue,
+  enabled?: ?boolean,
+  mode?: ?('dialog' | 'dropdown'),
+  onValueChange?: ?(itemValue: ?PickerItemValue, itemIndex: number) => mixed,
+  prompt?: ?string,
+  testID?: string,
+|}>;
+
+/**
+ * Not exposed as a public API - use <Picker> instead.
+ */
+function PickerAndroid(props: Props): React.Node {
+  const pickerRef = React.useRef(null);
+
+  const [items, selected] = React.useMemo(() => {
+    // eslint-disable-next-line no-shadow
+    let selected = 0;
+    // eslint-disable-next-line no-shadow
+    const items = React.Children.map(props.children, (child, index) => {
+      if (child === null) {
+        return null;
+      }
+      if (child.props.value === props.selectedValue) {
+        selected = index;
+      }
+      const {color, label} = child.props;
+      const processedColor = processColor(color);
+      invariant(
+        processedColor == null || typeof processedColor === 'number',
+        'Unexpected color given for PickerAndroid color prop',
+      );
+      return {
+        color: color == null ? null : processedColor,
+        label,
+      };
+    });
+    return [items, selected];
+  }, [props.children, props.selectedValue]);
+
+  const onSelect = React.useCallback(
+    ({nativeEvent}: PickerItemSelectSyntheticEvent) => {
+      const {position} = nativeEvent;
+      const onValueChange = props.onValueChange;
+
+      if (onValueChange != null) {
+        if (position >= 0) {
+          const children = React.Children.toArray(props.children).filter(
+            item => item != null,
+          );
+          const value = children[position].props.value;
+          if (props.selectedValue !== value) {
+            onValueChange(value, position);
+          }
+        } else {
+          onValueChange(null, position);
+        }
+      }
+      const {current} = pickerRef;
+      if (current != null && position !== selected) {
+        const Commands =
+          props.mode === 'dropdown'
+            ? AndroidDropdownPickerCommands
+            : AndroidDialogPickerCommands;
+        Commands.setNativeSelectedPosition(current, selected);
+      }
+    },
+    [
+      props.children,
+      props.onValueChange,
+      props.selectedValue,
+      props.mode,
+      selected,
+    ],
+  );
+
+  const rootProps = {
+    accessibilityLabel: props.accessibilityLabel,
+    enabled: props.enabled,
+    items,
+    onSelect,
+    prompt: props.prompt,
+    ref: pickerRef,
+    selected,
+    style: StyleSheet.compose(
+      styles.pickerAndroid,
+      props.style,
+    ),
+    backgroundColor: props.backgroundColor,
+    testID: props.testID,
+  };
+  return props.mode === 'dropdown' ? (
+    <AndroidDropdownPickerNativeComponent {...rootProps} />
+  ) : (
+    <AndroidDialogPickerNativeComponent {...rootProps} />
+  );
+}
+
+const styles = StyleSheet.create({
+  pickerAndroid: {
+    // The picker will conform to whatever width is given, but we do
+    // have to set the component's height explicitly on the
+    // surrounding view to ensure it gets rendered.
+    // TODO would be better to export a native constant for this,
+    // like in iOS the RCTDatePickerManager.m
+    height: 50,
+  },
+});
+
+module.exports = PickerAndroid;

node_modules/react-native/Libraries/Components/Picker/PickerAndroid.ios.js

@@ -0,0 +1,12 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ */
+
+'use strict';
+
+module.exports = require('../UnimplementedViews/UnimplementedView');

node_modules/react-native/Libraries/Components/Picker/PickerIOS.android.js

@@ -0,0 +1,14 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ */
+
+// This is a controlled component version of RCTPickerIOS.
+
+'use strict';
+
+module.exports = require('../UnimplementedViews/UnimplementedView');

node_modules/react-native/Libraries/Components/Picker/PickerIOS.ios.js

@@ -0,0 +1,164 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @flow strict-local
+ */
+
+// This is a controlled component version of RCTPickerIOS.
+
+'use strict';
+
+const React = require('react');
+const StyleSheet = require('../../StyleSheet/StyleSheet');
+const View = require('../View/View');
+
+const invariant = require('invariant');
+const processColor = require('../../StyleSheet/processColor');
+
+import RCTPickerNativeComponent, {
+  Commands as PickerCommands,
+} from './RCTPickerNativeComponent';
+import type {TextStyleProp} from '../../StyleSheet/StyleSheet';
+import type {ColorValue} from '../../StyleSheet/StyleSheetTypes';
+import type {ProcessedColorValue} from '../../StyleSheet/processColor';
+import type {SyntheticEvent} from '../../Types/CoreEventTypes';
+import type {ViewProps} from '../View/ViewPropTypes';
+
+type PickerIOSChangeEvent = SyntheticEvent<
+  $ReadOnly<{|
+    newValue: number | string,
+    newIndex: number,
+  |}>,
+>;
+
+type RCTPickerIOSItemType = $ReadOnly<{|
+  label: ?Label,
+  value: ?(number | string),
+  textColor: ?ProcessedColorValue,
+|}>;
+
+type Label = Stringish | number;
+
+type Props = $ReadOnly<{|
+  ...ViewProps,
+  children: React.ChildrenArray<React.Element<typeof PickerIOSItem>>,
+  itemStyle?: ?TextStyleProp,
+  onChange?: ?(event: PickerIOSChangeEvent) => mixed,
+  onValueChange?: ?(itemValue: string | number, itemIndex: number) => mixed,
+  selectedValue: ?(number | string),
+  accessibilityLabel?: ?string,
+|}>;
+
+type State = {|
+  selectedIndex: number,
+  items: $ReadOnlyArray<RCTPickerIOSItemType>,
+|};
+
+type ItemProps = $ReadOnly<{|
+  label: ?Label,
+  value?: ?(number | string),
+  color?: ?ColorValue,
+|}>;
+
+const PickerIOSItem = (props: ItemProps): null => {
+  return null;
+};
+
+class PickerIOS extends React.Component<Props, State> {
+  _picker: ?React.ElementRef<typeof RCTPickerNativeComponent> = null;
+  _lastNativeValue: ?number;
+
+  state: State = {
+    selectedIndex: 0,
+    items: [],
+  };
+
+  static Item: (props: ItemProps) => null = PickerIOSItem;
+
+  static getDerivedStateFromProps(props: Props): State {
+    let selectedIndex = 0;
+    const items = [];
+    React.Children.toArray(props.children)
+      .filter(child => child !== null)
+      .forEach(function(child, index) {
+        if (child.props.value === props.selectedValue) {
+          selectedIndex = index;
+        }
+        const processedTextColor = processColor(child.props.color);
+        invariant(
+          processedTextColor == null || typeof processedTextColor === 'number',
+          'Unexpected color given for PickerIOSItem color',
+        );
+        items.push({
+          value: child.props.value,
+          label: child.props.label,
+          textColor: processedTextColor,
+        });
+      });
+    return {selectedIndex, items};
+  }
+
+  render(): React.Node {
+    return (
+      <View style={this.props.style}>
+        <RCTPickerNativeComponent
+          ref={picker => {
+            this._picker = picker;
+          }}
+          testID={this.props.testID}
+          style={[styles.pickerIOS, this.props.itemStyle]}
+          items={this.state.items}
+          selectedIndex={this.state.selectedIndex}
+          onChange={this._onChange}
+          accessibilityLabel={this.props.accessibilityLabel}
+        />
+      </View>
+    );
+  }
+
+  componentDidUpdate() {
+    // This is necessary in case native updates the picker and JS decides
+    // that the update should be ignored and we should stick with the value
+    // that we have in JS.
+    if (
+      this._picker &&
+      this._lastNativeValue !== undefined &&
+      this._lastNativeValue !== this.state.selectedIndex
+    ) {
+      PickerCommands.setNativeSelectedIndex(
+        this._picker,
+        this.state.selectedIndex,
+      );
+    }
+  }
+
+  _onChange = event => {
+    if (this.props.onChange) {
+      this.props.onChange(event);
+    }
+    if (this.props.onValueChange) {
+      this.props.onValueChange(
+        event.nativeEvent.newValue,
+        event.nativeEvent.newIndex,
+      );
+    }
+
+    this._lastNativeValue = event.nativeEvent.newIndex;
+    this.forceUpdate();
+  };
+}
+
+const styles = StyleSheet.create({
+  pickerIOS: {
+    // The picker will conform to whatever width is given, but we do
+    // have to set the component's height explicitly on the
+    // surrounding view to ensure it gets rendered.
+    height: 216,
+  },
+});
+
+module.exports = PickerIOS;

node_modules/react-native/Libraries/Components/Picker/RCTPickerNativeComponent.js

@@ -0,0 +1,63 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+'use strict';
+
+const requireNativeComponent = require('../../ReactNative/requireNativeComponent');
+
+import type {HostComponent} from '../../Renderer/shims/ReactNativeTypes';
+import type {SyntheticEvent} from '../../Types/CoreEventTypes';
+import type {TextStyleProp} from '../../StyleSheet/StyleSheet';
+import type {ProcessedColorValue} from '../../StyleSheet/processColor';
+import codegenNativeCommands from '../../Utilities/codegenNativeCommands';
+import * as React from 'react';
+
+type PickerIOSChangeEvent = SyntheticEvent<
+  $ReadOnly<{|
+    newValue: number | string,
+    newIndex: number,
+  |}>,
+>;
+
+type RCTPickerIOSItemType = $ReadOnly<{|
+  label: ?Label,
+  value: ?(number | string),
+  textColor: ?ProcessedColorValue,
+|}>;
+
+type Label = Stringish | number;
+
+type NativeProps = $ReadOnly<{|
+  items: $ReadOnlyArray<RCTPickerIOSItemType>,
+  onChange: (event: PickerIOSChangeEvent) => void,
+  selectedIndex: number,
+  style?: ?TextStyleProp,
+  testID?: ?string,
+  accessibilityLabel?: ?string,
+|}>;
+
+type ComponentType = HostComponent<NativeProps>;
+
+interface NativeCommands {
+  +setNativeSelectedIndex: (
+    viewRef: React.ElementRef<ComponentType>,
+    index: number,
+  ) => void;
+}
+
+export const Commands: NativeCommands = codegenNativeCommands<NativeCommands>({
+  supportedCommands: ['setNativeSelectedIndex'],
+});
+
+const RCTPickerNativeComponent: ComponentType = requireNativeComponent<NativeProps>(
+  'RCTPicker',
+);
+
+export default RCTPickerNativeComponent;

node_modules/react-native/Libraries/Components/Pressable/Pressable.js

@@ -0,0 +1,240 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+'use strict';
+
+import * as React from 'react';
+import {useMemo, useState, useRef, useImperativeHandle} from 'react';
+import useAndroidRippleForView, {
+  type RippleConfig,
+} from './useAndroidRippleForView';
+import type {
+  AccessibilityActionEvent,
+  AccessibilityActionInfo,
+  AccessibilityRole,
+  AccessibilityState,
+  AccessibilityValue,
+} from '../View/ViewAccessibility';
+import {PressabilityDebugView} from '../../Pressability/PressabilityDebug';
+import usePressability from '../../Pressability/usePressability';
+import {normalizeRect, type RectOrSize} from '../../StyleSheet/Rect';
+import type {ColorValue} from '../../StyleSheet/StyleSheetTypes';
+import type {LayoutEvent, PressEvent} from '../../Types/CoreEventTypes';
+import View from '../View/View';
+
+type ViewStyleProp = $ElementType<React.ElementConfig<typeof View>, 'style'>;
+
+export type StateCallbackType = $ReadOnly<{|
+  pressed: boolean,
+|}>;
+
+type Props = $ReadOnly<{|
+  /**
+   * Accessibility.
+   */
+  accessibilityActions?: ?$ReadOnlyArray<AccessibilityActionInfo>,
+  accessibilityElementsHidden?: ?boolean,
+  accessibilityHint?: ?Stringish,
+  accessibilityIgnoresInvertColors?: ?boolean,
+  accessibilityLabel?: ?Stringish,
+  accessibilityLiveRegion?: ?('none' | 'polite' | 'assertive'),
+  accessibilityRole?: ?AccessibilityRole,
+  accessibilityState?: ?AccessibilityState,
+  accessibilityValue?: ?AccessibilityValue,
+  accessibilityViewIsModal?: ?boolean,
+  accessible?: ?boolean,
+  focusable?: ?boolean,
+  importantForAccessibility?: ?('auto' | 'yes' | 'no' | 'no-hide-descendants'),
+  onAccessibilityAction?: ?(event: AccessibilityActionEvent) => mixed,
+
+  /**
+   * Either children or a render prop that receives a boolean reflecting whether
+   * the component is currently pressed.
+   */
+  children: React.Node | ((state: StateCallbackType) => React.Node),
+
+  /**
+   * Duration (in milliseconds) from `onPressIn` before `onLongPress` is called.
+   */
+  delayLongPress?: ?number,
+
+  /**
+   * Whether the press behavior is disabled.
+   */
+  disabled?: ?boolean,
+
+  /**
+   * Additional distance outside of this view in which a press is detected.
+   */
+  hitSlop?: ?RectOrSize,
+
+  /**
+   * Additional distance outside of this view in which a touch is considered a
+   * press before `onPressOut` is triggered.
+   */
+  pressRetentionOffset?: ?RectOrSize,
+
+  /**
+   * Called when this view's layout changes.
+   */
+  onLayout?: ?(event: LayoutEvent) => void,
+
+  /**
+   * Called when a long-tap gesture is detected.
+   */
+  onLongPress?: ?(event: PressEvent) => void,
+
+  /**
+   * Called when a single tap gesture is detected.
+   */
+  onPress?: ?(event: PressEvent) => void,
+
+  /**
+   * Called when a touch is engaged before `onPress`.
+   */
+  onPressIn?: ?(event: PressEvent) => void,
+
+  /**
+   * Called when a touch is released before `onPress`.
+   */
+  onPressOut?: ?(event: PressEvent) => void,
+
+  /**
+   * Either view styles or a function that receives a boolean reflecting whether
+   * the component is currently pressed and returns view styles.
+   */
+  style?: ViewStyleProp | ((state: StateCallbackType) => ViewStyleProp),
+
+  /**
+   * Identifier used to find this view in tests.
+   */
+  testID?: ?string,
+
+  /**
+   * If true, doesn't play system sound on touch.
+   */
+  android_disableSound?: ?boolean,
+
+  /**
+   * Enables the Android ripple effect and configures its color.
+   */
+  android_ripple?: ?RippleConfig,
+
+  /**
+   * Used only for documentation or testing (e.g. snapshot testing).
+   */
+  testOnly_pressed?: ?boolean,
+|}>;
+
+/**
+ * Component used to build display components that should respond to whether the
+ * component is currently pressed or not.
+ */
+function Pressable(props: Props, forwardedRef): React.Node {
+  const {
+    accessible,
+    android_disableSound,
+    android_ripple,
+    children,
+    delayLongPress,
+    disabled,
+    focusable,
+    onLongPress,
+    onPress,
+    onPressIn,
+    onPressOut,
+    pressRetentionOffset,
+    style,
+    testOnly_pressed,
+    ...restProps
+  } = props;
+
+  const viewRef = useRef<React.ElementRef<typeof View> | null>(null);
+  useImperativeHandle(forwardedRef, () => viewRef.current);
+
+  const android_rippleConfig = useAndroidRippleForView(android_ripple, viewRef);
+
+  const [pressed, setPressed] = usePressState(testOnly_pressed === true);
+
+  const hitSlop = normalizeRect(props.hitSlop);
+
+  const config = useMemo(
+    () => ({
+      disabled,
+      hitSlop,
+      pressRectOffset: pressRetentionOffset,
+      android_disableSound,
+      delayLongPress,
+      onLongPress,
+      onPress,
+      onPressIn(event: PressEvent): void {
+        if (android_rippleConfig != null) {
+          android_rippleConfig.onPressIn(event);
+        }
+        setPressed(true);
+        if (onPressIn != null) {
+          onPressIn(event);
+        }
+      },
+      onPressMove: android_rippleConfig?.onPressMove,
+      onPressOut(event: PressEvent): void {
+        if (android_rippleConfig != null) {
+          android_rippleConfig.onPressOut(event);
+        }
+        setPressed(false);
+        if (onPressOut != null) {
+          onPressOut(event);
+        }
+      },
+    }),
+    [
+      android_disableSound,
+      android_rippleConfig,
+      delayLongPress,
+      disabled,
+      hitSlop,
+      onLongPress,
+      onPress,
+      onPressIn,
+      onPressOut,
+      pressRetentionOffset,
+      setPressed,
+    ],
+  );
+  const eventHandlers = usePressability(config);
+
+  return (
+    <View
+      {...restProps}
+      {...eventHandlers}
+      {...android_rippleConfig?.viewProps}
+      accessible={accessible !== false}
+      focusable={focusable !== false}
+      hitSlop={hitSlop}
+      ref={viewRef}
+      style={typeof style === 'function' ? style({pressed}) : style}>
+      {typeof children === 'function' ? children({pressed}) : children}
+      {__DEV__ ? <PressabilityDebugView color="red" hitSlop={hitSlop} /> : null}
+    </View>
+  );
+}
+
+function usePressState(forcePressed: boolean): [boolean, (boolean) => void] {
+  const [pressed, setPressed] = useState(false);
+  return [pressed || forcePressed, setPressed];
+}
+
+const MemoedPressable = React.memo(React.forwardRef(Pressable));
+MemoedPressable.displayName = 'Pressable';
+
+export default (MemoedPressable: React.AbstractComponent<
+  Props,
+  React.ElementRef<typeof View>,
+>);

node_modules/react-native/Libraries/Components/Pressable/useAndroidRippleForView.js

@@ -0,0 +1,105 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+'use strict';
+
+import invariant from 'invariant';
+import {Commands} from '../View/ViewNativeComponent';
+import type {ColorValue} from '../../StyleSheet/StyleSheetTypes';
+import type {PressEvent} from '../../Types/CoreEventTypes';
+import {Platform, View, processColor} from 'react-native';
+import * as React from 'react';
+import {useMemo} from 'react';
+
+type NativeBackgroundProp = $ReadOnly<{|
+  type: 'RippleAndroid',
+  color: ?number,
+  borderless: boolean,
+  rippleRadius: ?number,
+|}>;
+
+export type RippleConfig = {|
+  color?: ?ColorValue,
+  borderless?: ?boolean,
+  radius?: ?number,
+|};
+
+/**
+ * Provides the event handlers and props for configuring the ripple effect on
+ * supported versions of Android.
+ */
+export default function useAndroidRippleForView(
+  rippleConfig: ?RippleConfig,
+  viewRef: {|current: null | React.ElementRef<typeof View>|},
+): ?$ReadOnly<{|
+  onPressIn: (event: PressEvent) => void,
+  onPressMove: (event: PressEvent) => void,
+  onPressOut: (event: PressEvent) => void,
+  viewProps: $ReadOnly<{|
+    nativeBackgroundAndroid: NativeBackgroundProp,
+  |}>,
+|}> {
+  const {color, borderless, radius} = rippleConfig ?? {};
+  const normalizedBorderless = borderless === true;
+
+  return useMemo(() => {
+    if (
+      Platform.OS === 'android' &&
+      Platform.Version >= 21 &&
+      (color != null || normalizedBorderless || radius != null)
+    ) {
+      const processedColor = processColor(color);
+      invariant(
+        processedColor == null || typeof processedColor === 'number',
+        'Unexpected color given for Ripple color',
+      );
+
+      return {
+        viewProps: {
+          // Consider supporting `nativeForegroundAndroid`
+          nativeBackgroundAndroid: {
+            type: 'RippleAndroid',
+            color: processedColor,
+            borderless: normalizedBorderless,
+            rippleRadius: radius,
+          },
+        },
+        onPressIn(event: PressEvent): void {
+          const view = viewRef.current;
+          if (view != null) {
+            Commands.setPressed(view, true);
+            Commands.hotspotUpdate(
+              view,
+              event.nativeEvent.locationX ?? 0,
+              event.nativeEvent.locationY ?? 0,
+            );
+          }
+        },
+        onPressMove(event: PressEvent): void {
+          const view = viewRef.current;
+          if (view != null) {
+            Commands.hotspotUpdate(
+              view,
+              event.nativeEvent.locationX ?? 0,
+              event.nativeEvent.locationY ?? 0,
+            );
+          }
+        },
+        onPressOut(event: PressEvent): void {
+          const view = viewRef.current;
+          if (view != null) {
+            Commands.setPressed(view, false);
+          }
+        },
+      };
+    }
+    return null;
+  }, [color, normalizedBorderless, radius, viewRef]);
+}

node_modules/react-native/Libraries/Components/ProgressBarAndroid/ProgressBarAndroid.android.js

@@ -0,0 +1,104 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+'use strict';
+
+const React = require('react');
+
+import ProgressBarAndroidNativeComponent from './ProgressBarAndroidNativeComponent';
+
+import type {ViewProps} from '../View/ViewPropTypes';
+import type {ColorValue} from '../../StyleSheet/StyleSheetTypes';
+
+export type ProgressBarAndroidProps = $ReadOnly<{|
+  ...ViewProps,
+
+  /**
+   * Style of the ProgressBar and whether it shows indeterminate progress (e.g. spinner).
+   *
+   * `indeterminate` can only be false if `styleAttr` is Horizontal, and requires a
+   * `progress` value.
+   */
+  ...
+    | {|
+        styleAttr: 'Horizontal',
+        indeterminate: false,
+        progress: number,
+      |}
+    | {|
+        typeAttr:
+          | 'Horizontal'
+          | 'Normal'
+          | 'Small'
+          | 'Large'
+          | 'Inverse'
+          | 'SmallInverse'
+          | 'LargeInverse',
+        indeterminate: true,
+      |},
+  /**
+   * Whether to show the ProgressBar (true, the default) or hide it (false).
+   */
+  animating?: ?boolean,
+  /**
+   * Color of the progress bar.
+   */
+  color?: ?ColorValue,
+  /**
+   * Used to locate this view in end-to-end tests.
+   */
+  testID?: ?string,
+|}>;
+
+/**
+ * React component that wraps the Android-only `ProgressBar`. This component is
+ * used to indicate that the app is loading or there is activity in the app.
+ *
+ * Example:
+ *
+ * ```
+ * render: function() {
+ *   var progressBar =
+ *     <View style={styles.container}>
+ *       <ProgressBar styleAttr="Inverse" />
+ *     </View>;
+
+ *   return (
+ *     <MyLoadingComponent
+ *       componentView={componentView}
+ *       loadingView={progressBar}
+ *       style={styles.loadingComponent}
+ *     />
+ *   );
+ * },
+ * ```
+ */
+const ProgressBarAndroid = (
+  props: ProgressBarAndroidProps,
+  forwardedRef: ?React.Ref<typeof ProgressBarAndroidNativeComponent>,
+) => {
+  return <ProgressBarAndroidNativeComponent {...props} ref={forwardedRef} />;
+};
+
+const ProgressBarAndroidToExport = React.forwardRef(ProgressBarAndroid);
+
+/* $FlowFixMe(>=0.89.0 site=react_native_android_fb) This comment suppresses an
+ * error found when Flow v0.89 was deployed. To see the error, delete this
+ * comment and run Flow. */
+ProgressBarAndroidToExport.defaultProps = {
+  styleAttr: 'Normal',
+  indeterminate: true,
+  animating: true,
+};
+
+/* $FlowFixMe(>=0.89.0 site=react_native_android_fb) This comment suppresses an
+ * error found when Flow v0.89 was deployed. To see the error, delete this
+ * comment and run Flow. */
+module.exports = (ProgressBarAndroidToExport: typeof ProgressBarAndroidNativeComponent);

node_modules/react-native/Libraries/Components/ProgressBarAndroid/ProgressBarAndroid.ios.js

@@ -0,0 +1,12 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ */
+
+'use strict';
+
+module.exports = require('../UnimplementedViews/UnimplementedView');

node_modules/react-native/Libraries/Components/ProgressBarAndroid/ProgressBarAndroidNativeComponent.js

@@ -0,0 +1,35 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+'use strict';
+
+import type {ColorValue} from '../../StyleSheet/StyleSheetTypes';
+import type {ViewProps} from '../View/ViewPropTypes';
+import type {Double, WithDefault} from '../../Types/CodegenTypes';
+
+import codegenNativeComponent from '../../Utilities/codegenNativeComponent';
+import type {HostComponent} from '../../Renderer/shims/ReactNativeTypes';
+
+type NativeProps = $ReadOnly<{|
+  ...ViewProps,
+
+  //Props
+  styleAttr?: string,
+  typeAttr?: string,
+  indeterminate: boolean,
+  progress?: WithDefault<Double, 0>,
+  animating?: WithDefault<boolean, true>,
+  color?: ?ColorValue,
+  testID?: WithDefault<string, ''>,
+|}>;
+
+export default (codegenNativeComponent<NativeProps>(
+  'AndroidProgressBar',
+): HostComponent<NativeProps>);

node_modules/react-native/Libraries/Components/ProgressViewIOS/ProgressViewIOS.android.js

@@ -0,0 +1,46 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ */
+
+'use strict';
+
+const React = require('react');
+const StyleSheet = require('../../StyleSheet/StyleSheet');
+const Text = require('../../Text/Text');
+const View = require('../View/View');
+
+class DummyProgressViewIOS extends React.Component {
+  render() {
+    return (
+      <View style={[styles.dummy, this.props.style]}>
+        <Text style={styles.text}>
+          ProgressViewIOS is not supported on this platform!
+        </Text>
+      </View>
+    );
+  }
+}
+
+const styles = StyleSheet.create({
+  dummy: {
+    width: 120,
+    height: 20,
+    backgroundColor: '#ffbcbc',
+    borderWidth: 1,
+    borderColor: 'red',
+    alignItems: 'center',
+    justifyContent: 'center',
+  },
+  text: {
+    color: '#333333',
+    margin: 5,
+    fontSize: 10,
+  },
+});
+
+module.exports = DummyProgressViewIOS;

node_modules/react-native/Libraries/Components/ProgressViewIOS/ProgressViewIOS.ios.js

@@ -0,0 +1,77 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @flow strict-local
+ */
+
+'use strict';
+
+const React = require('react');
+const StyleSheet = require('../../StyleSheet/StyleSheet');
+
+import RCTProgressViewNativeComponent from './RCTProgressViewNativeComponent';
+import type {ImageSource} from '../../Image/ImageSource';
+import type {ColorValue} from '../../StyleSheet/StyleSheetTypes';
+import type {ViewProps} from '../View/ViewPropTypes';
+
+type Props = $ReadOnly<{|
+  ...ViewProps,
+
+  /**
+   * The progress bar style.
+   */
+  progressViewStyle?: ?('default' | 'bar'),
+
+  /**
+   * The progress value (between 0 and 1).
+   */
+  progress?: ?number,
+
+  /**
+   * The tint color of the progress bar itself.
+   */
+  progressTintColor?: ?ColorValue,
+
+  /**
+   * The tint color of the progress bar track.
+   */
+  trackTintColor?: ?ColorValue,
+
+  /**
+   * A stretchable image to display as the progress bar.
+   */
+  progressImage?: ?ImageSource,
+
+  /**
+   * A stretchable image to display behind the progress bar.
+   */
+  trackImage?: ?ImageSource,
+|}>;
+
+/**
+ * Use `ProgressViewIOS` to render a UIProgressView on iOS.
+ */
+const ProgressViewIOS = (
+  props: Props,
+  forwardedRef?: ?React.Ref<typeof RCTProgressViewNativeComponent>,
+) => (
+  <RCTProgressViewNativeComponent
+    {...props}
+    style={[styles.progressView, props.style]}
+    ref={forwardedRef}
+  />
+);
+
+const styles = StyleSheet.create({
+  progressView: {
+    height: 2,
+  },
+});
+
+const ProgressViewIOSWithRef = React.forwardRef(ProgressViewIOS);
+
+module.exports = (ProgressViewIOSWithRef: typeof RCTProgressViewNativeComponent);

node_modules/react-native/Libraries/Components/ProgressViewIOS/RCTProgressViewNativeComponent.js

@@ -0,0 +1,35 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+'use strict';
+
+import type {Float, WithDefault} from '../../Types/CodegenTypes';
+import type {ImageSource} from '../../Image/ImageSource';
+import type {ColorValue} from '../../StyleSheet/StyleSheetTypes';
+import type {ViewProps} from '../View/ViewPropTypes';
+
+import codegenNativeComponent from '../../Utilities/codegenNativeComponent';
+import type {HostComponent} from '../../Renderer/shims/ReactNativeTypes';
+
+type NativeProps = $ReadOnly<{|
+  ...ViewProps,
+
+  // Props
+  progressViewStyle?: WithDefault<'default' | 'bar', 'default'>,
+  progress?: WithDefault<Float, 0>,
+  progressTintColor?: ?ColorValue,
+  trackTintColor?: ?ColorValue,
+  progressImage?: ?ImageSource,
+  trackImage?: ?ImageSource,
+|}>;
+
+export default (codegenNativeComponent<NativeProps>(
+  'RCTProgressView',
+): HostComponent<NativeProps>);

node_modules/react-native/Libraries/Components/RefreshControl/AndroidSwipeRefreshLayoutNativeComponent.js

@@ -0,0 +1,86 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @flow strict-local
+ */
+
+'use strict';
+
+import * as React from 'react';
+
+import codegenNativeCommands from 'react-native/Libraries/Utilities/codegenNativeCommands';
+import codegenNativeComponent from '../../Utilities/codegenNativeComponent';
+import type {HostComponent} from '../../Renderer/shims/ReactNativeTypes';
+
+import type {
+  DirectEventHandler,
+  Float,
+  Int32,
+  WithDefault,
+} from '../../Types/CodegenTypes';
+import type {ColorValue} from '../../StyleSheet/StyleSheetTypes';
+import type {ViewProps} from '../View/ViewPropTypes';
+
+type NativeProps = $ReadOnly<{|
+  ...ViewProps,
+
+  /**
+   * Whether the pull to refresh functionality is enabled.
+   */
+  enabled?: WithDefault<boolean, true>,
+  /**
+   * The colors (at least one) that will be used to draw the refresh indicator.
+   */
+  colors?: ?$ReadOnlyArray<ColorValue>,
+  /**
+   * The background color of the refresh indicator.
+   */
+  progressBackgroundColor?: ?ColorValue,
+  /**
+   * Size of the refresh indicator, see RefreshControl.SIZE.
+   *
+   * This type isn't currently accurate. It really is specific numbers
+   * hard coded in the Android platform.
+   *
+   * Also, 1 isn't actually a safe default. We are able to set this here
+   * because native code isn't currently consuming the generated artifact.
+   * This will end up being
+   * size?: WithDefault<'default' | 'large', 'default'>,
+   */
+  size?: WithDefault<Int32, 1>,
+  /**
+   * Progress view top offset
+   */
+  progressViewOffset?: WithDefault<Float, 0>,
+
+  /**
+   * Called when the view starts refreshing.
+   */
+  onRefresh?: ?DirectEventHandler<null>,
+
+  /**
+   * Whether the view should be indicating an active refresh.
+   */
+  refreshing: boolean,
+|}>;
+
+type NativeType = HostComponent<NativeProps>;
+
+interface NativeCommands {
+  +setNativeRefreshing: (
+    viewRef: React.ElementRef<NativeType>,
+    value: boolean,
+  ) => void;
+}
+
+export const Commands: NativeCommands = codegenNativeCommands<NativeCommands>({
+  supportedCommands: ['setNativeRefreshing'],
+});
+
+export default (codegenNativeComponent<NativeProps>(
+  'AndroidSwipeRefreshLayout',
+): NativeType);

node_modules/react-native/Libraries/Components/RefreshControl/PullToRefreshViewNativeComponent.js

@@ -0,0 +1,65 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @flow strict-local
+ */
+
+'use strict';
+
+import type {DirectEventHandler, WithDefault} from '../../Types/CodegenTypes';
+import type {ColorValue} from '../../StyleSheet/StyleSheetTypes';
+import type {ViewProps} from '../View/ViewPropTypes';
+import * as React from 'react';
+
+import codegenNativeComponent from '../../Utilities/codegenNativeComponent';
+import type {HostComponent} from '../../Renderer/shims/ReactNativeTypes';
+import codegenNativeCommands from 'react-native/Libraries/Utilities/codegenNativeCommands';
+
+type NativeProps = $ReadOnly<{|
+  ...ViewProps,
+
+  /**
+   * The color of the refresh indicator.
+   */
+  tintColor?: ?ColorValue,
+  /**
+   * Title color.
+   */
+  titleColor?: ?ColorValue,
+  /**
+   * The title displayed under the refresh indicator.
+   */
+  title?: WithDefault<string, null>,
+
+  /**
+   * Called when the view starts refreshing.
+   */
+  onRefresh?: ?DirectEventHandler<null>,
+
+  /**
+   * Whether the view should be indicating an active refresh.
+   */
+  refreshing: boolean,
+|}>;
+
+type ComponentType = HostComponent<NativeProps>;
+
+interface NativeCommands {
+  +setNativeRefreshing: (
+    viewRef: React.ElementRef<ComponentType>,
+    refreshing: boolean,
+  ) => void;
+}
+
+export const Commands: NativeCommands = codegenNativeCommands<NativeCommands>({
+  supportedCommands: ['setNativeRefreshing'],
+});
+
+export default (codegenNativeComponent<NativeProps>('PullToRefreshView', {
+  paperComponentName: 'RCTRefreshControl',
+  excludedPlatform: 'android',
+}): HostComponent<NativeProps>);

node_modules/react-native/Libraries/Components/RefreshControl/RefreshControl.js

@@ -0,0 +1,226 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @flow
+ */
+
+'use strict';
+
+const Platform = require('../../Utilities/Platform');
+const React = require('react');
+
+import type {ColorValue} from '../../StyleSheet/StyleSheetTypes';
+import type {ViewProps} from '../View/ViewPropTypes';
+import AndroidSwipeRefreshLayoutNativeComponent, {
+  Commands as AndroidSwipeRefreshLayoutCommands,
+} from './AndroidSwipeRefreshLayoutNativeComponent';
+import PullToRefreshViewNativeComponent, {
+  Commands as PullToRefreshCommands,
+} from './PullToRefreshViewNativeComponent';
+
+let RefreshLayoutConsts: any;
+if (Platform.OS === 'android') {
+  const AndroidSwipeRefreshLayout = require('../../ReactNative/UIManager').getViewManagerConfig(
+    'AndroidSwipeRefreshLayout',
+  );
+  RefreshLayoutConsts = AndroidSwipeRefreshLayout
+    ? AndroidSwipeRefreshLayout.Constants
+    : {SIZE: {}};
+} else {
+  RefreshLayoutConsts = {SIZE: {}};
+}
+
+type IOSProps = $ReadOnly<{|
+  /**
+   * The color of the refresh indicator.
+   */
+  tintColor?: ?ColorValue,
+  /**
+   * Title color.
+   */
+  titleColor?: ?ColorValue,
+  /**
+   * The title displayed under the refresh indicator.
+   */
+  title?: ?string,
+|}>;
+
+type AndroidProps = $ReadOnly<{|
+  /**
+   * Whether the pull to refresh functionality is enabled.
+   */
+  enabled?: ?boolean,
+  /**
+   * The colors (at least one) that will be used to draw the refresh indicator.
+   */
+  colors?: ?$ReadOnlyArray<ColorValue>,
+  /**
+   * The background color of the refresh indicator.
+   */
+  progressBackgroundColor?: ?ColorValue,
+  /**
+   * Size of the refresh indicator, see RefreshControl.SIZE.
+   */
+  size?: ?(
+    | typeof RefreshLayoutConsts.SIZE.DEFAULT
+    | typeof RefreshLayoutConsts.SIZE.LARGE
+  ),
+  /**
+   * Progress view top offset
+   */
+  progressViewOffset?: ?number,
+|}>;
+
+export type RefreshControlProps = $ReadOnly<{|
+  ...ViewProps,
+  ...IOSProps,
+  ...AndroidProps,
+
+  /**
+   * Called when the view starts refreshing.
+   */
+  onRefresh?: ?() => void | Promise<void>,
+
+  /**
+   * Whether the view should be indicating an active refresh.
+   */
+  refreshing: boolean,
+|}>;
+
+/**
+ * This component is used inside a ScrollView or ListView to add pull to refresh
+ * functionality. When the ScrollView is at `scrollY: 0`, swiping down
+ * triggers an `onRefresh` event.
+ *
+ * ### Usage example
+ *
+ * ``` js
+ * class RefreshableList extends Component {
+ *   constructor(props) {
+ *     super(props);
+ *     this.state = {
+ *       refreshing: false,
+ *     };
+ *   }
+ *
+ *   _onRefresh() {
+ *     this.setState({refreshing: true});
+ *     fetchData().then(() => {
+ *       this.setState({refreshing: false});
+ *     });
+ *   }
+ *
+ *   render() {
+ *     return (
+ *       <ListView
+ *         refreshControl={
+ *           <RefreshControl
+ *             refreshing={this.state.refreshing}
+ *             onRefresh={this._onRefresh.bind(this)}
+ *           />
+ *         }
+ *         ...
+ *       >
+ *       ...
+ *       </ListView>
+ *     );
+ *   }
+ *   ...
+ * }
+ * ```
+ *
+ * __Note:__ `refreshing` is a controlled prop, this is why it needs to be set to true
+ * in the `onRefresh` function otherwise the refresh indicator will stop immediately.
+ */
+class RefreshControl extends React.Component<RefreshControlProps> {
+  static SIZE: any = RefreshLayoutConsts.SIZE;
+
+  _nativeRef: ?React.ElementRef<
+    | typeof PullToRefreshViewNativeComponent
+    | typeof AndroidSwipeRefreshLayoutNativeComponent,
+  >;
+  _lastNativeRefreshing = false;
+
+  componentDidMount() {
+    this._lastNativeRefreshing = this.props.refreshing;
+  }
+
+  componentDidUpdate(prevProps: RefreshControlProps) {
+    // RefreshControl is a controlled component so if the native refreshing
+    // value doesn't match the current js refreshing prop update it to
+    // the js value.
+    if (this.props.refreshing !== prevProps.refreshing) {
+      this._lastNativeRefreshing = this.props.refreshing;
+    } else if (
+      this.props.refreshing !== this._lastNativeRefreshing &&
+      this._nativeRef
+    ) {
+      if (Platform.OS === 'android') {
+        AndroidSwipeRefreshLayoutCommands.setNativeRefreshing(
+          this._nativeRef,
+          this.props.refreshing,
+        );
+      } else {
+        PullToRefreshCommands.setNativeRefreshing(
+          this._nativeRef,
+          this.props.refreshing,
+        );
+      }
+      this._lastNativeRefreshing = this.props.refreshing;
+    }
+  }
+
+  render(): React.Node {
+    if (Platform.OS === 'ios') {
+      const {
+        enabled,
+        colors,
+        progressBackgroundColor,
+        size,
+        progressViewOffset,
+        ...props
+      } = this.props;
+      return (
+        <PullToRefreshViewNativeComponent
+          {...props}
+          ref={this._setNativeRef}
+          onRefresh={this._onRefresh}
+        />
+      );
+    } else {
+      const {tintColor, titleColor, title, ...props} = this.props;
+      return (
+        <AndroidSwipeRefreshLayoutNativeComponent
+          {...props}
+          ref={this._setNativeRef}
+          onRefresh={this._onRefresh}
+        />
+      );
+    }
+  }
+
+  _onRefresh = () => {
+    this._lastNativeRefreshing = true;
+
+    this.props.onRefresh && this.props.onRefresh();
+
+    // The native component will start refreshing so force an update to
+    // make sure it stays in sync with the js component.
+    this.forceUpdate();
+  };
+
+  _setNativeRef = (
+    ref: ?React.ElementRef<
+      | typeof PullToRefreshViewNativeComponent
+      | typeof AndroidSwipeRefreshLayoutNativeComponent,
+    >,
+  ) => {
+    this._nativeRef = ref;
+  };
+}
+
+module.exports = RefreshControl;

node_modules/react-native/Libraries/Components/RefreshControl/__mocks__/RefreshControlMock.js

@@ -0,0 +1,33 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @flow strict-local
+ */
+
+'use strict';
+
+const React = require('react');
+
+const requireNativeComponent = require('../../../ReactNative/requireNativeComponent');
+
+import type {HostComponent} from '../../../Renderer/shims/ReactNativeTypes';
+
+const RCTRefreshControl: HostComponent<mixed> = requireNativeComponent<mixed>(
+  'RCTRefreshControl',
+);
+
+class RefreshControlMock extends React.Component<{...}> {
+  static latestRef: ?RefreshControlMock;
+  componentDidMount() {
+    RefreshControlMock.latestRef = this;
+  }
+  render(): React.Element<typeof RCTRefreshControl> {
+    return <RCTRefreshControl />;
+  }
+}
+
+module.exports = RefreshControlMock;

node_modules/react-native/Libraries/Components/SafeAreaView/RCTSafeAreaViewNativeComponent.js

@@ -0,0 +1,29 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @flow strict-local
+ */
+
+'use strict';
+
+import type {ViewProps} from '../View/ViewPropTypes';
+import type {WithDefault} from '../../Types/CodegenTypes';
+
+import codegenNativeComponent from '../../Utilities/codegenNativeComponent';
+import type {HostComponent} from '../../Renderer/shims/ReactNativeTypes';
+
+type NativeProps = $ReadOnly<{|
+  ...ViewProps,
+
+  // Props
+  emulateUnlessSupported?: WithDefault<boolean, false>,
+|}>;
+
+export default (codegenNativeComponent<NativeProps>('SafeAreaView', {
+  paperComponentName: 'RCTSafeAreaView',
+  interfaceOnly: true,
+}): HostComponent<NativeProps>);

node_modules/react-native/Libraries/Components/SafeAreaView/SafeAreaView.js

@@ -0,0 +1,61 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+const Platform = require('../../Utilities/Platform');
+const React = require('react');
+const View = require('../View/View');
+
+import type {HostComponent} from '../../Renderer/shims/ReactNativeTypes';
+import type {ViewProps} from '../View/ViewPropTypes';
+
+type Props = $ReadOnly<{|
+  ...ViewProps,
+  emulateUnlessSupported?: boolean,
+|}>;
+
+let exported: React.AbstractComponent<
+  Props,
+  React.ElementRef<HostComponent<mixed>>,
+>;
+
+/**
+ * Renders nested content and automatically applies paddings reflect the portion
+ * of the view that is not covered by navigation bars, tab bars, toolbars, and
+ * other ancestor views.
+ *
+ * Moreover, and most importantly, Safe Area's paddings reflect physical
+ * limitation of the screen, such as rounded corners or camera notches (aka
+ * sensor housing area on iPhone X).
+ */
+if (Platform.OS === 'android') {
+  exported = React.forwardRef<Props, React.ElementRef<HostComponent<mixed>>>(
+    function SafeAreaView(props, forwardedRef) {
+      const {emulateUnlessSupported, ...localProps} = props;
+      return <View {...localProps} ref={forwardedRef} />;
+    },
+  );
+} else {
+  const RCTSafeAreaViewNativeComponent = require('./RCTSafeAreaViewNativeComponent')
+    .default;
+
+  exported = React.forwardRef<Props, React.ElementRef<HostComponent<mixed>>>(
+    function SafeAreaView(props, forwardedRef) {
+      return (
+        <RCTSafeAreaViewNativeComponent
+          emulateUnlessSupported={true}
+          {...props}
+          ref={forwardedRef}
+        />
+      );
+    },
+  );
+}
+
+module.exports = exported;

node_modules/react-native/Libraries/Components/ScrollResponder.js

@@ -0,0 +1,773 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @flow
+ */
+
+'use strict';
+
+const React = require('react');
+const Dimensions = require('../Utilities/Dimensions');
+const FrameRateLogger = require('../Interaction/FrameRateLogger');
+const Keyboard = require('./Keyboard/Keyboard');
+const ReactNative = require('../Renderer/shims/ReactNative');
+const TextInputState = require('./TextInput/TextInputState');
+const UIManager = require('../ReactNative/UIManager');
+const Platform = require('../Utilities/Platform');
+import Commands from './ScrollView/ScrollViewCommands';
+
+const invariant = require('invariant');
+const performanceNow = require('fbjs/lib/performanceNow');
+
+import type {PressEvent, ScrollEvent} from '../Types/CoreEventTypes';
+import typeof ScrollView from './ScrollView/ScrollView';
+import type {Props as ScrollViewProps} from './ScrollView/ScrollView';
+import type {KeyboardEvent} from './Keyboard/Keyboard';
+import type EmitterSubscription from '../vendor/emitter/EmitterSubscription';
+import type {HostComponent} from '../Renderer/shims/ReactNativeTypes';
+
+/**
+ * Mixin that can be integrated in order to handle scrolling that plays well
+ * with `ResponderEventPlugin`. Integrate with your platform specific scroll
+ * views, or even your custom built (every-frame animating) scroll views so that
+ * all of these systems play well with the `ResponderEventPlugin`.
+ *
+ * iOS scroll event timing nuances:
+ * ===============================
+ *
+ *
+ * Scrolling without bouncing, if you touch down:
+ * -------------------------------
+ *
+ * 1. `onMomentumScrollBegin` (when animation begins after letting up)
+ *    ... physical touch starts ...
+ * 2. `onTouchStartCapture`   (when you press down to stop the scroll)
+ * 3. `onTouchStart`          (same, but bubble phase)
+ * 4. `onResponderRelease`    (when lifting up - you could pause forever before * lifting)
+ * 5. `onMomentumScrollEnd`
+ *
+ *
+ * Scrolling with bouncing, if you touch down:
+ * -------------------------------
+ *
+ * 1. `onMomentumScrollBegin` (when animation begins after letting up)
+ *    ... bounce begins ...
+ *    ... some time elapses ...
+ *    ... physical touch during bounce ...
+ * 2. `onMomentumScrollEnd`   (Makes no sense why this occurs first during bounce)
+ * 3. `onTouchStartCapture`   (immediately after `onMomentumScrollEnd`)
+ * 4. `onTouchStart`          (same, but bubble phase)
+ * 5. `onTouchEnd`            (You could hold the touch start for a long time)
+ * 6. `onMomentumScrollBegin` (When releasing the view starts bouncing back)
+ *
+ * So when we receive an `onTouchStart`, how can we tell if we are touching
+ * *during* an animation (which then causes the animation to stop)? The only way
+ * to tell is if the `touchStart` occurred immediately after the
+ * `onMomentumScrollEnd`.
+ *
+ * This is abstracted out for you, so you can just call this.scrollResponderIsAnimating() if
+ * necessary
+ *
+ * `ScrollResponder` also includes logic for blurring a currently focused input
+ * if one is focused while scrolling. The `ScrollResponder` is a natural place
+ * to put this logic since it can support not dismissing the keyboard while
+ * scrolling, unless a recognized "tap"-like gesture has occurred.
+ *
+ * The public lifecycle API includes events for keyboard interaction, responder
+ * interaction, and scrolling (among others). The keyboard callbacks
+ * `onKeyboardWill/Did/*` are *global* events, but are invoked on scroll
+ * responder's props so that you can guarantee that the scroll responder's
+ * internal state has been updated accordingly (and deterministically) by
+ * the time the props callbacks are invoke. Otherwise, you would always wonder
+ * if the scroll responder is currently in a state where it recognizes new
+ * keyboard positions etc. If coordinating scrolling with keyboard movement,
+ * *always* use these hooks instead of listening to your own global keyboard
+ * events.
+ *
+ * Public keyboard lifecycle API: (props callbacks)
+ *
+ * Standard Keyboard Appearance Sequence:
+ *
+ *   this.props.onKeyboardWillShow
+ *   this.props.onKeyboardDidShow
+ *
+ * `onScrollResponderKeyboardDismissed` will be invoked if an appropriate
+ * tap inside the scroll responder's scrollable region was responsible
+ * for the dismissal of the keyboard. There are other reasons why the
+ * keyboard could be dismissed.
+ *
+ *   this.props.onScrollResponderKeyboardDismissed
+ *
+ * Standard Keyboard Hide Sequence:
+ *
+ *   this.props.onKeyboardWillHide
+ *   this.props.onKeyboardDidHide
+ */
+
+const IS_ANIMATING_TOUCH_START_THRESHOLD_MS = 16;
+
+export type State = {|
+  isTouching: boolean,
+  lastMomentumScrollBeginTime: number,
+  lastMomentumScrollEndTime: number,
+  observedScrollSinceBecomingResponder: boolean,
+  becameResponderWhileAnimating: boolean,
+|};
+
+const ScrollResponderMixin = {
+  _subscriptionKeyboardWillShow: (null: ?EmitterSubscription),
+  _subscriptionKeyboardWillHide: (null: ?EmitterSubscription),
+  _subscriptionKeyboardDidShow: (null: ?EmitterSubscription),
+  _subscriptionKeyboardDidHide: (null: ?EmitterSubscription),
+  scrollResponderMixinGetInitialState: function(): State {
+    return {
+      isTouching: false,
+      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 !== 'always').
+      observedScrollSinceBecomingResponder: false,
+      becameResponderWhileAnimating: false,
+    };
+  },
+
+  /**
+   * Invoke this from an `onScroll` event.
+   */
+  scrollResponderHandleScrollShouldSetResponder: function(): boolean {
+    // Allow any event touch pass through if the default pan responder is disabled
+    if (this.props.disableScrollViewPanResponder === true) {
+      return false;
+    }
+    return this.state.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: function(
+    e: PressEvent,
+  ): boolean {
+    // Allow any event touch pass through if the default pan responder is disabled
+    if (this.props.disableScrollViewPanResponder === true) {
+      return false;
+    }
+
+    const currentlyFocusedInput = TextInputState.currentlyFocusedInput();
+
+    if (
+      this.props.keyboardShouldPersistTaps === 'handled' &&
+      currentlyFocusedInput != null &&
+      e.target !== currentlyFocusedInput
+    ) {
+      return true;
+    }
+    return false;
+  },
+
+  /**
+   * 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 a text input, while the keyboard is
+   *   up (which should dismiss the keyboard).
+   *
+   * Invoke this from an `onStartShouldSetResponderCapture` event.
+   */
+  scrollResponderHandleStartShouldSetResponderCapture: function(
+    e: PressEvent,
+  ): boolean {
+    // The scroll view should receive taps instead of its descendants if:
+    // * it is already animating/decelerating
+    if (this.scrollResponderIsAnimating()) {
+      return true;
+    }
+
+    // Allow any event touch pass through if the default pan responder is disabled
+    if (this.props.disableScrollViewPanResponder === true) {
+      return false;
+    }
+
+    // * the keyboard is up, keyboardShouldPersistTaps is 'never' (the default),
+    // and a new touch starts with a non-textinput target (in which case the
+    // first tap should be sent to the scroll view and dismiss the keyboard,
+    // then the second tap goes to the actual interior view)
+    const currentlyFocusedTextInput = TextInputState.currentlyFocusedInput();
+    const {keyboardShouldPersistTaps} = this.props;
+    const keyboardNeverPersistTaps =
+      !keyboardShouldPersistTaps || keyboardShouldPersistTaps === 'never';
+
+    if (typeof e.target === 'number') {
+      if (__DEV__) {
+        console.error(
+          'Did not expect event target to be a number. Should have been a native component',
+        );
+      }
+
+      return false;
+    }
+
+    if (
+      keyboardNeverPersistTaps &&
+      currentlyFocusedTextInput != null &&
+      e.target != null &&
+      !TextInputState.isTextInput(e.target)
+    ) {
+      return true;
+    }
+
+    return false;
+  },
+
+  /**
+   * 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: function() {},
+
+  /**
+   * 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: function(): boolean {
+    return !this.state.observedScrollSinceBecomingResponder;
+  },
+
+  /**
+   * Invoke this from an `onTouchEnd` event.
+   *
+   * @param {PressEvent} e Event.
+   */
+  scrollResponderHandleTouchEnd: function(e: PressEvent) {
+    const nativeEvent = e.nativeEvent;
+    this.state.isTouching = nativeEvent.touches.length !== 0;
+    this.props.onTouchEnd && this.props.onTouchEnd(e);
+  },
+
+  /**
+   * Invoke this from an `onTouchCancel` event.
+   *
+   * @param {PressEvent} e Event.
+   */
+  scrollResponderHandleTouchCancel: function(e: PressEvent) {
+    this.state.isTouching = false;
+    this.props.onTouchCancel && this.props.onTouchCancel(e);
+  },
+
+  /**
+   * Invoke this from an `onResponderRelease` event.
+   */
+  scrollResponderHandleResponderRelease: function(e: PressEvent) {
+    this.props.onResponderRelease && this.props.onResponderRelease(e);
+
+    if (typeof e.target === 'number') {
+      if (__DEV__) {
+        console.error(
+          'Did not expect event target to be a number. Should have been a native component',
+        );
+      }
+
+      return;
+    }
+
+    // By default scroll views will unfocus a textField
+    // if another touch occurs outside of it
+    const currentlyFocusedTextInput = TextInputState.currentlyFocusedInput();
+    if (
+      this.props.keyboardShouldPersistTaps !== true &&
+      this.props.keyboardShouldPersistTaps !== 'always' &&
+      currentlyFocusedTextInput != null &&
+      e.target !== currentlyFocusedTextInput &&
+      !this.state.observedScrollSinceBecomingResponder &&
+      !this.state.becameResponderWhileAnimating
+    ) {
+      this.props.onScrollResponderKeyboardDismissed &&
+        this.props.onScrollResponderKeyboardDismissed(e);
+      TextInputState.blurTextInput(currentlyFocusedTextInput);
+    }
+  },
+
+  scrollResponderHandleScroll: function(e: ScrollEvent) {
+    (this: any).state.observedScrollSinceBecomingResponder = true;
+    (this: any).props.onScroll && (this: any).props.onScroll(e);
+  },
+
+  /**
+   * Invoke this from an `onResponderGrant` event.
+   */
+  scrollResponderHandleResponderGrant: function(e: ScrollEvent) {
+    this.state.observedScrollSinceBecomingResponder = false;
+    this.props.onResponderGrant && this.props.onResponderGrant(e);
+    this.state.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: function(e: ScrollEvent) {
+    FrameRateLogger.beginScroll(); // TODO: track all scrolls after implementing onScrollEndAnimation
+    this.props.onScrollBeginDrag && this.props.onScrollBeginDrag(e);
+  },
+
+  /**
+   * Invoke this from an `onScrollEndDrag` event.
+   */
+  scrollResponderHandleScrollEndDrag: function(e: ScrollEvent) {
+    const {velocity} = e.nativeEvent;
+    // - If we are animating, then this is a "drag" that is stopping the scrollview and momentum end
+    //   will fire.
+    // - If velocity is non-zero, then the interaction will stop when momentum scroll ends or
+    //   another drag starts and ends.
+    // - If we don't get velocity, better to stop the interaction twice than not stop it.
+    if (
+      !this.scrollResponderIsAnimating() &&
+      (!velocity || (velocity.x === 0 && velocity.y === 0))
+    ) {
+      FrameRateLogger.endScroll();
+    }
+    this.props.onScrollEndDrag && this.props.onScrollEndDrag(e);
+  },
+
+  /**
+   * Invoke this from an `onMomentumScrollBegin` event.
+   */
+  scrollResponderHandleMomentumScrollBegin: function(e: ScrollEvent) {
+    this.state.lastMomentumScrollBeginTime = performanceNow();
+    this.props.onMomentumScrollBegin && this.props.onMomentumScrollBegin(e);
+  },
+
+  /**
+   * Invoke this from an `onMomentumScrollEnd` event.
+   */
+  scrollResponderHandleMomentumScrollEnd: function(e: ScrollEvent) {
+    FrameRateLogger.endScroll();
+    this.state.lastMomentumScrollEndTime = performanceNow();
+    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 {PressEvent} e Touch Start event.
+   */
+  scrollResponderHandleTouchStart: function(e: PressEvent) {
+    this.state.isTouching = true;
+    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 {PressEvent} e Touch Start event.
+   */
+  scrollResponderHandleTouchMove: function(e: PressEvent) {
+    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: function(): boolean {
+    const now = performanceNow();
+    const timeSinceLastMomentumScrollEnd =
+      now - this.state.lastMomentumScrollEndTime;
+    const isAnimating =
+      timeSinceLastMomentumScrollEnd < IS_ANIMATING_TOUCH_START_THRESHOLD_MS ||
+      this.state.lastMomentumScrollEndTime <
+        this.state.lastMomentumScrollBeginTime;
+    return isAnimating;
+  },
+
+  /**
+   * Returns the node that represents native view that can be scrolled.
+   * Components can pass what node to use by defining a `getScrollableNode`
+   * function otherwise `this` is used.
+   */
+  scrollResponderGetScrollableNode: function(): ?number {
+    return this.getScrollableNode
+      ? this.getScrollableNode()
+      : ReactNative.findNodeHandle(this);
+  },
+
+  /**
+   * A helper function to scroll to a specific point in the ScrollView.
+   * This is currently used to help focus 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: function(
+    x?:
+      | number
+      | {
+          x?: number,
+          y?: number,
+          animated?: boolean,
+          ...
+        },
+    y?: number,
+    animated?: boolean,
+  ) {
+    if (typeof x === 'number') {
+      console.warn(
+        '`scrollResponderScrollTo(x, y, animated)` is deprecated. Use `scrollResponderScrollTo({x: 5, y: 5, animated: true})` instead.',
+      );
+    } else {
+      ({x, y, animated} = x || {});
+    }
+
+    const that: React.ElementRef<ScrollView> = (this: any);
+    invariant(
+      that.getNativeScrollRef != null,
+      'Expected scrollTo to be called on a scrollViewRef. If this exception occurs it is likely a bug in React Native',
+    );
+    const nativeScrollRef = that.getNativeScrollRef();
+    if (nativeScrollRef == null) {
+      return;
+    }
+    Commands.scrollTo(nativeScrollRef, x || 0, y || 0, animated !== false);
+  },
+
+  /**
+   * Scrolls to the end of the ScrollView, either immediately or with a smooth
+   * animation.
+   *
+   * Example:
+   *
+   * `scrollResponderScrollToEnd({animated: true})`
+   */
+  scrollResponderScrollToEnd: function(options?: {animated?: boolean, ...}) {
+    // Default to true
+    const animated = (options && options.animated) !== false;
+
+    const that: React.ElementRef<ScrollView> = (this: any);
+    invariant(
+      that.getNativeScrollRef != null,
+      'Expected scrollToEnd to be called on a scrollViewRef. If this exception occurs it is likely a bug in React Native',
+    );
+    const nativeScrollRef = that.getNativeScrollRef();
+    if (nativeScrollRef == null) {
+      return;
+    }
+
+    Commands.scrollToEnd(nativeScrollRef, animated);
+  },
+
+  /**
+   * 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: function(
+    rect: {|
+      x: number,
+      y: number,
+      width: number,
+      height: number,
+      animated?: boolean,
+    |},
+    animated?: boolean, // deprecated, put this inside the rect argument instead
+  ) {
+    invariant(Platform.OS === 'ios', 'zoomToRect is not implemented');
+    if ('animated' in rect) {
+      animated = rect.animated;
+      delete rect.animated;
+    } else if (typeof animated !== 'undefined') {
+      console.warn(
+        '`scrollResponderZoomTo` `animated` argument is deprecated. Use `options.animated` instead',
+      );
+    }
+
+    const that: React.ElementRef<ScrollView> = this;
+    invariant(
+      that.getNativeScrollRef != null,
+      'Expected zoomToRect to be called on a scrollViewRef. If this exception occurs it is likely a bug in React Native',
+    );
+    const nativeScrollRef = that.getNativeScrollRef();
+    if (nativeScrollRef == null) {
+      return;
+    }
+    Commands.zoomToRect(nativeScrollRef, rect, animated !== false);
+  },
+
+  /**
+   * Displays the scroll indicators momentarily.
+   */
+  scrollResponderFlashScrollIndicators: function() {
+    const that: React.ElementRef<ScrollView> = (this: any);
+    invariant(
+      that.getNativeScrollRef != null,
+      'Expected flashScrollIndicators to be called on a scrollViewRef. If this exception occurs it is likely a bug in React Native',
+    );
+    const nativeScrollRef = that.getNativeScrollRef();
+    if (nativeScrollRef == null) {
+      return;
+    }
+    Commands.flashScrollIndicators(nativeScrollRef);
+  },
+
+  /**
+   * 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 {number} nodeHandle The TextInput node handle
+   * @param {number} additionalOffset The scroll view's bottom "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: function<T>(
+    nodeHandle: number | React.ElementRef<HostComponent<T>>,
+    additionalOffset?: number,
+    preventNegativeScrollOffset?: boolean,
+  ) {
+    this.additionalScrollOffset = additionalOffset || 0;
+    this.preventNegativeScrollOffset = !!preventNegativeScrollOffset;
+
+    if (typeof nodeHandle === 'number') {
+      UIManager.measureLayout(
+        nodeHandle,
+        ReactNative.findNodeHandle(this.getInnerViewNode()),
+        this.scrollResponderTextInputFocusError,
+        this.scrollResponderInputMeasureAndScrollToKeyboard,
+      );
+    } else {
+      const innerRef = this.getInnerViewRef();
+
+      if (innerRef == null) {
+        return;
+      }
+
+      nodeHandle.measureLayout(
+        innerRef,
+        this.scrollResponderInputMeasureAndScrollToKeyboard,
+        this.scrollResponderTextInputFocusError,
+      );
+    }
+  },
+
+  /**
+   * 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: function(
+    left: number,
+    top: number,
+    width: number,
+    height: number,
+  ) {
+    let keyboardScreenY = Dimensions.get('window').height;
+    if (this.keyboardWillOpenTo) {
+      keyboardScreenY = this.keyboardWillOpenTo.endCoordinates.screenY;
+    }
+    let scrollOffsetY =
+      top - keyboardScreenY + height + this.additionalScrollOffset;
+
+    // By default, this can scroll with negative offset, pulling the content
+    // down so that the target component's bottom meets the keyboard's top.
+    // If requested otherwise, cap the offset at 0 minimum to avoid content
+    // shifting down.
+    if (this.preventNegativeScrollOffset) {
+      scrollOffsetY = Math.max(0, scrollOffsetY);
+    }
+    this.scrollResponderScrollTo({x: 0, y: scrollOffsetY, animated: true});
+
+    this.additionalOffset = 0;
+    this.preventNegativeScrollOffset = false;
+  },
+
+  scrollResponderTextInputFocusError: function(msg: string) {
+    console.error('Error measuring text field: ', msg);
+  },
+
+  /**
+   * `componentWillMount` is the closest thing to a  standard "constructor" for
+   * React components.
+   *
+   * The `keyboardWillShow` is called before input focus.
+   */
+  UNSAFE_componentWillMount: function() {
+    const {keyboardShouldPersistTaps} = ((this: any).props: ScrollViewProps);
+    if (typeof keyboardShouldPersistTaps === 'boolean') {
+      console.warn(
+        `'keyboardShouldPersistTaps={${
+          keyboardShouldPersistTaps === true ? 'true' : 'false'
+        }}' is deprecated. ` +
+          `Use 'keyboardShouldPersistTaps="${
+            keyboardShouldPersistTaps ? 'always' : 'never'
+          }"' instead`,
+      );
+    }
+
+    (this: any).keyboardWillOpenTo = null;
+    (this: any).additionalScrollOffset = 0;
+    this._subscriptionKeyboardWillShow = Keyboard.addListener(
+      'keyboardWillShow',
+      this.scrollResponderKeyboardWillShow,
+    );
+
+    this._subscriptionKeyboardWillHide = Keyboard.addListener(
+      'keyboardWillHide',
+      this.scrollResponderKeyboardWillHide,
+    );
+    this._subscriptionKeyboardDidShow = Keyboard.addListener(
+      'keyboardDidShow',
+      this.scrollResponderKeyboardDidShow,
+    );
+    this._subscriptionKeyboardDidHide = Keyboard.addListener(
+      'keyboardDidHide',
+      this.scrollResponderKeyboardDidHide,
+    );
+  },
+
+  componentWillUnmount: function() {
+    if (this._subscriptionKeyboardWillShow != null) {
+      this._subscriptionKeyboardWillShow.remove();
+    }
+    if (this._subscriptionKeyboardWillHide != null) {
+      this._subscriptionKeyboardWillHide.remove();
+    }
+    if (this._subscriptionKeyboardDidShow != null) {
+      this._subscriptionKeyboardDidShow.remove();
+    }
+    if (this._subscriptionKeyboardDidHide != null) {
+      this._subscriptionKeyboardDidHide.remove();
+    }
+  },
+
+  /**
+   * 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` module 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: function(e: KeyboardEvent) {
+    this.keyboardWillOpenTo = e;
+    this.props.onKeyboardWillShow && this.props.onKeyboardWillShow(e);
+  },
+
+  scrollResponderKeyboardWillHide: function(e: KeyboardEvent) {
+    this.keyboardWillOpenTo = null;
+    this.props.onKeyboardWillHide && this.props.onKeyboardWillHide(e);
+  },
+
+  scrollResponderKeyboardDidShow: function(e: KeyboardEvent) {
+    // TODO(7693961): The event for DidShow is not available on iOS yet.
+    // Use the one from WillShow and do not assign.
+    if (e) {
+      this.keyboardWillOpenTo = e;
+    }
+    this.props.onKeyboardDidShow && this.props.onKeyboardDidShow(e);
+  },
+
+  scrollResponderKeyboardDidHide: function(e: KeyboardEvent) {
+    this.keyboardWillOpenTo = null;
+    this.props.onKeyboardDidHide && this.props.onKeyboardDidHide(e);
+  },
+};
+
+const ScrollResponder = {
+  Mixin: ScrollResponderMixin,
+};
+
+module.exports = ScrollResponder;

node_modules/react-native/Libraries/Components/ScrollView/AndroidHorizontalScrollContentViewNativeComponent.js

@@ -0,0 +1,40 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @flow
+ */
+
+'use strict';
+
+const registerGeneratedViewConfig = require('../../Utilities/registerGeneratedViewConfig');
+const requireNativeComponent = require('../../ReactNative/requireNativeComponent');
+
+import type {HostComponent} from '../../Renderer/shims/ReactNativeTypes';
+import type {ViewProps} from '../View/ViewPropTypes';
+
+const AndroidHorizontalScrollContentViewViewConfig = {
+  uiViewClassName: 'AndroidHorizontalScrollContentView',
+  bubblingEventTypes: {},
+  directEventTypes: {},
+  validAttributes: {},
+};
+
+let AndroidHorizontalScrollContentViewNativeComponent;
+if (global.RN$Bridgeless) {
+  registerGeneratedViewConfig(
+    'AndroidHorizontalScrollContentView',
+    AndroidHorizontalScrollContentViewViewConfig,
+  );
+  AndroidHorizontalScrollContentViewNativeComponent =
+    'AndroidHorizontalScrollContentView';
+} else {
+  AndroidHorizontalScrollContentViewNativeComponent = requireNativeComponent<ViewProps>(
+    'AndroidHorizontalScrollContentView',
+  );
+}
+
+export default ((AndroidHorizontalScrollContentViewNativeComponent: any): HostComponent<ViewProps>);

node_modules/react-native/Libraries/Components/ScrollView/AndroidHorizontalScrollViewNativeComponent.js

@@ -0,0 +1,57 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @flow
+ */
+
+'use strict';
+
+const registerGeneratedViewConfig = require('../../Utilities/registerGeneratedViewConfig');
+const requireNativeComponent = require('../../ReactNative/requireNativeComponent');
+
+import type {HostComponent} from '../../Renderer/shims/ReactNativeTypes';
+import type {ScrollViewNativeProps} from './ScrollViewNativeComponentType';
+
+const AndroidHorizontalScrollViewViewConfig = {
+  uiViewClassName: 'AndroidHorizontalScrollView',
+  bubblingEventTypes: {},
+  directEventTypes: {},
+  validAttributes: {
+    decelerationRate: true,
+    disableIntervalMomentum: true,
+    endFillColor: {process: require('../../StyleSheet/processColor')},
+    fadingEdgeLength: true,
+    nestedScrollEnabled: true,
+    overScrollMode: true,
+    pagingEnabled: true,
+    persistentScrollbar: true,
+    scrollEnabled: true,
+    scrollPerfTag: true,
+    sendMomentumEvents: true,
+    showsHorizontalScrollIndicator: true,
+    snapToEnd: true,
+    snapToInterval: true,
+    snapToStart: true,
+    snapToOffsets: true,
+    contentOffset: true,
+  },
+};
+
+let AndroidHorizontalScrollViewNativeComponent;
+if (global.RN$Bridgeless) {
+  registerGeneratedViewConfig(
+    'AndroidHorizontalScrollView',
+    AndroidHorizontalScrollViewViewConfig,
+  );
+  AndroidHorizontalScrollViewNativeComponent = 'AndroidHorizontalScrollView';
+} else {
+  AndroidHorizontalScrollViewNativeComponent = requireNativeComponent<ScrollViewNativeProps>(
+    'AndroidHorizontalScrollView',
+  );
+}
+
+export default ((AndroidHorizontalScrollViewNativeComponent: any): HostComponent<ScrollViewNativeProps>);

node_modules/react-native/Libraries/Components/ScrollView/ScrollContentViewNativeComponent.js

@@ -0,0 +1,39 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @flow
+ */
+
+'use strict';
+
+const registerGeneratedViewConfig = require('../../Utilities/registerGeneratedViewConfig');
+const requireNativeComponent = require('../../ReactNative/requireNativeComponent');
+
+import type {HostComponent} from '../../Renderer/shims/ReactNativeTypes';
+import type {ViewProps} from '../View/ViewPropTypes';
+
+const ScrollContentViewViewConfig = {
+  uiViewClassName: 'RCTScrollContentView',
+  bubblingEventTypes: {},
+  directEventTypes: {},
+  validAttributes: {},
+};
+
+let ScrollContentViewNativeComponent;
+if (global.RN$Bridgeless) {
+  registerGeneratedViewConfig(
+    'RCTScrollContentView',
+    ScrollContentViewViewConfig,
+  );
+  ScrollContentViewNativeComponent = 'RCTScrollContentView';
+} else {
+  ScrollContentViewNativeComponent = requireNativeComponent<ViewProps>(
+    'RCTScrollContentView',
+  );
+}
+
+export default ((ScrollContentViewNativeComponent: any): HostComponent<ViewProps>);

node_modules/react-native/Libraries/Components/ScrollView/ScrollViewCommands.js

@@ -0,0 +1,52 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @flow strict-local
+ */
+
+import codegenNativeCommands from '../../Utilities/codegenNativeCommands';
+import * as React from 'react';
+import type {Double} from 'react-native/Libraries/Types/CodegenTypes';
+
+import type {HostComponent} from '../../Renderer/shims/ReactNativeTypes';
+
+type ScrollViewNativeComponentType = HostComponent<mixed>;
+interface NativeCommands {
+  +flashScrollIndicators: (
+    viewRef: React.ElementRef<ScrollViewNativeComponentType>,
+  ) => void;
+  +scrollTo: (
+    viewRef: React.ElementRef<ScrollViewNativeComponentType>,
+    x: Double,
+    y: Double,
+    animated: boolean,
+  ) => void;
+  +scrollToEnd: (
+    viewRef: React.ElementRef<ScrollViewNativeComponentType>,
+    animated: boolean,
+  ) => void;
+  +zoomToRect: (
+    viewRef: React.ElementRef<ScrollViewNativeComponentType>,
+    rect: {|
+      x: Double,
+      y: Double,
+      width: Double,
+      height: Double,
+      animated?: boolean,
+    |},
+    animated?: boolean,
+  ) => void;
+}
+
+export default (codegenNativeCommands<NativeCommands>({
+  supportedCommands: [
+    'flashScrollIndicators',
+    'scrollTo',
+    'scrollToEnd',
+    'zoomToRect',
+  ],
+}): NativeCommands);

node_modules/react-native/Libraries/Components/ScrollView/ScrollViewNativeComponent.js

@@ -0,0 +1,32 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @flow
+ */
+
+'use strict';
+
+const registerGeneratedViewConfig = require('../../Utilities/registerGeneratedViewConfig');
+const requireNativeComponent = require('../../ReactNative/requireNativeComponent');
+import ScrollViewViewConfig from './ScrollViewViewConfig';
+
+import type {
+  ScrollViewNativeProps,
+  ScrollViewNativeComponentType,
+} from './ScrollViewNativeComponentType';
+
+let ScrollViewNativeComponent;
+if (global.RN$Bridgeless) {
+  registerGeneratedViewConfig('RCTScrollView', ScrollViewViewConfig);
+  ScrollViewNativeComponent = 'RCTScrollView';
+} else {
+  ScrollViewNativeComponent = requireNativeComponent<ScrollViewNativeProps>(
+    'RCTScrollView',
+  );
+}
+
+export default ((ScrollViewNativeComponent: any): ScrollViewNativeComponentType);

node_modules/react-native/Libraries/Components/ScrollView/ScrollViewNativeComponentType.js

@@ -0,0 +1,87 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @flow
+ */
+
+'use strict';
+
+import type {HostComponent} from '../../Renderer/shims/ReactNativeTypes';
+import type {ViewProps} from '../View/ViewPropTypes';
+import type {
+  ViewStyleProp,
+  DangerouslyImpreciseStyle,
+} from '../../StyleSheet/StyleSheet';
+import type {ColorValue} from '../../StyleSheet/StyleSheetTypes';
+import type {EdgeInsetsProp} from '../../StyleSheet/EdgeInsetsPropType';
+import type {ScrollEvent} from '../../Types/CoreEventTypes';
+import type {PointProp} from '../../StyleSheet/PointPropType';
+
+export type ScrollViewNativeProps = $ReadOnly<{
+  ...ViewProps,
+  alwaysBounceHorizontal?: ?boolean,
+  alwaysBounceVertical?: ?boolean,
+  automaticallyAdjustContentInsets?: ?boolean,
+  bounces?: ?boolean,
+  bouncesZoom?: ?boolean,
+  canCancelContentTouches?: ?boolean,
+  centerContent?: ?boolean,
+  contentInset?: ?EdgeInsetsProp,
+  contentInsetAdjustmentBehavior?: ?(
+    | 'automatic'
+    | 'scrollableAxes'
+    | 'never'
+    | 'always'
+  ),
+  contentOffset?: ?PointProp,
+  decelerationRate?: ?('fast' | 'normal' | number),
+  directionalLockEnabled?: ?boolean,
+  disableIntervalMomentum?: ?boolean,
+  endFillColor?: ?ColorValue,
+  fadingEdgeLength?: ?number,
+  indicatorStyle?: ?('default' | 'black' | 'white'),
+  keyboardDismissMode?: ?('none' | 'on-drag' | 'interactive'),
+  maintainVisibleContentPosition?: ?$ReadOnly<{|
+    minIndexForVisible: number,
+    autoscrollToTopThreshold?: ?number,
+  |}>,
+  maximumZoomScale?: ?number,
+  minimumZoomScale?: ?number,
+  nestedScrollEnabled?: ?boolean,
+  onMomentumScrollBegin?: ?(event: ScrollEvent) => void,
+  onMomentumScrollEnd?: ?(event: ScrollEvent) => void,
+  onScroll?: ?(event: ScrollEvent) => void,
+  onScrollBeginDrag?: ?(event: ScrollEvent) => void,
+  onScrollEndDrag?: ?(event: ScrollEvent) => void,
+  onScrollToTop?: (event: ScrollEvent) => void,
+  overScrollMode?: ?('auto' | 'always' | 'never'),
+  pagingEnabled?: ?boolean,
+  persistentScrollbar?: ?boolean,
+  pinchGestureEnabled?: ?boolean,
+  scrollEnabled?: ?boolean,
+  scrollEventThrottle?: ?number,
+  scrollIndicatorInsets?: ?EdgeInsetsProp,
+  scrollPerfTag?: ?string,
+  scrollToOverflowEnabled?: ?boolean,
+  scrollsToTop?: ?boolean,
+  sendMomentumEvents?: ?boolean,
+  showsHorizontalScrollIndicator?: ?boolean,
+  showsVerticalScrollIndicator?: ?boolean,
+  snapToAlignment?: ?('start' | 'center' | 'end'),
+  snapToEnd?: ?boolean,
+  snapToInterval?: ?number,
+  snapToOffsets?: ?$ReadOnlyArray<number>,
+  snapToStart?: ?boolean,
+  zoomScale?: ?number,
+  DEPRECATED_sendUpdatedChildFrames?: ?boolean,
+  // Overrides
+  style?: {...ViewStyleProp, ...} | DangerouslyImpreciseStyle,
+  onResponderGrant?: ?(e: any) => void | boolean,
+  ...
+}>;
+
+export type ScrollViewNativeComponentType = HostComponent<ScrollViewNativeProps>;

node_modules/react-native/Libraries/Components/ScrollView/ScrollViewStickyHeader.js

@@ -0,0 +1,166 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow
+ * @format
+ */
+
+'use strict';
+
+const AnimatedImplementation = require('../../Animated/src/AnimatedImplementation');
+const React = require('react');
+const StyleSheet = require('../../StyleSheet/StyleSheet');
+const View = require('../View/View');
+
+import type {LayoutEvent} from '../../Types/CoreEventTypes';
+
+const AnimatedView = AnimatedImplementation.createAnimatedComponent(View);
+
+export type Props = {
+  children?: React.Element<any>,
+  nextHeaderLayoutY: ?number,
+  onLayout: (event: LayoutEvent) => void,
+  scrollAnimatedValue: AnimatedImplementation.Value,
+  // Will cause sticky headers to stick at the bottom of the ScrollView instead
+  // of the top.
+  inverted: ?boolean,
+  // The height of the parent ScrollView. Currently only set when inverted.
+  scrollViewHeight: ?number,
+  ...
+};
+
+type State = {
+  measured: boolean,
+  layoutY: number,
+  layoutHeight: number,
+  nextHeaderLayoutY: ?number,
+  ...
+};
+
+class ScrollViewStickyHeader extends React.Component<Props, State> {
+  state: State = {
+    measured: false,
+    layoutY: 0,
+    layoutHeight: 0,
+    nextHeaderLayoutY: this.props.nextHeaderLayoutY,
+  };
+
+  setNextHeaderY(y: number) {
+    this.setState({nextHeaderLayoutY: y});
+  }
+
+  _onLayout = event => {
+    this.setState({
+      measured: true,
+      layoutY: event.nativeEvent.layout.y,
+      layoutHeight: event.nativeEvent.layout.height,
+    });
+
+    this.props.onLayout(event);
+    const child = React.Children.only(this.props.children);
+    if (child.props.onLayout) {
+      child.props.onLayout(event);
+    }
+  };
+
+  render(): React.Node {
+    const {inverted, scrollViewHeight} = this.props;
+    const {measured, layoutHeight, layoutY, nextHeaderLayoutY} = this.state;
+    const inputRange: Array<number> = [-1, 0];
+    const outputRange: Array<number> = [0, 0];
+
+    if (measured) {
+      if (inverted) {
+        // The interpolation looks like:
+        // - Negative scroll: no translation
+        // - `stickStartPoint` is the point at which the header will start sticking.
+        //   It is calculated using the ScrollView viewport height so it is a the bottom.
+        // - Headers that are in the initial viewport will never stick, `stickStartPoint`
+        //   will be negative.
+        // - From 0 to `stickStartPoint` no translation. This will cause the header
+        //   to scroll normally until it reaches the top of the scroll view.
+        // - From `stickStartPoint` to when the next header y hits the bottom edge of the header: translate
+        //   equally to scroll. This will cause the header to stay at the top of the scroll view.
+        // - Past the collision with the next header y: no more translation. This will cause the
+        //   header to continue scrolling up and make room for the next sticky header.
+        //   In the case that there is no next header just translate equally to
+        //   scroll indefinitely.
+        if (scrollViewHeight != null) {
+          const stickStartPoint = layoutY + layoutHeight - scrollViewHeight;
+          if (stickStartPoint > 0) {
+            inputRange.push(stickStartPoint);
+            outputRange.push(0);
+            inputRange.push(stickStartPoint + 1);
+            outputRange.push(1);
+            // If the next sticky header has not loaded yet (probably windowing) or is the last
+            // we can just keep it sticked forever.
+            const collisionPoint =
+              (nextHeaderLayoutY || 0) - layoutHeight - scrollViewHeight;
+            if (collisionPoint > stickStartPoint) {
+              inputRange.push(collisionPoint, collisionPoint + 1);
+              outputRange.push(
+                collisionPoint - stickStartPoint,
+                collisionPoint - stickStartPoint,
+              );
+            }
+          }
+        }
+      } else {
+        // The interpolation looks like:
+        // - Negative scroll: no translation
+        // - From 0 to the y of the header: no translation. This will cause the header
+        //   to scroll normally until it reaches the top of the scroll view.
+        // - From header y to when the next header y hits the bottom edge of the header: translate
+        //   equally to scroll. This will cause the header to stay at the top of the scroll view.
+        // - Past the collision with the next header y: no more translation. This will cause the
+        //   header to continue scrolling up and make room for the next sticky header.
+        //   In the case that there is no next header just translate equally to
+        //   scroll indefinitely.
+        inputRange.push(layoutY);
+        outputRange.push(0);
+        // If the next sticky header has not loaded yet (probably windowing) or is the last
+        // we can just keep it sticked forever.
+        const collisionPoint = (nextHeaderLayoutY || 0) - layoutHeight;
+        if (collisionPoint >= layoutY) {
+          inputRange.push(collisionPoint, collisionPoint + 1);
+          outputRange.push(collisionPoint - layoutY, collisionPoint - layoutY);
+        } else {
+          inputRange.push(layoutY + 1);
+          outputRange.push(1);
+        }
+      }
+    }
+
+    const translateY = this.props.scrollAnimatedValue.interpolate({
+      inputRange,
+      outputRange,
+    });
+    const child = React.Children.only(this.props.children);
+
+    return (
+      <AnimatedView
+        collapsable={false}
+        onLayout={this._onLayout}
+        style={[child.props.style, styles.header, {transform: [{translateY}]}]}>
+        {React.cloneElement(child, {
+          style: styles.fill, // We transfer the child style to the wrapper.
+          onLayout: undefined, // we call this manually through our this._onLayout
+        })}
+      </AnimatedView>
+    );
+  }
+}
+
+const styles = StyleSheet.create({
+  header: {
+    zIndex: 10,
+  },
+  fill: {
+    flex: 1,
+  },
+});
+
+module.exports = ScrollViewStickyHeader;

node_modules/react-native/Libraries/Components/ScrollView/ScrollViewViewConfig.js

@@ -0,0 +1,77 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+'use strict';
+
+import type {GeneratedViewConfig} from '../../Utilities/registerGeneratedViewConfig';
+
+const ScrollViewViewConfig = {
+  uiViewClassName: 'RCTScrollView',
+  bubblingEventTypes: {},
+  directEventTypes: {
+    topScrollToTop: {
+      registrationName: 'onScrollToTop',
+    },
+  },
+  validAttributes: {
+    alwaysBounceHorizontal: true,
+    alwaysBounceVertical: true,
+    automaticallyAdjustContentInsets: true,
+    bounces: true,
+    bouncesZoom: true,
+    canCancelContentTouches: true,
+    centerContent: true,
+    contentInset: {diff: require('../../Utilities/differ/pointsDiffer')},
+    contentOffset: {diff: require('../../Utilities/differ/pointsDiffer')},
+    contentInsetAdjustmentBehavior: true,
+    decelerationRate: true,
+    directionalLockEnabled: true,
+    disableIntervalMomentum: true,
+    endFillColor: {process: require('../../StyleSheet/processColor')},
+    fadingEdgeLength: true,
+    indicatorStyle: true,
+    keyboardDismissMode: true,
+    maintainVisibleContentPosition: true,
+    maximumZoomScale: true,
+    minimumZoomScale: true,
+    nestedScrollEnabled: true,
+    onMomentumScrollBegin: true,
+    onMomentumScrollEnd: true,
+    onScroll: true,
+    onScrollBeginDrag: true,
+    onScrollEndDrag: true,
+    onScrollToTop: true,
+    overScrollMode: true,
+    pagingEnabled: true,
+    persistentScrollbar: true,
+    pinchGestureEnabled: true,
+    scrollEnabled: true,
+    scrollEventThrottle: true,
+    scrollIndicatorInsets: {
+      diff: require('../../Utilities/differ/pointsDiffer'),
+    },
+    scrollPerfTag: true,
+    scrollToOverflowEnabled: true,
+    scrollsToTop: true,
+    sendMomentumEvents: true,
+    showsHorizontalScrollIndicator: true,
+    showsVerticalScrollIndicator: true,
+    snapToAlignment: true,
+    snapToEnd: true,
+    snapToInterval: true,
+    snapToOffsets: true,
+    snapToStart: true,
+    zoomScale: true,
+
+    DEPRECATED_sendUpdatedChildFrames: true,
+  },
+};
+
+module.exports = (ScrollViewViewConfig: GeneratedViewConfig);

node_modules/react-native/Libraries/Components/ScrollView/processDecelerationRate.js

@@ -0,0 +1,32 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @flow strict-local
+ */
+
+'use strict';
+
+const Platform = require('../../Utilities/Platform');
+
+function processDecelerationRate(
+  decelerationRate: number | 'normal' | 'fast',
+): number {
+  if (decelerationRate === 'normal') {
+    return Platform.select({
+      ios: 0.998,
+      android: 0.985,
+    });
+  } else if (decelerationRate === 'fast') {
+    return Platform.select({
+      ios: 0.99,
+      android: 0.9,
+    });
+  }
+  return decelerationRate;
+}
+
+module.exports = processDecelerationRate;

node_modules/react-native/Libraries/Components/SegmentedControlIOS/RCTSegmentedControlNativeComponent.js

@@ -0,0 +1,46 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+'use strict';
+
+import codegenNativeComponent from '../../Utilities/codegenNativeComponent';
+import type {HostComponent} from '../../Renderer/shims/ReactNativeTypes';
+import type {ViewProps} from '../View/ViewPropTypes';
+import type {
+  BubblingEventHandler,
+  WithDefault,
+  Int32,
+} from '../../Types/CodegenTypes';
+import type {ColorValue} from '../../StyleSheet/StyleSheetTypes';
+
+export type OnChangeEvent = $ReadOnly<{|
+  value: Int32,
+  selectedSegmentIndex: Int32,
+|}>;
+
+type NativeProps = $ReadOnly<{|
+  ...ViewProps,
+
+  // Props
+  values?: $ReadOnlyArray<string>,
+  selectedIndex?: WithDefault<Int32, 0>,
+  enabled?: WithDefault<boolean, true>,
+  tintColor?: ?ColorValue,
+  textColor?: ?ColorValue,
+  backgroundColor?: ?ColorValue,
+  momentary?: WithDefault<boolean, false>,
+
+  // Events
+  onChange?: ?BubblingEventHandler<OnChangeEvent>,
+|}>;
+
+export default (codegenNativeComponent<NativeProps>(
+  'RCTSegmentedControl',
+): HostComponent<NativeProps>);

node_modules/react-native/Libraries/Components/SegmentedControlIOS/SegmentedControlIOS.android.js

@@ -0,0 +1,46 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ */
+
+'use strict';
+
+const React = require('react');
+const StyleSheet = require('../../StyleSheet/StyleSheet');
+const Text = require('../../Text/Text');
+const View = require('../View/View');
+
+class DummySegmentedControlIOS extends React.Component {
+  render() {
+    return (
+      <View style={[styles.dummy, this.props.style]}>
+        <Text style={styles.text}>
+          SegmentedControlIOS is not supported on this platform!
+        </Text>
+      </View>
+    );
+  }
+}
+
+const styles = StyleSheet.create({
+  dummy: {
+    width: 120,
+    height: 50,
+    backgroundColor: '#ffbcbc',
+    borderWidth: 1,
+    borderColor: 'red',
+    alignItems: 'center',
+    justifyContent: 'center',
+  },
+  text: {
+    color: '#333333',
+    margin: 5,
+    fontSize: 10,
+  },
+});
+
+module.exports = DummySegmentedControlIOS;

node_modules/react-native/Libraries/Components/SegmentedControlIOS/SegmentedControlIOS.ios.js

@@ -0,0 +1,123 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @flow strict-local
+ */
+
+'use strict';
+
+import * as React from 'react';
+import StyleSheet from '../../StyleSheet/StyleSheet';
+import type {OnChangeEvent} from './RCTSegmentedControlNativeComponent';
+import type {ViewProps} from '../View/ViewPropTypes';
+import RCTSegmentedControlNativeComponent from './RCTSegmentedControlNativeComponent';
+import type {SyntheticEvent} from 'react-native/Libraries/Types/CoreEventTypes';
+
+type SegmentedControlIOSProps = $ReadOnly<{|
+  ...ViewProps,
+  /**
+   * The labels for the control's segment buttons, in order.
+   */
+  values?: $ReadOnlyArray<string>,
+  /**
+   * The index in `props.values` of the segment to be (pre)selected.
+   */
+  selectedIndex?: ?number,
+  /**
+   * If false the user won't be able to interact with the control.
+   */
+  enabled?: boolean,
+  /**
+   * Accent color of the control.
+   */
+  tintColor?: ?string,
+  /**
+   * If true, then selecting a segment won't persist visually.
+   * The `onValueChange` callback will still work as expected.
+   */
+  momentary?: ?boolean,
+  /**
+   * Callback that is called when the user taps a segment
+   */
+  onChange?: ?(event: SyntheticEvent<OnChangeEvent>) => void,
+  /**
+   * Callback that is called when the user taps a segment;
+   * passes the segment's value as an argument
+   */
+  onValueChange?: ?(value: number) => mixed,
+|}>;
+
+type Props = $ReadOnly<{|
+  ...SegmentedControlIOSProps,
+  forwardedRef: ?React.Ref<typeof RCTSegmentedControlNativeComponent>,
+|}>;
+
+/**
+ * Use `SegmentedControlIOS` to render a UISegmentedControl iOS.
+ *
+ * #### Programmatically changing selected index
+ *
+ * The selected index can be changed on the fly by assigning the
+ * selectedIndex prop to a state variable, then changing that variable.
+ * Note that the state variable would need to be updated as the user
+ * selects a value and changes the index, as shown in the example below.
+ *
+ * ````
+ * <SegmentedControlIOS
+ *   values={['One', 'Two']}
+ *   selectedIndex={this.state.selectedIndex}
+ *   onChange={(event) => {
+ *     this.setState({selectedIndex: event.nativeEvent.selectedSegmentIndex});
+ *   }}
+ * />
+ * ````
+ */
+
+class SegmentedControlIOS extends React.Component<Props> {
+  static defaultProps = {
+    values: [],
+    enabled: true,
+  };
+
+  _onChange = (event: SyntheticEvent<OnChangeEvent>) => {
+    this.props.onChange && this.props.onChange(event);
+    this.props.onValueChange &&
+      this.props.onValueChange(event.nativeEvent.value);
+  };
+
+  render() {
+    const {forwardedRef, onValueChange, style, ...props} = this.props;
+    return (
+      <RCTSegmentedControlNativeComponent
+        {...props}
+        ref={forwardedRef}
+        style={[styles.segmentedControl, style]}
+        onChange={this._onChange}
+      />
+    );
+  }
+}
+
+const styles = StyleSheet.create({
+  segmentedControl: {
+    height: 28,
+  },
+});
+
+const SegmentedControlIOSWithRef = React.forwardRef(
+  (
+    props: SegmentedControlIOSProps,
+    forwardedRef: ?React.Ref<typeof RCTSegmentedControlNativeComponent>,
+  ) => {
+    return <SegmentedControlIOS {...props} forwardedRef={forwardedRef} />;
+  },
+);
+
+/* $FlowFixMe(>=0.89.0 site=react_native_ios_fb) This comment suppresses an
+ * error found when Flow v0.89 was deployed. To see the error, delete this
+ * comment and run Flow. */
+module.exports = (SegmentedControlIOSWithRef: NativeSegmentedControlIOS);

node_modules/react-native/Libraries/Components/Slider/Slider.js

@@ -0,0 +1,276 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @flow strict-local
+ */
+
+'use strict';
+
+const Platform = require('../../Utilities/Platform');
+import SliderNativeComponent from './SliderNativeComponent';
+const React = require('react');
+const StyleSheet = require('../../StyleSheet/StyleSheet');
+
+import type {ImageSource} from '../../Image/ImageSource';
+import type {ViewStyleProp} from '../../StyleSheet/StyleSheet';
+import type {ColorValue} from '../../StyleSheet/StyleSheetTypes';
+import type {ViewProps} from '../View/ViewPropTypes';
+import type {SyntheticEvent} from '../../Types/CoreEventTypes';
+
+type Event = SyntheticEvent<
+  $ReadOnly<{|
+    value: number,
+    /**
+     * Android Only.
+     */
+    fromUser?: boolean,
+  |}>,
+>;
+
+type IOSProps = $ReadOnly<{|
+  /**
+   * Assigns a single image for the track. Only static images are supported.
+   * The center pixel of the image will be stretched to fill the track.
+   */
+  trackImage?: ?ImageSource,
+
+  /**
+   * Assigns a minimum track image. Only static images are supported. The
+   * rightmost pixel of the image will be stretched to fill the track.
+   */
+  minimumTrackImage?: ?ImageSource,
+
+  /**
+   * Assigns a maximum track image. Only static images are supported. The
+   * leftmost pixel of the image will be stretched to fill the track.
+   */
+  maximumTrackImage?: ?ImageSource,
+
+  /**
+   * Sets an image for the thumb. Only static images are supported.
+   */
+  thumbImage?: ?ImageSource,
+|}>;
+
+type Props = $ReadOnly<{|
+  ...ViewProps,
+  ...IOSProps,
+
+  /**
+   * Used to style and layout the `Slider`.  See `StyleSheet.js` and
+   * `DeprecatedViewStylePropTypes.js` for more info.
+   */
+  style?: ?ViewStyleProp,
+
+  /**
+   * Initial value of the slider. The value should be between minimumValue
+   * and maximumValue, which default to 0 and 1 respectively.
+   * Default value is 0.
+   *
+   * *This is not a controlled component*, you don't need to update the
+   * value during dragging.
+   */
+  value?: ?number,
+
+  /**
+   * Step value of the slider. The value should be
+   * between 0 and (maximumValue - minimumValue).
+   * Default value is 0.
+   */
+  step?: ?number,
+
+  /**
+   * Initial minimum value of the slider. Default value is 0.
+   */
+  minimumValue?: ?number,
+
+  /**
+   * Initial maximum value of the slider. Default value is 1.
+   */
+  maximumValue?: ?number,
+
+  /**
+   * The color used for the track to the left of the button.
+   * Overrides the default blue gradient image on iOS.
+   */
+  minimumTrackTintColor?: ?ColorValue,
+
+  /**
+   * The color used for the track to the right of the button.
+   * Overrides the default blue gradient image on iOS.
+   */
+  maximumTrackTintColor?: ?ColorValue,
+  /**
+   * The color used to tint the default thumb images on iOS, or the
+   * color of the foreground switch grip on Android.
+   */
+  thumbTintColor?: ?ColorValue,
+
+  /**
+   * If true the user won't be able to move the slider.
+   * Default value is false.
+   */
+  disabled?: ?boolean,
+
+  /**
+   * Callback continuously called while the user is dragging the slider.
+   */
+  onValueChange?: ?(value: number) => void,
+
+  /**
+   * Callback that is called when the user releases the slider,
+   * regardless if the value has changed. The current value is passed
+   * as an argument to the callback handler.
+   */
+  onSlidingComplete?: ?(value: number) => void,
+
+  /**
+   * Used to locate this view in UI automation tests.
+   */
+  testID?: ?string,
+|}>;
+
+/**
+ * A component used to select a single value from a range of values.
+ *
+ * ### Usage
+ *
+ * The example below shows how to use `Slider` to change
+ * a value used by `Text`. The value is stored using
+ * the state of the root component (`App`). The same component
+ * subscribes to the `onValueChange`  of `Slider` and changes
+ * the value using `setState`.
+ *
+ *```
+ * import React from 'react';
+ * import { StyleSheet, Text, View, Slider } from 'react-native';
+ *
+ * export default class App extends React.Component {
+ *   constructor(props) {
+ *     super(props);
+ *     this.state = {
+ *       value: 50
+ *     }
+ *   }
+ *
+ *   change(value) {
+ *     this.setState(() => {
+ *       return {
+ *         value: parseFloat(value)
+ *       };
+ *     });
+ *   }
+ *
+ *   render() {
+ *     const {value} = this.state;
+ *     return (
+ *       <View style={styles.container}>
+ *         <Text style={styles.text}>{String(value)}</Text>
+ *         <Slider
+ *           step={1}
+ *           maximumValue={100}
+ *           onValueChange={this.change.bind(this)}
+ *           value={value} />
+ *       </View>
+ *     );
+ *   }
+ * }
+ *
+ * const styles = StyleSheet.create({
+ *   container: {
+ *     flex: 1,
+ *     flexDirection: 'column',
+ *     justifyContent: 'center'
+ *   },
+ *   text: {
+ *     fontSize: 50,
+ *     textAlign: 'center'
+ *   }
+ * });
+ *```
+ *
+ */
+const Slider = (
+  props: Props,
+  forwardedRef?: ?React.Ref<typeof SliderNativeComponent>,
+) => {
+  const style = StyleSheet.compose(
+    styles.slider,
+    props.style,
+  );
+
+  const {
+    disabled = false,
+    value = 0.5,
+    minimumValue = 0,
+    maximumValue = 1,
+    step = 0,
+    onValueChange,
+    onSlidingComplete,
+    ...localProps
+  } = props;
+
+  const onValueChangeEvent = onValueChange
+    ? (event: Event) => {
+        let userEvent = true;
+        if (Platform.OS === 'android') {
+          // On Android there's a special flag telling us the user is
+          // dragging the slider.
+          userEvent =
+            event.nativeEvent.fromUser != null && event.nativeEvent.fromUser;
+        }
+        userEvent && onValueChange(event.nativeEvent.value);
+      }
+    : null;
+
+  const onChangeEvent = onValueChangeEvent;
+  const onSlidingCompleteEvent = onSlidingComplete
+    ? (event: Event) => {
+        onSlidingComplete(event.nativeEvent.value);
+      }
+    : null;
+
+  return (
+    <SliderNativeComponent
+      {...localProps}
+      // TODO: Reconcile these across the two platforms.
+      enabled={!disabled}
+      disabled={disabled}
+      maximumValue={maximumValue}
+      minimumValue={minimumValue}
+      onChange={onChangeEvent}
+      onResponderTerminationRequest={() => false}
+      onSlidingComplete={onSlidingCompleteEvent}
+      onStartShouldSetResponder={() => true}
+      onValueChange={onValueChangeEvent}
+      ref={forwardedRef}
+      step={step}
+      style={style}
+      value={value}
+    />
+  );
+};
+
+const SliderWithRef: React.AbstractComponent<
+  Props,
+  React.ElementRef<typeof SliderNativeComponent>,
+> = React.forwardRef(Slider);
+
+let styles;
+if (Platform.OS === 'ios') {
+  styles = StyleSheet.create({
+    slider: {
+      height: 40,
+    },
+  });
+} else {
+  styles = StyleSheet.create({
+    slider: {},
+  });
+}
+
+module.exports = SliderWithRef;

node_modules/react-native/Libraries/Components/Slider/SliderNativeComponent.js

@@ -0,0 +1,60 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @flow strict-local
+ */
+
+'use strict';
+
+import type {
+  BubblingEventHandler,
+  DirectEventHandler,
+  Double,
+  WithDefault,
+} from '../../Types/CodegenTypes';
+
+import codegenNativeComponent from '../../Utilities/codegenNativeComponent';
+import type {HostComponent} from '../../Renderer/shims/ReactNativeTypes';
+
+import type {ColorValue} from '../../StyleSheet/StyleSheetTypes';
+import type {ImageSource} from '../../Image/ImageSource';
+import type {ViewProps} from '../View/ViewPropTypes';
+
+type Event = $ReadOnly<{|
+  value: Double,
+  fromUser?: boolean,
+|}>;
+
+type NativeProps = $ReadOnly<{|
+  ...ViewProps,
+
+  // Props
+  disabled?: WithDefault<boolean, false>,
+  enabled?: WithDefault<boolean, true>,
+  maximumTrackImage?: ?ImageSource,
+  maximumTrackTintColor?: ?ColorValue,
+  maximumValue?: WithDefault<Double, 1>,
+  minimumTrackImage?: ?ImageSource,
+  minimumTrackTintColor?: ?ColorValue,
+  minimumValue?: WithDefault<Double, 0>,
+  step?: WithDefault<Double, 0>,
+  testID?: WithDefault<string, ''>,
+  thumbImage?: ?ImageSource,
+  thumbTintColor?: ?ColorValue,
+  trackImage?: ?ImageSource,
+  value?: WithDefault<Double, 0>,
+
+  // Events
+  onChange?: ?BubblingEventHandler<Event>,
+  onValueChange?: ?BubblingEventHandler<Event, 'paperValueChange'>,
+  onSlidingComplete?: ?DirectEventHandler<Event, 'paperSlidingComplete'>,
+|}>;
+
+export default (codegenNativeComponent<NativeProps>('Slider', {
+  interfaceOnly: true,
+  paperComponentName: 'RCTSlider',
+}): HostComponent<NativeProps>);

node_modules/react-native/Libraries/Components/Sound/NativeSoundManager.js

@@ -0,0 +1,23 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+'use strict';
+
+import type {TurboModule} from '../../TurboModule/RCTExport';
+import * as TurboModuleRegistry from '../../TurboModule/TurboModuleRegistry';
+
+/**
+ * Native Module used for playing sounds in native platform.
+ */
+export interface Spec extends TurboModule {
+  +playTouchSound: () => void;
+}
+
+export default (TurboModuleRegistry.get<Spec>('SoundManager'): ?Spec);

node_modules/react-native/Libraries/Components/Sound/SoundManager.js

@@ -0,0 +1,22 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @flow strict-local
+ */
+
+'use strict';
+import NativeSoundManager from './NativeSoundManager';
+
+const SoundManager = {
+  playTouchSound: function(): void {
+    if (NativeSoundManager) {
+      NativeSoundManager.playTouchSound();
+    }
+  },
+};
+
+module.exports = SoundManager;

node_modules/react-native/Libraries/Components/StaticContainer.react.js

@@ -0,0 +1,51 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @flow strict-local
+ */
+
+'use strict';
+
+const React = require('react');
+
+/**
+ * Renders static content efficiently by allowing React to short-circuit the
+ * reconciliation process. This component should be used when you know that a
+ * subtree of components will never need to be updated.
+ *
+ *   const someValue = ...; // We know for certain this value will never change.
+ *   return (
+ *     <StaticContainer>
+ *       <MyComponent value={someValue} />
+ *     </StaticContainer>
+ *   );
+ *
+ * Typically, you will not need to use this component and should opt for normal
+ * React reconciliation.
+ */
+
+type Props = $ReadOnly<{|
+  /**
+   * Whether or not this component should update.
+   */
+  shouldUpdate?: ?boolean,
+  /**
+   * Content short-circuited by React reconciliation process.
+   */
+  children: React.Node,
+|}>;
+class StaticContainer extends React.Component<Props> {
+  shouldComponentUpdate(nextProps: Props): boolean {
+    return !!nextProps.shouldUpdate;
+  }
+
+  render(): React.Node {
+    return this.props.children;
+  }
+}
+
+module.exports = StaticContainer;

node_modules/react-native/Libraries/Components/StaticRenderer.js

@@ -0,0 +1,37 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @flow strict-local
+ */
+
+'use strict';
+
+const React = require('react');
+
+type Props = $ReadOnly<{|
+  /**
+   * Indicates whether the render function needs to be called again
+   */
+  shouldUpdate: boolean,
+  /**
+   * () => renderable
+   * A function that returns a renderable component
+   */
+  render: () => React.Node,
+|}>;
+
+class StaticRenderer extends React.Component<Props> {
+  shouldComponentUpdate(nextProps: Props): boolean {
+    return nextProps.shouldUpdate;
+  }
+
+  render(): React.Node {
+    return this.props.render();
+  }
+}
+
+module.exports = StaticRenderer;

node_modules/react-native/Libraries/Components/StatusBar/NativeStatusBarManagerAndroid.js

@@ -0,0 +1,35 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+'use strict';
+
+import type {TurboModule} from '../../TurboModule/RCTExport';
+import * as TurboModuleRegistry from '../../TurboModule/TurboModuleRegistry';
+
+export interface Spec extends TurboModule {
+  +getConstants: () => {|
+    +HEIGHT: number,
+    +DEFAULT_BACKGROUND_COLOR: number,
+  |};
+  +setColor: (color: number, animated: boolean) => void;
+  +setTranslucent: (translucent: boolean) => void;
+
+  /**
+   *  - statusBarStyles can be:
+   *    - 'default'
+   *    - 'dark-content'
+   */
+  +setStyle: (statusBarStyle?: ?string) => void;
+  +setHidden: (hidden: boolean) => void;
+}
+
+export default (TurboModuleRegistry.getEnforcing<Spec>(
+  'StatusBarManager',
+): Spec);

node_modules/react-native/Libraries/Components/StatusBar/NativeStatusBarManagerIOS.js

@@ -0,0 +1,43 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+'use strict';
+
+import type {TurboModule} from '../../TurboModule/RCTExport';
+import * as TurboModuleRegistry from '../../TurboModule/TurboModuleRegistry';
+
+export interface Spec extends TurboModule {
+  +getConstants: () => {|
+    +HEIGHT: number,
+    +DEFAULT_BACKGROUND_COLOR?: number,
+  |};
+
+  // TODO(T47754272) Can we remove this method?
+  +getHeight: (callback: (result: {|height: number|}) => void) => void;
+  +setNetworkActivityIndicatorVisible: (visible: boolean) => void;
+  +addListener: (eventType: string) => void;
+  +removeListeners: (count: number) => void;
+
+  /**
+   *  - statusBarStyles can be:
+   *    - 'default'
+   *    - 'dark-content'
+   *    - 'light-content'
+   */
+  +setStyle: (statusBarStyle?: ?string, animated: boolean) => void;
+  /**
+   *  - withAnimation can be: 'none' | 'fade' | 'slide'
+   */
+  +setHidden: (hidden: boolean, withAnimation: string) => void;
+}
+
+export default (TurboModuleRegistry.getEnforcing<Spec>(
+  'StatusBarManager',
+): Spec);

node_modules/react-native/Libraries/Components/StatusBar/StatusBar.js

@@ -0,0 +1,501 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @flow
+ */
+
+'use strict';
+
+const Platform = require('../../Utilities/Platform');
+const React = require('react');
+
+const invariant = require('invariant');
+const processColor = require('../../StyleSheet/processColor');
+import type {ColorValue} from '../../StyleSheet/StyleSheetTypes';
+
+import NativeStatusBarManagerAndroid from './NativeStatusBarManagerAndroid';
+import NativeStatusBarManagerIOS from './NativeStatusBarManagerIOS';
+
+/**
+ * Status bar style
+ */
+export type StatusBarStyle = $Keys<{
+  /**
+   * Default status bar style (dark for iOS, light for Android)
+   */
+  default: string,
+  /**
+   * Dark background, white texts and icons
+   */
+  'light-content': string,
+  /**
+   * Light background, dark texts and icons
+   */
+  'dark-content': string,
+  ...
+}>;
+
+/**
+ * Status bar animation
+ */
+export type StatusBarAnimation = $Keys<{
+  /**
+   * No animation
+   */
+  none: string,
+  /**
+   * Fade animation
+   */
+  fade: string,
+  /**
+   * Slide animation
+   */
+  slide: string,
+  ...
+}>;
+
+type AndroidProps = $ReadOnly<{|
+  /**
+   * The background color of the status bar.
+   * @platform android
+   */
+  backgroundColor?: ?ColorValue,
+  /**
+   * If the status bar is translucent.
+   * When translucent is set to true, the app will draw under the status bar.
+   * This is useful when using a semi transparent status bar color.
+   *
+   * @platform android
+   */
+  translucent?: ?boolean,
+|}>;
+
+type IOSProps = $ReadOnly<{|
+  /**
+   * If the network activity indicator should be visible.
+   *
+   * @platform ios
+   */
+  networkActivityIndicatorVisible?: ?boolean,
+  /**
+   * The transition effect when showing and hiding the status bar using the `hidden`
+   * prop. Defaults to 'fade'.
+   *
+   * @platform ios
+   */
+  showHideTransition?: ?('fade' | 'slide'),
+|}>;
+
+type Props = $ReadOnly<{|
+  ...AndroidProps,
+  ...IOSProps,
+  /**
+   * If the status bar is hidden.
+   */
+  hidden?: ?boolean,
+  /**
+   * If the transition between status bar property changes should be animated.
+   * Supported for backgroundColor, barStyle and hidden.
+   */
+  animated?: ?boolean,
+  /**
+   * Sets the color of the status bar text.
+   */
+  barStyle?: ?('default' | 'light-content' | 'dark-content'),
+|}>;
+
+/**
+ * Merges the prop stack with the default values.
+ */
+function mergePropsStack(
+  propsStack: Array<Object>,
+  defaultValues: Object,
+): Object {
+  return propsStack.reduce((prev, cur) => {
+    for (const prop in cur) {
+      if (cur[prop] != null) {
+        prev[prop] = cur[prop];
+      }
+    }
+    return prev;
+  }, Object.assign({}, defaultValues));
+}
+
+/**
+ * Returns an object to insert in the props stack from the props
+ * and the transition/animation info.
+ */
+function createStackEntry(props: any): any {
+  return {
+    backgroundColor:
+      props.backgroundColor != null
+        ? {
+            value: props.backgroundColor,
+            animated: props.animated,
+          }
+        : null,
+    barStyle:
+      props.barStyle != null
+        ? {
+            value: props.barStyle,
+            animated: props.animated,
+          }
+        : null,
+    translucent: props.translucent,
+    hidden:
+      props.hidden != null
+        ? {
+            value: props.hidden,
+            animated: props.animated,
+            transition: props.showHideTransition,
+          }
+        : null,
+    networkActivityIndicatorVisible: props.networkActivityIndicatorVisible,
+  };
+}
+
+/**
+ * Component to control the app status bar.
+ *
+ * ### Usage with Navigator
+ *
+ * It is possible to have multiple `StatusBar` components mounted at the same
+ * time. The props will be merged in the order the `StatusBar` components were
+ * mounted. One use case is to specify status bar styles per route using `Navigator`.
+ *
+ * ```
+ *  <View>
+ *    <StatusBar
+ *      backgroundColor="blue"
+ *      barStyle="light-content"
+ *    />
+ *    <Navigator
+ *      initialRoute={{statusBarHidden: true}}
+ *      renderScene={(route, navigator) =>
+ *        <View>
+ *          <StatusBar hidden={route.statusBarHidden} />
+ *          ...
+ *        </View>
+ *      }
+ *    />
+ *  </View>
+ * ```
+ *
+ * ### Imperative API
+ *
+ * For cases where using a component is not ideal, there are static methods
+ * to manipulate the `StatusBar` display stack. These methods have the same
+ * behavior as mounting and unmounting a `StatusBar` component.
+ *
+ * For example, you can call `StatusBar.pushStackEntry` to update the status bar
+ * before launching a third-party native UI component, and then call
+ * `StatusBar.popStackEntry` when completed.
+ *
+ * ```
+ * const openThirdPartyBugReporter = async () => {
+ *   // The bug reporter has a dark background, so we push a new status bar style.
+ *   const stackEntry = StatusBar.pushStackEntry({barStyle: 'light-content'});
+ *
+ *   // `open` returns a promise that resolves when the UI is dismissed.
+ *   await BugReporter.open();
+ *
+ *   // Don't forget to call `popStackEntry` when you're done.
+ *   StatusBar.popStackEntry(stackEntry);
+ * };
+ * ```
+ *
+ * There is a legacy imperative API that enables you to manually update the
+ * status bar styles. However, the legacy API does not update the internal
+ * `StatusBar` display stack, which means that any changes will be overridden
+ * whenever a `StatusBar` component is mounted or unmounted.
+ *
+ * It is strongly advised that you use `pushStackEntry`, `popStackEntry`, or
+ * `replaceStackEntry` instead of the static methods beginning with `set`.
+ *
+ * ### Constants
+ *
+ * `currentHeight` (Android only) The height of the status bar.
+ */
+class StatusBar extends React.Component<Props> {
+  static _propsStack = [];
+
+  static _defaultProps = createStackEntry({
+    animated: false,
+    showHideTransition: 'fade',
+    backgroundColor:
+      Platform.OS === 'android'
+        ? NativeStatusBarManagerAndroid.getConstants()
+            .DEFAULT_BACKGROUND_COLOR ?? 'black'
+        : 'black',
+    barStyle: 'default',
+    translucent: false,
+    hidden: false,
+    networkActivityIndicatorVisible: false,
+  });
+
+  // Timer for updating the native module values at the end of the frame.
+  static _updateImmediate = null;
+
+  // The current merged values from the props stack.
+  static _currentValues = null;
+
+  // TODO(janic): Provide a real API to deal with status bar height. See the
+  // discussion in #6195.
+  /**
+   * The current height of the status bar on the device.
+   *
+   * @platform android
+   */
+  static currentHeight: ?number =
+    Platform.OS === 'android'
+      ? NativeStatusBarManagerAndroid.getConstants().HEIGHT
+      : null;
+
+  // Provide an imperative API as static functions of the component.
+  // See the corresponding prop for more detail.
+
+  /**
+   * Show or hide the status bar
+   * @param hidden Hide the status bar.
+   * @param animation Optional animation when
+   *    changing the status bar hidden property.
+   */
+  static setHidden(hidden: boolean, animation?: StatusBarAnimation) {
+    animation = animation || 'none';
+    StatusBar._defaultProps.hidden.value = hidden;
+    if (Platform.OS === 'ios') {
+      NativeStatusBarManagerIOS.setHidden(hidden, animation);
+    } else if (Platform.OS === 'android') {
+      NativeStatusBarManagerAndroid.setHidden(hidden);
+    }
+  }
+
+  /**
+   * Set the status bar style
+   * @param style Status bar style to set
+   * @param animated Animate the style change.
+   */
+  static setBarStyle(style: StatusBarStyle, animated?: boolean) {
+    animated = animated || false;
+    StatusBar._defaultProps.barStyle.value = style;
+    if (Platform.OS === 'ios') {
+      NativeStatusBarManagerIOS.setStyle(style, animated);
+    } else if (Platform.OS === 'android') {
+      NativeStatusBarManagerAndroid.setStyle(style);
+    }
+  }
+
+  /**
+   * Control the visibility of the network activity indicator
+   * @param visible Show the indicator.
+   */
+  static setNetworkActivityIndicatorVisible(visible: boolean) {
+    if (Platform.OS !== 'ios') {
+      console.warn(
+        '`setNetworkActivityIndicatorVisible` is only available on iOS',
+      );
+      return;
+    }
+    StatusBar._defaultProps.networkActivityIndicatorVisible = visible;
+    NativeStatusBarManagerIOS.setNetworkActivityIndicatorVisible(visible);
+  }
+
+  /**
+   * Set the background color for the status bar
+   * @param color Background color.
+   * @param animated Animate the style change.
+   */
+  static setBackgroundColor(color: string, animated?: boolean) {
+    if (Platform.OS !== 'android') {
+      console.warn('`setBackgroundColor` is only available on Android');
+      return;
+    }
+    animated = animated || false;
+    StatusBar._defaultProps.backgroundColor.value = color;
+
+    const processedColor = processColor(color);
+    if (processedColor == null) {
+      console.warn(
+        `\`StatusBar.setBackgroundColor\`: Color ${color} parsed to null or undefined`,
+      );
+      return;
+    }
+    invariant(
+      typeof processedColor === 'number',
+      'Unexpected color given for StatusBar.setBackgroundColor',
+    );
+
+    NativeStatusBarManagerAndroid.setColor(processedColor, animated);
+  }
+
+  /**
+   * Control the translucency of the status bar
+   * @param translucent Set as translucent.
+   */
+  static setTranslucent(translucent: boolean) {
+    if (Platform.OS !== 'android') {
+      console.warn('`setTranslucent` is only available on Android');
+      return;
+    }
+    StatusBar._defaultProps.translucent = translucent;
+    NativeStatusBarManagerAndroid.setTranslucent(translucent);
+  }
+
+  /**
+   * Push a StatusBar entry onto the stack.
+   * The return value should be passed to `popStackEntry` when complete.
+   *
+   * @param props Object containing the StatusBar props to use in the stack entry.
+   */
+  static pushStackEntry(props: any): any {
+    const entry = createStackEntry(props);
+    StatusBar._propsStack.push(entry);
+    StatusBar._updatePropsStack();
+    return entry;
+  }
+
+  /**
+   * Pop a StatusBar entry from the stack.
+   *
+   * @param entry Entry returned from `pushStackEntry`.
+   */
+  static popStackEntry(entry: any) {
+    const index = StatusBar._propsStack.indexOf(entry);
+    if (index !== -1) {
+      StatusBar._propsStack.splice(index, 1);
+    }
+    StatusBar._updatePropsStack();
+  }
+
+  /**
+   * Replace an existing StatusBar stack entry with new props.
+   *
+   * @param entry Entry returned from `pushStackEntry` to replace.
+   * @param props Object containing the StatusBar props to use in the replacement stack entry.
+   */
+  static replaceStackEntry(entry: any, props: any): any {
+    const newEntry = createStackEntry(props);
+    const index = StatusBar._propsStack.indexOf(entry);
+    if (index !== -1) {
+      StatusBar._propsStack[index] = newEntry;
+    }
+    StatusBar._updatePropsStack();
+    return newEntry;
+  }
+
+  static defaultProps: {|
+    animated: boolean,
+    showHideTransition: $TEMPORARY$string<'fade'>,
+  |} = {
+    animated: false,
+    showHideTransition: 'fade',
+  };
+
+  _stackEntry = null;
+
+  componentDidMount() {
+    // Every time a StatusBar component is mounted, we push it's prop to a stack
+    // and always update the native status bar with the props from the top of then
+    // stack. This allows having multiple StatusBar components and the one that is
+    // added last or is deeper in the view hierarchy will have priority.
+    this._stackEntry = StatusBar.pushStackEntry(this.props);
+  }
+
+  componentWillUnmount() {
+    // When a StatusBar is unmounted, remove itself from the stack and update
+    // the native bar with the next props.
+    StatusBar.popStackEntry(this._stackEntry);
+  }
+
+  componentDidUpdate() {
+    this._stackEntry = StatusBar.replaceStackEntry(
+      this._stackEntry,
+      this.props,
+    );
+  }
+
+  /**
+   * Updates the native status bar with the props from the stack.
+   */
+  static _updatePropsStack = () => {
+    // Send the update to the native module only once at the end of the frame.
+    clearImmediate(StatusBar._updateImmediate);
+    StatusBar._updateImmediate = setImmediate(() => {
+      const oldProps = StatusBar._currentValues;
+      const mergedProps = mergePropsStack(
+        StatusBar._propsStack,
+        StatusBar._defaultProps,
+      );
+
+      // Update the props that have changed using the merged values from the props stack.
+      if (Platform.OS === 'ios') {
+        if (
+          !oldProps ||
+          oldProps.barStyle.value !== mergedProps.barStyle.value
+        ) {
+          NativeStatusBarManagerIOS.setStyle(
+            mergedProps.barStyle.value,
+            mergedProps.barStyle.animated || false,
+          );
+        }
+        if (!oldProps || oldProps.hidden.value !== mergedProps.hidden.value) {
+          NativeStatusBarManagerIOS.setHidden(
+            mergedProps.hidden.value,
+            mergedProps.hidden.animated
+              ? mergedProps.hidden.transition
+              : 'none',
+          );
+        }
+
+        if (
+          !oldProps ||
+          oldProps.networkActivityIndicatorVisible !==
+            mergedProps.networkActivityIndicatorVisible
+        ) {
+          NativeStatusBarManagerIOS.setNetworkActivityIndicatorVisible(
+            mergedProps.networkActivityIndicatorVisible,
+          );
+        }
+      } else if (Platform.OS === 'android') {
+        //todo(T60684787): Add back optimization to only update bar style and
+        //background color if the new value is different from the old value.
+        NativeStatusBarManagerAndroid.setStyle(mergedProps.barStyle.value);
+        const processedColor = processColor(mergedProps.backgroundColor.value);
+        if (processedColor == null) {
+          console.warn(
+            `\`StatusBar._updatePropsStack\`: Color ${
+              mergedProps.backgroundColor.value
+            } parsed to null or undefined`,
+          );
+        } else {
+          invariant(
+            typeof processedColor === 'number',
+            'Unexpected color given in StatusBar._updatePropsStack',
+          );
+          NativeStatusBarManagerAndroid.setColor(
+            processedColor,
+            mergedProps.backgroundColor.animated,
+          );
+        }
+        if (!oldProps || oldProps.hidden.value !== mergedProps.hidden.value) {
+          NativeStatusBarManagerAndroid.setHidden(mergedProps.hidden.value);
+        }
+        if (!oldProps || oldProps.translucent !== mergedProps.translucent) {
+          NativeStatusBarManagerAndroid.setTranslucent(mergedProps.translucent);
+        }
+      }
+      // Update the current prop values.
+      StatusBar._currentValues = mergedProps;
+    });
+  };
+
+  render(): React.Node {
+    return null;
+  }
+}
+
+module.exports = StatusBar;

node_modules/react-native/Libraries/Components/StatusBar/StatusBarIOS.js

@@ -0,0 +1,22 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @flow strict-local
+ */
+
+'use strict';
+
+const NativeEventEmitter = require('../../EventEmitter/NativeEventEmitter');
+
+import NativeStatusBarManagerIOS from './NativeStatusBarManagerIOS';
+
+/**
+ * Use `StatusBar` for mutating the status bar.
+ */
+class StatusBarIOS extends NativeEventEmitter {}
+
+module.exports = (new StatusBarIOS(NativeStatusBarManagerIOS): StatusBarIOS);

node_modules/react-native/Libraries/Components/Switch/AndroidSwitchNativeComponent.js

@@ -0,0 +1,64 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+'use strict';
+
+import * as React from 'react';
+
+import type {
+  WithDefault,
+  BubblingEventHandler,
+} from 'react-native/Libraries/Types/CodegenTypes';
+
+import codegenNativeCommands from 'react-native/Libraries/Utilities/codegenNativeCommands';
+import codegenNativeComponent from 'react-native/Libraries/Utilities/codegenNativeComponent';
+import type {HostComponent} from 'react-native/Libraries/Renderer/shims/ReactNativeTypes';
+
+import type {ColorValue} from '../../StyleSheet/StyleSheetTypes';
+import type {ViewProps} from '../View/ViewPropTypes';
+
+type SwitchChangeEvent = $ReadOnly<{|
+  value: boolean,
+|}>;
+
+type NativeProps = $ReadOnly<{|
+  ...ViewProps,
+
+  // Props
+  disabled?: WithDefault<boolean, false>,
+  enabled?: WithDefault<boolean, true>,
+  thumbColor?: ?ColorValue,
+  trackColorForFalse?: ?ColorValue,
+  trackColorForTrue?: ?ColorValue,
+  value?: WithDefault<boolean, false>,
+  on?: WithDefault<boolean, false>,
+  thumbTintColor?: ?ColorValue,
+  trackTintColor?: ?ColorValue,
+
+  // Events
+  onChange?: BubblingEventHandler<SwitchChangeEvent>,
+|}>;
+
+type NativeType = HostComponent<NativeProps>;
+
+interface NativeCommands {
+  +setNativeValue: (
+    viewRef: React.ElementRef<NativeType>,
+    value: boolean,
+  ) => void;
+}
+
+export const Commands: NativeCommands = codegenNativeCommands<NativeCommands>({
+  supportedCommands: ['setNativeValue'],
+});
+
+export default (codegenNativeComponent<NativeProps>('AndroidSwitch', {
+  interfaceOnly: true,
+}): NativeType);

node_modules/react-native/Libraries/Components/Switch/Switch.js

@@ -0,0 +1,228 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ * @generate-docs
+ */
+
+'use strict';
+
+import Platform from '../../Utilities/Platform';
+import * as React from 'react';
+import StyleSheet from '../../StyleSheet/StyleSheet';
+
+import AndroidSwitchNativeComponent, {
+  Commands as AndroidSwitchCommands,
+} from './AndroidSwitchNativeComponent';
+import SwitchNativeComponent, {
+  Commands as SwitchCommands,
+} from './SwitchNativeComponent';
+
+import type {ColorValue} from '../../StyleSheet/StyleSheetTypes';
+import type {SyntheticEvent} from '../../Types/CoreEventTypes';
+import type {ViewProps} from '../View/ViewPropTypes';
+
+type SwitchChangeEvent = SyntheticEvent<
+  $ReadOnly<{|
+    value: boolean,
+  |}>,
+>;
+
+export type Props = $ReadOnly<{|
+  ...ViewProps,
+
+  /**
+   * Whether the switch is disabled. Defaults to false.
+   */
+  disabled?: ?boolean,
+
+  /**
+   * Boolean value of the switch. Defaults to false.
+   */
+  value?: ?boolean,
+
+  /**
+   * Custom color for the switch thumb.
+   */
+  thumbColor?: ?ColorValue,
+
+  /**
+   * Custom colors for the switch track.
+   *
+   * NOTE: On iOS when the switch value is false, the track shrinks into the
+   * border. If you want to change the color of the background exposed by the
+   * shrunken track, use `ios_backgroundColor`.
+   */
+  trackColor?: ?$ReadOnly<{|
+    false?: ?ColorValue,
+    true?: ?ColorValue,
+  |}>,
+
+  /**
+   * On iOS, custom color for the background. This background color can be seen
+   * either when the switch value is false or when the switch is disabled (and
+   * the switch is translucent).
+   */
+  ios_backgroundColor?: ?ColorValue,
+
+  /**
+   * Called when the user tries to change the value of the switch.
+   *
+   * Receives the change event as an argument. If you want to only receive the
+   * new value, use `onValueChange` instead.
+   */
+  onChange?: ?(event: SwitchChangeEvent) => Promise<void> | void,
+
+  /**
+   * Called when the user tries to change the value of the switch.
+   *
+   * Receives the new value as an argument. If you want to instead receive an
+   * event, use `onChange`.
+   */
+  onValueChange?: ?(value: boolean) => Promise<void> | void,
+|}>;
+
+/**
+ * A visual toggle between two mutually exclusive states.
+ *
+ * This is a controlled component that requires an `onValueChange` callback that
+ * updates the `value` prop in order for the component to reflect user actions.
+ * If the `value` prop is not updated, the component will continue to render the
+ * supplied `value` prop instead of the expected result of any user actions.
+ */
+class Switch extends React.Component<Props> {
+  _nativeSwitchRef: ?React.ElementRef<
+    typeof SwitchNativeComponent | typeof AndroidSwitchNativeComponent,
+  >;
+  _lastNativeValue: ?boolean;
+
+  render(): React.Node {
+    const {
+      disabled,
+      ios_backgroundColor,
+      onChange,
+      onValueChange,
+      style,
+      thumbColor,
+      trackColor,
+      value,
+      ...props
+    } = this.props;
+
+    const trackColorForFalse = trackColor?.false;
+    const trackColorForTrue = trackColor?.true;
+
+    if (Platform.OS === 'android') {
+      const platformProps = {
+        enabled: disabled !== true,
+        on: value === true,
+        style,
+        thumbTintColor: thumbColor,
+        trackColorForFalse: trackColorForFalse,
+        trackColorForTrue: trackColorForTrue,
+        trackTintColor: value === true ? trackColorForTrue : trackColorForFalse,
+      };
+
+      return (
+        <AndroidSwitchNativeComponent
+          {...props}
+          {...platformProps}
+          accessibilityRole={props.accessibilityRole ?? 'switch'}
+          onChange={this._handleChange}
+          onResponderTerminationRequest={returnsFalse}
+          onStartShouldSetResponder={returnsTrue}
+          ref={this._handleSwitchNativeComponentRef}
+        />
+      );
+    }
+
+    const platformProps = {
+      disabled,
+      onTintColor: trackColorForTrue,
+      style: StyleSheet.compose(
+        {height: 31, width: 51},
+        StyleSheet.compose(
+          style,
+          ios_backgroundColor == null
+            ? null
+            : {
+                backgroundColor: ios_backgroundColor,
+                borderRadius: 16,
+              },
+        ),
+      ),
+      thumbTintColor: thumbColor,
+      tintColor: trackColorForFalse,
+      value: value === true,
+    };
+
+    return (
+      <SwitchNativeComponent
+        {...props}
+        {...platformProps}
+        accessibilityRole={props.accessibilityRole ?? 'switch'}
+        onChange={this._handleChange}
+        onResponderTerminationRequest={returnsFalse}
+        onStartShouldSetResponder={returnsTrue}
+        ref={this._handleSwitchNativeComponentRef}
+      />
+    );
+  }
+
+  componentDidUpdate() {
+    // This is necessary in case native updates the switch and JS decides
+    // that the update should be ignored and we should stick with the value
+    // that we have in JS.
+    const nativeProps = {};
+    const value = this.props.value === true;
+
+    if (this._lastNativeValue !== value) {
+      nativeProps.value = value;
+    }
+
+    if (
+      Object.keys(nativeProps).length > 0 &&
+      this._nativeSwitchRef &&
+      this._nativeSwitchRef.setNativeProps
+    ) {
+      if (Platform.OS === 'android') {
+        AndroidSwitchCommands.setNativeValue(
+          this._nativeSwitchRef,
+          nativeProps.value,
+        );
+      } else {
+        SwitchCommands.setValue(this._nativeSwitchRef, nativeProps.value);
+      }
+    }
+  }
+
+  _handleChange = (event: SwitchChangeEvent) => {
+    if (this.props.onChange != null) {
+      this.props.onChange(event);
+    }
+
+    if (this.props.onValueChange != null) {
+      this.props.onValueChange(event.nativeEvent.value);
+    }
+
+    this._lastNativeValue = event.nativeEvent.value;
+    this.forceUpdate();
+  };
+
+  _handleSwitchNativeComponentRef = (
+    ref: ?React.ElementRef<
+      typeof SwitchNativeComponent | typeof AndroidSwitchNativeComponent,
+    >,
+  ) => {
+    this._nativeSwitchRef = ref;
+  };
+}
+
+const returnsFalse = () => false;
+const returnsTrue = () => true;
+
+module.exports = Switch;

node_modules/react-native/Libraries/Components/Switch/SwitchNativeComponent.js

@@ -0,0 +1,58 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+'use strict';
+
+import type {BubblingEventHandler, WithDefault} from '../../Types/CodegenTypes';
+import type {ColorValue} from '../../StyleSheet/StyleSheetTypes';
+import type {ViewProps} from '../View/ViewPropTypes';
+import * as React from 'react';
+
+import codegenNativeComponent from '../../Utilities/codegenNativeComponent';
+import codegenNativeCommands from 'react-native/Libraries/Utilities/codegenNativeCommands';
+import type {HostComponent} from '../../Renderer/shims/ReactNativeTypes';
+
+type SwitchChangeEvent = $ReadOnly<{|
+  value: boolean,
+|}>;
+
+type NativeProps = $ReadOnly<{|
+  ...ViewProps,
+
+  // Props
+  disabled?: WithDefault<boolean, false>,
+  value?: WithDefault<boolean, false>,
+  tintColor?: ?ColorValue,
+  onTintColor?: ?ColorValue,
+  thumbTintColor?: ?ColorValue,
+
+  // Deprecated props
+  thumbColor?: ?ColorValue,
+  trackColorForFalse?: ?ColorValue,
+  trackColorForTrue?: ?ColorValue,
+
+  // Events
+  onChange?: ?BubblingEventHandler<SwitchChangeEvent>,
+|}>;
+
+type ComponentType = HostComponent<NativeProps>;
+
+interface NativeCommands {
+  +setValue: (viewRef: React.ElementRef<ComponentType>, value: boolean) => void;
+}
+
+export const Commands: NativeCommands = codegenNativeCommands<NativeCommands>({
+  supportedCommands: ['setValue'],
+});
+
+export default (codegenNativeComponent<NativeProps>('Switch', {
+  paperComponentName: 'RCTSwitch',
+  excludedPlatform: 'android',
+}): ComponentType);

node_modules/react-native/Libraries/Components/TextInput/AndroidTextInputNativeComponent.js

@@ -0,0 +1,563 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+'use strict';
+
+import type {ViewProps} from '../View/ViewPropTypes';
+import type {
+  BubblingEventHandler,
+  DirectEventHandler,
+  Double,
+  Float,
+  Int32,
+  WithDefault,
+} from '../../Types/CodegenTypes';
+import type {HostComponent} from '../../Renderer/shims/ReactNativeTypes';
+import type {TextStyleProp, ViewStyleProp} from '../../StyleSheet/StyleSheet';
+import type {ColorValue} from '../../StyleSheet/StyleSheetTypes';
+import requireNativeComponent from '../../ReactNative/requireNativeComponent';
+import codegenNativeCommands from '../../Utilities/codegenNativeCommands';
+import type {TextInputNativeCommands} from './TextInputNativeCommands';
+import * as React from 'react';
+import AndroidTextInputViewConfig from './AndroidTextInputViewConfig';
+const ReactNativeViewConfigRegistry = require('../../Renderer/shims/ReactNativeViewConfigRegistry');
+
+export type KeyboardType =
+  // Cross Platform
+  | 'default'
+  | 'email-address'
+  | 'numeric'
+  | 'phone-pad'
+  | 'number-pad'
+  | 'decimal-pad'
+  // iOS-only
+  | 'ascii-capable'
+  | 'numbers-and-punctuation'
+  | 'url'
+  | 'name-phone-pad'
+  | 'twitter'
+  | 'web-search'
+  // Android-only
+  | 'visible-password';
+
+export type ReturnKeyType =
+  // Cross Platform
+  | 'done'
+  | 'go'
+  | 'next'
+  | 'search'
+  | 'send'
+  // Android-only
+  | 'none'
+  | 'previous'
+  // iOS-only
+  | 'default'
+  | 'emergency-call'
+  | 'google'
+  | 'join'
+  | 'route'
+  | 'yahoo';
+
+export type NativeProps = $ReadOnly<{|
+  // This allows us to inherit everything from ViewProps except for style (see below)
+  // This must be commented for Fabric codegen to work.
+  ...$Diff<ViewProps, $ReadOnly<{|style: ?ViewStyleProp|}>>,
+
+  /**
+   * Android props after this
+   */
+  /**
+   * Determines which content to suggest on auto complete, e.g.`username`.
+   * To disable auto complete, use `off`.
+   *
+   * *Android Only*
+   *
+   * The following values work on Android only:
+   *
+   * - `username`
+   * - `password`
+   * - `email`
+   * - `name`
+   * - `tel`
+   * - `street-address`
+   * - `postal-code`
+   * - `cc-number`
+   * - `cc-csc`
+   * - `cc-exp`
+   * - `cc-exp-month`
+   * - `cc-exp-year`
+   * - `off`
+   *
+   * @platform android
+   */
+  autoCompleteType?: WithDefault<
+    | 'cc-csc'
+    | 'cc-exp'
+    | 'cc-exp-month'
+    | 'cc-exp-year'
+    | 'cc-number'
+    | 'email'
+    | 'name'
+    | 'password'
+    | 'postal-code'
+    | 'street-address'
+    | 'tel'
+    | 'username'
+    | 'off',
+    'off',
+  >,
+
+  /**
+   * Sets the return key to the label. Use it instead of `returnKeyType`.
+   * @platform android
+   */
+  returnKeyLabel?: ?string,
+
+  /**
+   * Sets the number of lines for a `TextInput`. Use it with multiline set to
+   * `true` to be able to fill the lines.
+   * @platform android
+   */
+  numberOfLines?: ?Int32,
+
+  /**
+   * When `false`, if there is a small amount of space available around a text input
+   * (e.g. landscape orientation on a phone), the OS may choose to have the user edit
+   * the text inside of a full screen text input mode. When `true`, this feature is
+   * disabled and users will always edit the text directly inside of the text input.
+   * Defaults to `false`.
+   * @platform android
+   */
+  disableFullscreenUI?: ?boolean,
+
+  /**
+   * Set text break strategy on Android API Level 23+, possible values are `simple`, `highQuality`, `balanced`
+   * The default value is `simple`.
+   * @platform android
+   */
+  textBreakStrategy?: WithDefault<
+    'simple' | 'highQuality' | 'balanced',
+    'simple',
+  >,
+
+  /**
+   * The color of the `TextInput` underline.
+   * @platform android
+   */
+  underlineColorAndroid?: ?ColorValue,
+
+  /**
+   * If defined, the provided image resource will be rendered on the left.
+   * The image resource must be inside `/android/app/src/main/res/drawable` and referenced
+   * like
+   * ```
+   * <TextInput
+   *  inlineImageLeft='search_icon'
+   * />
+   * ```
+   * @platform android
+   */
+  inlineImageLeft?: ?string,
+
+  /**
+   * Padding between the inline image, if any, and the text input itself.
+   * @platform android
+   */
+  inlineImagePadding?: ?Int32,
+
+  importantForAutofill?: string /*?(
+    | 'auto'
+    | 'no'
+    | 'noExcludeDescendants'
+    | 'yes'
+    | 'yesExcludeDescendants'
+  ),*/,
+
+  /**
+   * When `false`, it will prevent the soft keyboard from showing when the field is focused.
+   * Defaults to `true`.
+   * @platform android
+   */
+  showSoftInputOnFocus?: ?boolean,
+
+  /**
+   * TextInput props after this
+   */
+  /**
+   * Can tell `TextInput` to automatically capitalize certain characters.
+   *
+   * - `characters`: all characters.
+   * - `words`: first letter of each word.
+   * - `sentences`: first letter of each sentence (*default*).
+   * - `none`: don't auto capitalize anything.
+   */
+  autoCapitalize?: WithDefault<
+    'none' | 'sentences' | 'words' | 'characters',
+    'none',
+  >,
+
+  /**
+   * If `false`, disables auto-correct. The default value is `true`.
+   */
+  autoCorrect?: ?boolean,
+
+  /**
+   * If `true`, focuses the input on `componentDidMount`.
+   * The default value is `false`.
+   */
+  autoFocus?: ?boolean,
+
+  /**
+   * Specifies whether fonts should scale to respect Text Size accessibility settings. The
+   * default is `true`.
+   */
+  allowFontScaling?: ?boolean,
+
+  /**
+   * Specifies largest possible scale a font can reach when `allowFontScaling` is enabled.
+   * Possible values:
+   * `null/undefined` (default): inherit from the parent node or the global default (0)
+   * `0`: no max, ignore parent/global default
+   * `>= 1`: sets the maxFontSizeMultiplier of this node to this value
+   */
+  maxFontSizeMultiplier?: ?Float,
+
+  /**
+   * If `false`, text is not editable. The default value is `true`.
+   */
+  editable?: ?boolean,
+
+  /**
+   * Determines which keyboard to open, e.g.`numeric`.
+   *
+   * The following values work across platforms:
+   *
+   * - `default`
+   * - `numeric`
+   * - `number-pad`
+   * - `decimal-pad`
+   * - `email-address`
+   * - `phone-pad`
+   *
+   * *Android Only*
+   *
+   * The following values work on Android only:
+   *
+   * - `visible-password`
+   */
+  keyboardType?: WithDefault<KeyboardType, 'default'>,
+
+  /**
+   * Determines how the return key should look. On Android you can also use
+   * `returnKeyLabel`.
+   *
+   * *Cross platform*
+   *
+   * The following values work across platforms:
+   *
+   * - `done`
+   * - `go`
+   * - `next`
+   * - `search`
+   * - `send`
+   *
+   * *Android Only*
+   *
+   * The following values work on Android only:
+   *
+   * - `none`
+   * - `previous`
+   */
+  returnKeyType?: WithDefault<ReturnKeyType, 'done'>,
+
+  /**
+   * Limits the maximum number of characters that can be entered. Use this
+   * instead of implementing the logic in JS to avoid flicker.
+   */
+  maxLength?: ?Int32,
+
+  /**
+   * If `true`, the text input can be multiple lines.
+   * The default value is `false`.
+   */
+  multiline?: ?boolean,
+
+  /**
+   * Callback that is called when the text input is blurred.
+   * `target` is the reactTag of the element
+   */
+  onBlur?: ?BubblingEventHandler<$ReadOnly<{|target: Int32|}>>,
+
+  /**
+   * Callback that is called when the text input is focused.
+   * `target` is the reactTag of the element
+   */
+  onFocus?: ?BubblingEventHandler<$ReadOnly<{|target: Int32|}>>,
+
+  /**
+   * Callback that is called when the text input's text changes.
+   * `target` is the reactTag of the element
+   * TODO: differentiate between onChange and onChangeText
+   */
+  onChange?: ?BubblingEventHandler<
+    $ReadOnly<{|target: Int32, eventCount: Int32, text: string|}>,
+  >,
+
+  /**
+   * Callback that is called when the text input's text changes.
+   * Changed text is passed as an argument to the callback handler.
+   * TODO: differentiate between onChange and onChangeText
+   */
+  onChangeText?: ?BubblingEventHandler<
+    $ReadOnly<{|target: Int32, eventCount: Int32, text: string|}>,
+  >,
+
+  /**
+   * Callback that is called when the text input's content size changes.
+   * This will be called with
+   * `{ nativeEvent: { contentSize: { width, height } } }`.
+   *
+   * Only called for multiline text inputs.
+   */
+  onContentSizeChange?: ?DirectEventHandler<
+    $ReadOnly<{|
+      target: Int32,
+      contentSize: $ReadOnly<{|width: Double, height: Double|}>,
+    |}>,
+  >,
+
+  onTextInput?: ?BubblingEventHandler<
+    $ReadOnly<{|
+      target: Int32,
+      text: string,
+      previousText: string,
+      range: $ReadOnly<{|start: Double, end: Double|}>,
+    |}>,
+  >,
+
+  /**
+   * Callback that is called when text input ends.
+   */
+  onEndEditing?: ?BubblingEventHandler<
+    $ReadOnly<{|target: Int32, text: string|}>,
+  >,
+
+  /**
+   * Callback that is called when the text input selection is changed.
+   * This will be called with
+   * `{ nativeEvent: { selection: { start, end } } }`.
+   */
+  onSelectionChange?: ?DirectEventHandler<
+    $ReadOnly<{|
+      target: Int32,
+      selection: $ReadOnly<{|start: Double, end: Double|}>,
+    |}>,
+  >,
+
+  /**
+   * Callback that is called when the text input's submit button is pressed.
+   * Invalid if `multiline={true}` is specified.
+   */
+  onSubmitEditing?: ?BubblingEventHandler<
+    $ReadOnly<{|target: Int32, text: string|}>,
+  >,
+
+  /**
+   * Callback that is called when a key is pressed.
+   * This will be called with `{ nativeEvent: { key: keyValue } }`
+   * where `keyValue` is `'Enter'` or `'Backspace'` for respective keys and
+   * the typed-in character otherwise including `' '` for space.
+   * Fires before `onChange` callbacks.
+   */
+  onKeyPress?: ?BubblingEventHandler<$ReadOnly<{|target: Int32, key: string|}>>,
+
+  /**
+   * Invoked on content scroll with `{ nativeEvent: { contentOffset: { x, y } } }`.
+   * May also contain other properties from ScrollEvent but on Android contentSize
+   * is not provided for performance reasons.
+   */
+  onScroll?: ?DirectEventHandler<
+    $ReadOnly<{|
+      target: Int32,
+      responderIgnoreScroll: boolean,
+      contentInset: $ReadOnly<{|
+        top: Double, // always 0 on Android
+        bottom: Double, // always 0 on Android
+        left: Double, // always 0 on Android
+        right: Double, // always 0 on Android
+      |}>,
+      contentOffset: $ReadOnly<{|
+        x: Double,
+        y: Double,
+      |}>,
+      contentSize: $ReadOnly<{|
+        width: Double, // always 0 on Android
+        height: Double, // always 0 on Android
+      |}>,
+      layoutMeasurement: $ReadOnly<{|
+        width: Double,
+        height: Double,
+      |}>,
+      velocity: $ReadOnly<{|
+        x: Double, // always 0 on Android
+        y: Double, // always 0 on Android
+      |}>,
+    |}>,
+  >,
+
+  /**
+   * The string that will be rendered before text input has been entered.
+   */
+  placeholder?: ?string,
+
+  /**
+   * The text color of the placeholder string.
+   */
+  placeholderTextColor?: ?ColorValue,
+
+  /**
+   * If `true`, the text input obscures the text entered so that sensitive text
+   * like passwords stay secure. The default value is `false`. Does not work with 'multiline={true}'.
+   */
+  secureTextEntry?: ?boolean,
+
+  /**
+   * The highlight and cursor color of the text input.
+   */
+  selectionColor?: ?ColorValue,
+
+  /**
+   * The start and end of the text input's selection. Set start and end to
+   * the same value to position the cursor.
+   */
+  selection?: ?$ReadOnly<{|
+    start: Int32,
+    end?: ?Int32,
+  |}>,
+
+  /**
+   * The value to show for the text input. `TextInput` is a controlled
+   * component, which means the native value will be forced to match this
+   * value prop if provided. For most uses, this works great, but in some
+   * cases this may cause flickering - one common cause is preventing edits
+   * by keeping value the same. In addition to simply setting the same value,
+   * either set `editable={false}`, or set/update `maxLength` to prevent
+   * unwanted edits without flicker.
+   */
+  value?: ?string,
+
+  /**
+   * Provides an initial value that will change when the user starts typing.
+   * Useful for simple use-cases where you do not want to deal with listening
+   * to events and updating the value prop to keep the controlled state in sync.
+   */
+  defaultValue?: ?string,
+
+  /**
+   * If `true`, all text will automatically be selected on focus.
+   */
+  selectTextOnFocus?: ?boolean,
+
+  /**
+   * If `true`, the text field will blur when submitted.
+   * The default value is true for single-line fields and false for
+   * multiline fields. Note that for multiline fields, setting `blurOnSubmit`
+   * to `true` means that pressing return will blur the field and trigger the
+   * `onSubmitEditing` event instead of inserting a newline into the field.
+   */
+  blurOnSubmit?: ?boolean,
+
+  /**
+   * Note that not all Text styles are supported, an incomplete list of what is not supported includes:
+   *
+   * - `borderLeftWidth`
+   * - `borderTopWidth`
+   * - `borderRightWidth`
+   * - `borderBottomWidth`
+   * - `borderTopLeftRadius`
+   * - `borderTopRightRadius`
+   * - `borderBottomRightRadius`
+   * - `borderBottomLeftRadius`
+   *
+   * see [Issue#7070](https://github.com/facebook/react-native/issues/7070)
+   * for more detail.
+   *
+   * [Styles](docs/style.html)
+   */
+  // TODO: figure out what to do with this style prop for codegen/Fabric purposes
+  // This must be commented for Fabric codegen to work; it's currently not possible
+  // to override the default View style prop in codegen.
+  style?: ?TextStyleProp,
+
+  /**
+   * If `true`, caret is hidden. The default value is `false`.
+   * This property is supported only for single-line TextInput component on iOS.
+   */
+  caretHidden?: ?boolean,
+
+  /*
+   * If `true`, contextMenuHidden is hidden. The default value is `false`.
+   */
+  contextMenuHidden?: ?boolean,
+
+  /**
+   * The following are props that `BaseTextShadowNode` takes. It is unclear if they
+   * are used by TextInput.
+   */
+  textShadowColor?: ?ColorValue,
+  textShadowRadius?: ?Float,
+  textDecorationLine?: ?string,
+  fontStyle?: ?string,
+  textShadowOffset?: ?$ReadOnly<{|width?: ?Double, height?: ?Double|}>,
+  lineHeight?: ?Float,
+  textTransform?: ?string,
+  color?: ?Int32,
+  letterSpacing?: ?Float,
+  fontSize?: ?Float,
+  textAlign?: ?string,
+  includeFontPadding?: ?boolean,
+  fontWeight?: ?string,
+  fontFamily?: ?string,
+
+  /**
+   * I cannot find where these are defined but JS complains without them.
+   */
+  textAlignVertical?: ?string,
+  cursorColor?: ?ColorValue,
+
+  /**
+   * "Private" fields used by TextInput.js and not users of this component directly
+   */
+  mostRecentEventCount: Int32,
+  text?: ?string,
+|}>;
+
+type NativeType = HostComponent<NativeProps>;
+
+type NativeCommands = TextInputNativeCommands<NativeType>;
+
+export const Commands: NativeCommands = codegenNativeCommands<NativeCommands>({
+  supportedCommands: ['focus', 'blur', 'setTextAndSelection'],
+});
+
+let AndroidTextInputNativeComponent;
+if (global.RN$Bridgeless) {
+  ReactNativeViewConfigRegistry.register('AndroidTextInput', () => {
+    return AndroidTextInputViewConfig;
+  });
+  AndroidTextInputNativeComponent = 'AndroidTextInput';
+} else {
+  AndroidTextInputNativeComponent = requireNativeComponent<NativeProps>(
+    'AndroidTextInput',
+  );
+}
+
+// flowlint-next-line unclear-type:off
+export default ((AndroidTextInputNativeComponent: any): HostComponent<NativeProps>);

node_modules/react-native/Libraries/Components/TextInput/AndroidTextInputViewConfig.js

@@ -0,0 +1,84 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+'use strict';
+
+import ReactNativeViewViewConfig from '../../Components/View/ReactNativeViewViewConfig';
+import type {ReactNativeBaseComponentViewConfig} from '../../Renderer/shims/ReactNativeTypes';
+
+const AndroidTextInputViewConfig = {
+  uiViewClassName: 'AndroidTextInput',
+  bubblingEventTypes: {
+    topTextInput: {
+      phasedRegistrationNames: {
+        bubbled: 'onTextInput',
+        captured: 'onTextInputCapture',
+      },
+    },
+  },
+  directEventTypes: {},
+  validAttributes: {
+    ...ReactNativeViewViewConfig.validAttributes,
+
+    maxFontSizeMultiplier: true,
+    placeholder: true,
+    inlineImagePadding: true,
+    contextMenuHidden: true,
+    textShadowColor: {process: require('../../StyleSheet/processColor')},
+    maxLength: true,
+    selectTextOnFocus: true,
+    textShadowRadius: true,
+    underlineColorAndroid: {process: require('../../StyleSheet/processColor')},
+    textDecorationLine: true,
+    blurOnSubmit: true,
+    textAlignVertical: true,
+    fontStyle: true,
+    textShadowOffset: true,
+    selectionColor: {process: require('../../StyleSheet/processColor')},
+    selection: true,
+    placeholderTextColor: {process: require('../../StyleSheet/processColor')},
+    importantForAutofill: true,
+    lineHeight: true,
+    textTransform: true,
+    returnKeyType: true,
+    keyboardType: true,
+    multiline: true,
+    color: true,
+    autoCompleteType: true,
+    numberOfLines: true,
+    letterSpacing: true,
+    returnKeyLabel: true,
+    fontSize: true,
+    onKeyPress: true,
+    cursorColor: {process: require('../../StyleSheet/processColor')},
+    text: true,
+    showSoftInputOnFocus: true,
+    textAlign: true,
+    autoCapitalize: true,
+    autoCorrect: true,
+    caretHidden: true,
+    secureTextEntry: true,
+    textBreakStrategy: true,
+    onScroll: true,
+    onContentSizeChange: true,
+    disableFullscreenUI: true,
+    includeFontPadding: true,
+    fontWeight: true,
+    fontFamily: true,
+    allowFontScaling: true,
+    onSelectionChange: true,
+    mostRecentEventCount: true,
+    inlineImageLeft: true,
+    editable: true,
+    fontVariant: true,
+  },
+};
+
+module.exports = (AndroidTextInputViewConfig: ReactNativeBaseComponentViewConfig<>);

node_modules/react-native/Libraries/Components/TextInput/InputAccessoryView.js

@@ -0,0 +1,118 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow
+ * @format
+ */
+
+'use strict';
+
+const Platform = require('../../Utilities/Platform');
+const React = require('react');
+const StyleSheet = require('../../StyleSheet/StyleSheet');
+
+import RCTInputAccessoryViewNativeComponent from './RCTInputAccessoryViewNativeComponent';
+
+import type {ViewStyleProp} from '../../StyleSheet/StyleSheet';
+import type {ColorValue} from '../../StyleSheet/StyleSheetTypes';
+
+/**
+ * Note: iOS only
+ *
+ * A component which enables customization of the keyboard input accessory view.
+ * The input accessory view is displayed above the keyboard whenever a TextInput
+ * has focus. This component can be used to create custom toolbars.
+ *
+ * To use this component wrap your custom toolbar with the
+ * InputAccessoryView component, and set a nativeID. Then, pass that nativeID
+ * as the inputAccessoryViewID of whatever TextInput you desire. A simple
+ * example:
+ *
+ * ```ReactNativeWebPlayer
+ * import React, { Component } from 'react';
+ * import { AppRegistry, TextInput, InputAccessoryView, Button } from 'react-native';
+ *
+ * export default class UselessTextInput extends Component {
+ *   constructor(props) {
+ *     super(props);
+ *     this.state = {text: 'Placeholder Text'};
+ *   }
+ *
+ *   render() {
+ *     const inputAccessoryViewID = "uniqueID";
+ *     return (
+ *       <View>
+ *         <ScrollView keyboardDismissMode="interactive">
+ *           <TextInput
+ *             style={{
+ *               padding: 10,
+ *               paddingTop: 50,
+ *             }}
+ *             inputAccessoryViewID=inputAccessoryViewID
+ *             onChangeText={text => this.setState({text})}
+ *             value={this.state.text}
+ *           />
+ *         </ScrollView>
+ *         <InputAccessoryView nativeID=inputAccessoryViewID>
+ *           <Button
+ *             onPress={() => this.setState({text: 'Placeholder Text'})}
+ *             title="Reset Text"
+ *           />
+ *         </InputAccessoryView>
+ *       </View>
+ *     );
+ *   }
+ * }
+ *
+ * // skip this line if using Create React Native App
+ * AppRegistry.registerComponent('AwesomeProject', () => UselessTextInput);
+ * ```
+ *
+ * This component can also be used to create sticky text inputs (text inputs
+ * which are anchored to the top of the keyboard). To do this, wrap a
+ * TextInput with the InputAccessoryView component, and don't set a nativeID.
+ * For an example, look at InputAccessoryViewExample.js in RNTester.
+ */
+
+type Props = $ReadOnly<{|
+  +children: React.Node,
+  /**
+   * An ID which is used to associate this `InputAccessoryView` to
+   * specified TextInput(s).
+   */
+  nativeID?: ?string,
+  style?: ?ViewStyleProp,
+  backgroundColor?: ?ColorValue,
+|}>;
+
+class InputAccessoryView extends React.Component<Props> {
+  render(): React.Node {
+    if (Platform.OS !== 'ios') {
+      console.warn('<InputAccessoryView> is only supported on iOS.');
+    }
+
+    if (React.Children.count(this.props.children) === 0) {
+      return null;
+    }
+
+    return (
+      <RCTInputAccessoryViewNativeComponent
+        style={[this.props.style, styles.container]}
+        nativeID={this.props.nativeID}
+        backgroundColor={this.props.backgroundColor}>
+        {this.props.children}
+      </RCTInputAccessoryViewNativeComponent>
+    );
+  }
+}
+
+const styles = StyleSheet.create({
+  container: {
+    position: 'absolute',
+  },
+});
+
+module.exports = InputAccessoryView;

node_modules/react-native/Libraries/Components/TextInput/RCTInputAccessoryViewNativeComponent.js

@@ -0,0 +1,26 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+'use strict';
+
+import type {ColorValue} from '../../StyleSheet/StyleSheetTypes';
+import type {ViewProps} from '../View/ViewPropTypes';
+
+import codegenNativeComponent from '../../Utilities/codegenNativeComponent';
+import type {HostComponent} from '../../Renderer/shims/ReactNativeTypes';
+
+type NativeProps = $ReadOnly<{|
+  ...ViewProps,
+  backgroundColor?: ?ColorValue,
+|}>;
+
+export default (codegenNativeComponent<NativeProps>(
+  'RCTInputAccessoryView',
+): HostComponent<NativeProps>);

node_modules/react-native/Libraries/Components/TextInput/RCTMultilineTextInputNativeComponent.js

@@ -0,0 +1,32 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+'use strict';
+
+import type {HostComponent} from '../../Renderer/shims/ReactNativeTypes';
+import requireNativeComponent from '../../ReactNative/requireNativeComponent';
+import codegenNativeCommands from '../../Utilities/codegenNativeCommands';
+import type {Int32} from '../../Types/CodegenTypes';
+import type {TextInputNativeCommands} from './TextInputNativeCommands';
+import * as React from 'react';
+
+type NativeType = HostComponent<mixed>;
+
+type NativeCommands = TextInputNativeCommands<NativeType>;
+
+export const Commands: NativeCommands = codegenNativeCommands<NativeCommands>({
+  supportedCommands: ['focus', 'blur', 'setTextAndSelection'],
+});
+
+const SinglelineTextInputNativeComponent: HostComponent<mixed> = requireNativeComponent<mixed>(
+  'RCTMultilineTextInputView',
+);
+
+export default SinglelineTextInputNativeComponent;

node_modules/react-native/Libraries/Components/TextInput/RCTSingelineTextInputNativeComponent.js

@@ -0,0 +1,43 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+'use strict';
+
+import type {HostComponent} from '../../Renderer/shims/ReactNativeTypes';
+import requireNativeComponent from '../../ReactNative/requireNativeComponent';
+import codegenNativeCommands from '../../Utilities/codegenNativeCommands';
+import type {Int32} from '../../Types/CodegenTypes';
+import * as React from 'react';
+import type {TextInputNativeCommands} from './TextInputNativeCommands';
+import RCTSinglelineTextInputViewConfig from './RCTSinglelineTextInputViewConfig';
+const ReactNativeViewConfigRegistry = require('../../Renderer/shims/ReactNativeViewConfigRegistry');
+
+type NativeType = HostComponent<mixed>;
+
+type NativeCommands = TextInputNativeCommands<NativeType>;
+
+export const Commands: NativeCommands = codegenNativeCommands<NativeCommands>({
+  supportedCommands: ['focus', 'blur', 'setTextAndSelection'],
+});
+
+let SinglelineTextInputNativeComponent;
+if (global.RN$Bridgeless) {
+  ReactNativeViewConfigRegistry.register('RCTSinglelineTextInputView', () => {
+    return RCTSinglelineTextInputViewConfig;
+  });
+  SinglelineTextInputNativeComponent = 'RCTSinglelineTextInputView';
+} else {
+  SinglelineTextInputNativeComponent = requireNativeComponent<mixed>(
+    'RCTSinglelineTextInputView',
+  );
+}
+
+// flowlint-next-line unclear-type:off
+export default ((SinglelineTextInputNativeComponent: any): HostComponent<mixed>);

node_modules/react-native/Libraries/Components/TextInput/RCTSinglelineTextInputViewConfig.js

@@ -0,0 +1,134 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+'use strict';
+
+import ReactNativeViewViewConfig from '../../Components/View/ReactNativeViewViewConfig';
+import type {ReactNativeBaseComponentViewConfig} from '../../Renderer/shims/ReactNativeTypes';
+
+const RCTSinglelineTextInputViewConfig = {
+  uiViewClassName: 'RCTSinglelineTextInputView',
+  bubblingEventTypes: {
+    topBlur: {
+      phasedRegistrationNames: {
+        bubbled: 'onBlur',
+        captured: 'onBlurCapture',
+      },
+    },
+    topChange: {
+      phasedRegistrationNames: {
+        bubbled: 'onChange',
+        captured: 'onChangeCapture',
+      },
+    },
+    topEndEditing: {
+      phasedRegistrationNames: {
+        bubbled: 'onEndEditing',
+        captured: 'onEndEditingCapture',
+      },
+    },
+    topFocus: {
+      phasedRegistrationNames: {
+        bubbled: 'onFocus',
+        captured: 'onFocusCapture',
+      },
+    },
+    topKeyPress: {
+      phasedRegistrationNames: {
+        bubbled: 'onKeyPress',
+        captured: 'onKeyPressCapture',
+      },
+    },
+    topSubmitEditing: {
+      phasedRegistrationNames: {
+        bubbled: 'onSubmitEditing',
+        captured: 'onSubmitEditingCapture',
+      },
+    },
+    topTouchCancel: {
+      phasedRegistrationNames: {
+        bubbled: 'onTouchCancel',
+        captured: 'onTouchCancelCapture',
+      },
+    },
+    topTouchEnd: {
+      phasedRegistrationNames: {
+        bubbled: 'onTouchEnd',
+        captured: 'onTouchEndCapture',
+      },
+    },
+
+    topTouchMove: {
+      phasedRegistrationNames: {
+        bubbled: 'onTouchMove',
+        captured: 'onTouchMoveCapture',
+      },
+    },
+  },
+  directEventTypes: {},
+  validAttributes: {
+    ...ReactNativeViewViewConfig.validAttributes,
+    fontSize: true,
+    fontWeight: true,
+    fontVariant: true,
+    // flowlint-next-line untyped-import:off
+    textShadowOffset: {diff: require('../../Utilities/differ/sizesDiffer')},
+    allowFontScaling: true,
+    fontStyle: true,
+    textTransform: true,
+    textAlign: true,
+    fontFamily: true,
+    lineHeight: true,
+    isHighlighted: true,
+    writingDirection: true,
+    textDecorationLine: true,
+    textShadowRadius: true,
+    letterSpacing: true,
+    textDecorationStyle: true,
+    textDecorationColor: {process: require('../../StyleSheet/processColor')},
+    color: {process: require('../../StyleSheet/processColor')},
+    maxFontSizeMultiplier: true,
+    textShadowColor: {process: require('../../StyleSheet/processColor')},
+    editable: true,
+    inputAccessoryViewID: true,
+    caretHidden: true,
+    enablesReturnKeyAutomatically: true,
+    placeholderTextColor: {process: require('../../StyleSheet/processColor')},
+    onSelectionChange: true,
+    clearButtonMode: true,
+    onContentSizeChange: true,
+    keyboardType: true,
+    selection: true,
+    returnKeyType: true,
+    blurOnSubmit: true,
+    mostRecentEventCount: true,
+    onChange: true,
+    scrollEnabled: true,
+    selectionColor: {process: require('../../StyleSheet/processColor')},
+    contextMenuHidden: true,
+    secureTextEntry: true,
+    onTextInput: true,
+    placeholder: true,
+    autoCorrect: true,
+    onScroll: true,
+    multiline: true,
+    textContentType: true,
+    maxLength: true,
+    autoCapitalize: true,
+    keyboardAppearance: true,
+    passwordRules: true,
+    spellCheck: true,
+    selectTextOnFocus: true,
+    text: true,
+    clearTextOnFocus: true,
+  },
+};
+
+module.exports = (RCTSinglelineTextInputViewConfig: ReactNativeBaseComponentViewConfig<>);

node_modules/react-native/Libraries/Components/TextInput/TextInputNativeCommands.js

@@ -0,0 +1,31 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+'use strict';
+
+import * as React from 'react';
+
+import type {Int32} from '../../Types/CodegenTypes';
+
+export interface TextInputNativeCommands<T> {
+  +focus: (viewRef: React.ElementRef<T>) => void;
+  +blur: (viewRef: React.ElementRef<T>) => void;
+  +setTextAndSelection: (
+    viewRef: React.ElementRef<T>,
+    mostRecentEventCount: Int32,
+    value: ?string, // in theory this is nullable
+    start: Int32,
+    end: Int32,
+  ) => void;
+}
+
+const supportedCommands = ['focus', 'blur', 'setTextAndSelection'];
+
+export default supportedCommands;

node_modules/react-native/Libraries/Components/TextInput/TextInputState.js

@@ -0,0 +1,191 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @flow strict-local
+ */
+
+// This class is responsible for coordinating the "focused" state for
+// TextInputs. All calls relating to the keyboard should be funneled
+// through here.
+
+'use strict';
+
+const React = require('react');
+const Platform = require('../../Utilities/Platform');
+const {findNodeHandle} = require('../../Renderer/shims/ReactNative');
+import {Commands as AndroidTextInputCommands} from '../../Components/TextInput/AndroidTextInputNativeComponent';
+import {Commands as iOSTextInputCommands} from '../../Components/TextInput/RCTSingelineTextInputNativeComponent';
+
+import type {HostComponent} from '../../Renderer/shims/ReactNativeTypes';
+type ComponentRef = React.ElementRef<HostComponent<mixed>>;
+
+let currentlyFocusedInputRef: ?ComponentRef = null;
+const inputs = new Set();
+
+function currentlyFocusedInput(): ?ComponentRef {
+  return currentlyFocusedInputRef;
+}
+
+/**
+ * Returns the ID of the currently focused text field, if one exists
+ * If no text field is focused it returns null
+ */
+function currentlyFocusedField(): ?number {
+  if (__DEV__) {
+    console.error(
+      'currentlyFocusedField is deprecated and will be removed in a future release. Use currentlyFocusedInput',
+    );
+  }
+
+  return findNodeHandle(currentlyFocusedInputRef);
+}
+
+function focusInput(textField: ?ComponentRef): void {
+  if (currentlyFocusedInputRef !== textField && textField != null) {
+    currentlyFocusedInputRef = textField;
+  }
+}
+
+function blurInput(textField: ?ComponentRef): void {
+  if (currentlyFocusedInputRef === textField && textField != null) {
+    currentlyFocusedInputRef = null;
+  }
+}
+
+function focusField(textFieldID: ?number): void {
+  if (__DEV__) {
+    console.error('focusField no longer works. Use focusInput');
+  }
+
+  return;
+}
+
+function blurField(textFieldID: ?number) {
+  if (__DEV__) {
+    console.error('blurField no longer works. Use blurInput');
+  }
+
+  return;
+}
+
+/**
+ * @param {number} TextInputID id of the text field to focus
+ * Focuses the specified text field
+ * noop if the text field was already focused
+ */
+function focusTextInput(textField: ?ComponentRef) {
+  if (typeof textField === 'number') {
+    if (__DEV__) {
+      console.error(
+        'focusTextInput must be called with a host component. Passing a react tag is deprecated.',
+      );
+    }
+
+    return;
+  }
+
+  if (currentlyFocusedInputRef !== textField && textField != null) {
+    focusInput(textField);
+    if (Platform.OS === 'ios') {
+      // This isn't necessarily a single line text input
+      // But commands don't actually care as long as the thing being passed in
+      // actually has a command with that name. So this should work with single
+      // and multiline text inputs. Ideally we'll merge them into one component
+      // in the future.
+      iOSTextInputCommands.focus(textField);
+    } else if (Platform.OS === 'android') {
+      AndroidTextInputCommands.focus(textField);
+    }
+  }
+}
+
+/**
+ * @param {number} textFieldID id of the text field to unfocus
+ * Unfocuses the specified text field
+ * noop if it wasn't focused
+ */
+function blurTextInput(textField: ?ComponentRef) {
+  if (typeof textField === 'number') {
+    if (__DEV__) {
+      console.error(
+        'focusTextInput must be called with a host component. Passing a react tag is deprecated.',
+      );
+    }
+
+    return;
+  }
+
+  if (currentlyFocusedInputRef === textField && textField != null) {
+    blurInput(textField);
+    if (Platform.OS === 'ios') {
+      // This isn't necessarily a single line text input
+      // But commands don't actually care as long as the thing being passed in
+      // actually has a command with that name. So this should work with single
+      // and multiline text inputs. Ideally we'll merge them into one component
+      // in the future.
+      iOSTextInputCommands.blur(textField);
+    } else if (Platform.OS === 'android') {
+      AndroidTextInputCommands.blur(textField);
+    }
+  }
+}
+
+function registerInput(textField: ComponentRef) {
+  if (typeof textField === 'number') {
+    if (__DEV__) {
+      console.error(
+        'registerInput must be called with a host component. Passing a react tag is deprecated.',
+      );
+    }
+
+    return;
+  }
+
+  inputs.add(textField);
+}
+
+function unregisterInput(textField: ComponentRef) {
+  if (typeof textField === 'number') {
+    if (__DEV__) {
+      console.error(
+        'unregisterInput must be called with a host component. Passing a react tag is deprecated.',
+      );
+    }
+
+    return;
+  }
+  inputs.delete(textField);
+}
+
+function isTextInput(textField: ComponentRef): boolean {
+  if (typeof textField === 'number') {
+    if (__DEV__) {
+      console.error(
+        'isTextInput must be called with a host component. Passing a react tag is deprecated.',
+      );
+    }
+
+    return false;
+  }
+
+  return inputs.has(textField);
+}
+
+module.exports = {
+  currentlyFocusedInput,
+  focusInput,
+  blurInput,
+
+  currentlyFocusedField,
+  focusField,
+  blurField,
+  focusTextInput,
+  blurTextInput,
+  registerInput,
+  unregisterInput,
+  isTextInput,
+};

node_modules/react-native/Libraries/Components/ToastAndroid/NativeToastAndroid.js

@@ -0,0 +1,39 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+'use strict';
+
+import type {TurboModule} from '../../TurboModule/RCTExport';
+import * as TurboModuleRegistry from '../../TurboModule/TurboModuleRegistry';
+
+export interface Spec extends TurboModule {
+  +getConstants: () => {|
+    SHORT: number,
+    LONG: number,
+    TOP: number,
+    BOTTOM: number,
+    CENTER: number,
+  |};
+  +show: (message: string, duration: number) => void;
+  +showWithGravity: (
+    message: string,
+    duration: number,
+    gravity: number,
+  ) => void;
+  +showWithGravityAndOffset: (
+    message: string,
+    duration: number,
+    gravity: number,
+    xOffset: number,
+    yOffset: number,
+  ) => void;
+}
+
+export default (TurboModuleRegistry.getEnforcing<Spec>('ToastAndroid'): Spec);

node_modules/react-native/Libraries/Components/ToastAndroid/ToastAndroid.android.js

@@ -0,0 +1,73 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @flow strict-local
+ */
+
+'use strict';
+import NativeToastAndroid from './NativeToastAndroid';
+
+/**
+ * This exposes the native ToastAndroid module as a JS module. This has a function 'show'
+ * which takes the following parameters:
+ *
+ * 1. String message: A string with the text to toast
+ * 2. int duration: The duration of the toast. May be ToastAndroid.SHORT or ToastAndroid.LONG
+ *
+ * There is also a function `showWithGravity` to specify the layout gravity. May be
+ * ToastAndroid.TOP, ToastAndroid.BOTTOM, ToastAndroid.CENTER.
+ *
+ * The 'showWithGravityAndOffset' function adds on the ability to specify offset
+ * These offset values will translate to pixels.
+ *
+ * Basic usage:
+ * ```javascript
+ * ToastAndroid.show('A pikachu appeared nearby !', ToastAndroid.SHORT);
+ * ToastAndroid.showWithGravity('All Your Base Are Belong To Us', ToastAndroid.SHORT, ToastAndroid.CENTER);
+ * ToastAndroid.showWithGravityAndOffset('A wild toast appeared!', ToastAndroid.LONG, ToastAndroid.BOTTOM, 25, 50);
+ * ```
+ */
+
+const ToastAndroid = {
+  // Toast duration constants
+  SHORT: (NativeToastAndroid.getConstants().SHORT: number),
+  LONG: (NativeToastAndroid.getConstants().LONG: number),
+  // Toast gravity constants
+  TOP: (NativeToastAndroid.getConstants().TOP: number),
+  BOTTOM: (NativeToastAndroid.getConstants().BOTTOM: number),
+  CENTER: (NativeToastAndroid.getConstants().CENTER: number),
+
+  show: function(message: string, duration: number): void {
+    NativeToastAndroid.show(message, duration);
+  },
+
+  showWithGravity: function(
+    message: string,
+    duration: number,
+    gravity: number,
+  ): void {
+    NativeToastAndroid.showWithGravity(message, duration, gravity);
+  },
+
+  showWithGravityAndOffset: function(
+    message: string,
+    duration: number,
+    gravity: number,
+    xOffset: number,
+    yOffset: number,
+  ): void {
+    NativeToastAndroid.showWithGravityAndOffset(
+      message,
+      duration,
+      gravity,
+      xOffset,
+      yOffset,
+    );
+  },
+};
+
+module.exports = ToastAndroid;

node_modules/react-native/Libraries/Components/ToastAndroid/ToastAndroid.ios.js

@@ -0,0 +1,39 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @noflow
+ */
+
+'use strict';
+
+const warning = require('fbjs/lib/warning');
+
+const ToastAndroid = {
+  show: function(message: string, duration: number): void {
+    warning(false, 'ToastAndroid is not supported on this platform.');
+  },
+
+  showWithGravity: function(
+    message: string,
+    duration: number,
+    gravity: number,
+  ): void {
+    warning(false, 'ToastAndroid is not supported on this platform.');
+  },
+
+  showWithGravityAndOffset: function(
+    message: string,
+    duration: number,
+    gravity: number,
+    xOffset: number,
+    yOffset: number,
+  ): void {
+    warning(false, 'ToastAndroid is not supported on this platform.');
+  },
+};
+
+module.exports = ToastAndroid;

node_modules/react-native/Libraries/Components/Touchable/BoundingDimensions.js

@@ -0,0 +1,46 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ */
+
+'use strict';
+
+const PooledClass = require('./PooledClass');
+
+const twoArgumentPooler = PooledClass.twoArgumentPooler;
+
+/**
+ * PooledClass representing the bounding rectangle of a region.
+ *
+ * @param {number} width Width of bounding rectangle.
+ * @param {number} height Height of bounding rectangle.
+ * @constructor BoundingDimensions
+ */
+function BoundingDimensions(width, height) {
+  this.width = width;
+  this.height = height;
+}
+
+BoundingDimensions.prototype.destructor = function() {
+  this.width = null;
+  this.height = null;
+};
+
+/**
+ * @param {HTMLElement} element Element to return `BoundingDimensions` for.
+ * @return {BoundingDimensions} Bounding dimensions of `element`.
+ */
+BoundingDimensions.getPooledFromElement = function(element) {
+  return BoundingDimensions.getPooled(
+    element.offsetWidth,
+    element.offsetHeight,
+  );
+};
+
+PooledClass.addPoolingTo(BoundingDimensions, twoArgumentPooler);
+
+module.exports = BoundingDimensions;

node_modules/react-native/Libraries/Components/Touchable/PooledClass.js

@@ -0,0 +1,122 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @flow
+ */
+
+'use strict';
+
+const invariant = require('invariant');
+
+/**
+ * Static poolers. Several custom versions for each potential number of
+ * arguments. A completely generic pooler is easy to implement, but would
+ * require accessing the `arguments` object. In each of these, `this` refers to
+ * the Class itself, not an instance. If any others are needed, simply add them
+ * here, or in their own files.
+ */
+const oneArgumentPooler = function(copyFieldsFrom) {
+  const Klass = this;
+  if (Klass.instancePool.length) {
+    const instance = Klass.instancePool.pop();
+    Klass.call(instance, copyFieldsFrom);
+    return instance;
+  } else {
+    return new Klass(copyFieldsFrom);
+  }
+};
+
+const twoArgumentPooler = function(a1, a2) {
+  const Klass = this;
+  if (Klass.instancePool.length) {
+    const instance = Klass.instancePool.pop();
+    Klass.call(instance, a1, a2);
+    return instance;
+  } else {
+    return new Klass(a1, a2);
+  }
+};
+
+const threeArgumentPooler = function(a1, a2, a3) {
+  const Klass = this;
+  if (Klass.instancePool.length) {
+    const instance = Klass.instancePool.pop();
+    Klass.call(instance, a1, a2, a3);
+    return instance;
+  } else {
+    return new Klass(a1, a2, a3);
+  }
+};
+
+const fourArgumentPooler = function(a1, a2, a3, a4) {
+  const Klass = this;
+  if (Klass.instancePool.length) {
+    const instance = Klass.instancePool.pop();
+    Klass.call(instance, a1, a2, a3, a4);
+    return instance;
+  } else {
+    return new Klass(a1, a2, a3, a4);
+  }
+};
+
+const standardReleaser = function(instance) {
+  const Klass = this;
+  invariant(
+    instance instanceof Klass,
+    'Trying to release an instance into a pool of a different type.',
+  );
+  instance.destructor();
+  if (Klass.instancePool.length < Klass.poolSize) {
+    Klass.instancePool.push(instance);
+  }
+};
+
+const DEFAULT_POOL_SIZE = 10;
+const DEFAULT_POOLER = oneArgumentPooler;
+
+type Pooler = any;
+
+/**
+ * Augments `CopyConstructor` to be a poolable class, augmenting only the class
+ * itself (statically) not adding any prototypical fields. Any CopyConstructor
+ * you give this may have a `poolSize` property, and will look for a
+ * prototypical `destructor` on instances.
+ *
+ * @param {Function} CopyConstructor Constructor that can be used to reset.
+ * @param {Function} pooler Customizable pooler.
+ */
+const addPoolingTo = function<T>(
+  CopyConstructor: Class<T>,
+  pooler: Pooler,
+): Class<T> & {
+  getPooled(
+    ...args: $ReadOnlyArray<mixed>
+  ): /* arguments of the constructor */ T,
+  release(instance: mixed): void,
+  ...
+} {
+  // Casting as any so that flow ignores the actual implementation and trusts
+  // it to match the type we declared
+  const NewKlass = (CopyConstructor: any);
+  NewKlass.instancePool = [];
+  NewKlass.getPooled = pooler || DEFAULT_POOLER;
+  if (!NewKlass.poolSize) {
+    NewKlass.poolSize = DEFAULT_POOL_SIZE;
+  }
+  NewKlass.release = standardReleaser;
+  return NewKlass;
+};
+
+const PooledClass = {
+  addPoolingTo: addPoolingTo,
+  oneArgumentPooler: (oneArgumentPooler: Pooler),
+  twoArgumentPooler: (twoArgumentPooler: Pooler),
+  threeArgumentPooler: (threeArgumentPooler: Pooler),
+  fourArgumentPooler: (fourArgumentPooler: Pooler),
+};
+
+module.exports = PooledClass;

node_modules/react-native/Libraries/Components/Touchable/Position.js

@@ -0,0 +1,36 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ */
+
+'use strict';
+
+const PooledClass = require('./PooledClass');
+
+const twoArgumentPooler = PooledClass.twoArgumentPooler;
+
+/**
+ * Position does not expose methods for construction via an `HTMLDOMElement`,
+ * because it isn't meaningful to construct such a thing without first defining
+ * a frame of reference.
+ *
+ * @param {number} windowStartKey Key that window starts at.
+ * @param {number} windowEndKey Key that window ends at.
+ */
+function Position(left, top) {
+  this.left = left;
+  this.top = top;
+}
+
+Position.prototype.destructor = function() {
+  this.left = null;
+  this.top = null;
+};
+
+PooledClass.addPoolingTo(Position, twoArgumentPooler);
+
+module.exports = Position;

node_modules/react-native/Libraries/Components/Touchable/TVTouchable.js

@@ -0,0 +1,55 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow
+ * @format
+ */
+
+'use strict';
+
+import invariant from 'invariant';
+import ReactNative from '../../Renderer/shims/ReactNative';
+import type {
+  BlurEvent,
+  FocusEvent,
+  PressEvent,
+} from '../../Types/CoreEventTypes';
+import Platform from '../../Utilities/Platform';
+import TVEventHandler from '../../Components/AppleTV/TVEventHandler';
+
+type TVTouchableConfig = $ReadOnly<{|
+  getDisabled: () => boolean,
+  onBlur: (event: BlurEvent) => mixed,
+  onFocus: (event: FocusEvent) => mixed,
+  onPress: (event: PressEvent) => mixed,
+|}>;
+
+export default class TVTouchable {
+  _tvEventHandler: TVEventHandler;
+
+  constructor(component: any, config: TVTouchableConfig) {
+    invariant(Platform.isTV, 'TVTouchable: Requires `Platform.isTV`.');
+    this._tvEventHandler = new TVEventHandler();
+    this._tvEventHandler.enable(component, (_, tvData) => {
+      tvData.dispatchConfig = {};
+      if (ReactNative.findNodeHandle(component) === tvData.tag) {
+        if (tvData.eventType === 'focus') {
+          config.onFocus(tvData);
+        } else if (tvData.eventType === 'blur') {
+          config.onBlur(tvData);
+        } else if (tvData.eventType === 'select') {
+          if (!config.getDisabled()) {
+            config.onPress(tvData);
+          }
+        }
+      }
+    });
+  }
+
+  destroy(): void {
+    this._tvEventHandler.disable();
+  }
+}

node_modules/react-native/Libraries/Components/Touchable/Touchable.js

@@ -0,0 +1,984 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow
+ * @format
+ */
+
+'use strict';
+
+const BoundingDimensions = require('./BoundingDimensions');
+const Platform = require('../../Utilities/Platform');
+const Position = require('./Position');
+const React = require('react');
+const ReactNative = require('../../Renderer/shims/ReactNative');
+const StyleSheet = require('../../StyleSheet/StyleSheet');
+const TVEventHandler = require('../AppleTV/TVEventHandler');
+const UIManager = require('../../ReactNative/UIManager');
+const View = require('../View/View');
+const SoundManager = require('../Sound/SoundManager');
+
+const keyMirror = require('fbjs/lib/keyMirror');
+const normalizeColor = require('../../StyleSheet/normalizeColor');
+
+import type {EdgeInsetsProp} from '../../StyleSheet/EdgeInsetsPropType';
+import type {PressEvent} from '../../Types/CoreEventTypes';
+
+const extractSingleTouch = nativeEvent => {
+  const touches = nativeEvent.touches;
+  const changedTouches = nativeEvent.changedTouches;
+  const hasTouches = touches && touches.length > 0;
+  const hasChangedTouches = changedTouches && changedTouches.length > 0;
+
+  return !hasTouches && hasChangedTouches
+    ? changedTouches[0]
+    : hasTouches
+    ? touches[0]
+    : nativeEvent;
+};
+
+/**
+ * `Touchable`: Taps done right.
+ *
+ * You hook your `ResponderEventPlugin` events into `Touchable`. `Touchable`
+ * will measure time/geometry and tells you when to give feedback to the user.
+ *
+ * ====================== Touchable Tutorial ===============================
+ * The `Touchable` mixin helps you handle the "press" interaction. It analyzes
+ * the geometry of elements, and observes when another responder (scroll view
+ * etc) has stolen the touch lock. It notifies your component when it should
+ * give feedback to the user. (bouncing/highlighting/unhighlighting).
+ *
+ * - When a touch was activated (typically you highlight)
+ * - When a touch was deactivated (typically you unhighlight)
+ * - When a touch was "pressed" - a touch ended while still within the geometry
+ *   of the element, and no other element (like scroller) has "stolen" touch
+ *   lock ("responder") (Typically you bounce the element).
+ *
+ * A good tap interaction isn't as simple as you might think. There should be a
+ * slight delay before showing a highlight when starting a touch. If a
+ * subsequent touch move exceeds the boundary of the element, it should
+ * unhighlight, but if that same touch is brought back within the boundary, it
+ * should rehighlight again. A touch can move in and out of that boundary
+ * several times, each time toggling highlighting, but a "press" is only
+ * triggered if that touch ends while within the element's boundary and no
+ * scroller (or anything else) has stolen the lock on touches.
+ *
+ * To create a new type of component that handles interaction using the
+ * `Touchable` mixin, do the following:
+ *
+ * - Initialize the `Touchable` state.
+ *
+ *   getInitialState: function() {
+ *     return merge(this.touchableGetInitialState(), yourComponentState);
+ *   }
+ *
+ * - Choose the rendered component who's touches should start the interactive
+ *   sequence. On that rendered node, forward all `Touchable` responder
+ *   handlers. You can choose any rendered node you like. Choose a node whose
+ *   hit target you'd like to instigate the interaction sequence:
+ *
+ *   // In render function:
+ *   return (
+ *     <View
+ *       onStartShouldSetResponder={this.touchableHandleStartShouldSetResponder}
+ *       onResponderTerminationRequest={this.touchableHandleResponderTerminationRequest}
+ *       onResponderGrant={this.touchableHandleResponderGrant}
+ *       onResponderMove={this.touchableHandleResponderMove}
+ *       onResponderRelease={this.touchableHandleResponderRelease}
+ *       onResponderTerminate={this.touchableHandleResponderTerminate}>
+ *       <View>
+ *         Even though the hit detection/interactions are triggered by the
+ *         wrapping (typically larger) node, we usually end up implementing
+ *         custom logic that highlights this inner one.
+ *       </View>
+ *     </View>
+ *   );
+ *
+ * - You may set up your own handlers for each of these events, so long as you
+ *   also invoke the `touchable*` handlers inside of your custom handler.
+ *
+ * - Implement the handlers on your component class in order to provide
+ *   feedback to the user. See documentation for each of these class methods
+ *   that you should implement.
+ *
+ *   touchableHandlePress: function() {
+ *      this.performBounceAnimation();  // or whatever you want to do.
+ *   },
+ *   touchableHandleActivePressIn: function() {
+ *     this.beginHighlighting(...);  // Whatever you like to convey activation
+ *   },
+ *   touchableHandleActivePressOut: function() {
+ *     this.endHighlighting(...);  // Whatever you like to convey deactivation
+ *   },
+ *
+ * - There are more advanced methods you can implement (see documentation below):
+ *   touchableGetHighlightDelayMS: function() {
+ *     return 20;
+ *   }
+ *   // In practice, *always* use a predeclared constant (conserve memory).
+ *   touchableGetPressRectOffset: function() {
+ *     return {top: 20, left: 20, right: 20, bottom: 100};
+ *   }
+ */
+
+/**
+ * Touchable states.
+ */
+
+const States = keyMirror({
+  NOT_RESPONDER: null, // Not the responder
+  RESPONDER_INACTIVE_PRESS_IN: null, // Responder, inactive, in the `PressRect`
+  RESPONDER_INACTIVE_PRESS_OUT: null, // Responder, inactive, out of `PressRect`
+  RESPONDER_ACTIVE_PRESS_IN: null, // Responder, active, in the `PressRect`
+  RESPONDER_ACTIVE_PRESS_OUT: null, // Responder, active, out of `PressRect`
+  RESPONDER_ACTIVE_LONG_PRESS_IN: null, // Responder, active, in the `PressRect`, after long press threshold
+  RESPONDER_ACTIVE_LONG_PRESS_OUT: null, // Responder, active, out of `PressRect`, after long press threshold
+  ERROR: null,
+});
+
+type State =
+  | typeof States.NOT_RESPONDER
+  | typeof States.RESPONDER_INACTIVE_PRESS_IN
+  | typeof States.RESPONDER_INACTIVE_PRESS_OUT
+  | typeof States.RESPONDER_ACTIVE_PRESS_IN
+  | typeof States.RESPONDER_ACTIVE_PRESS_OUT
+  | typeof States.RESPONDER_ACTIVE_LONG_PRESS_IN
+  | typeof States.RESPONDER_ACTIVE_LONG_PRESS_OUT
+  | typeof States.ERROR;
+
+/*
+ * Quick lookup map for states that are considered to be "active"
+ */
+
+const baseStatesConditions = {
+  NOT_RESPONDER: false,
+  RESPONDER_INACTIVE_PRESS_IN: false,
+  RESPONDER_INACTIVE_PRESS_OUT: false,
+  RESPONDER_ACTIVE_PRESS_IN: false,
+  RESPONDER_ACTIVE_PRESS_OUT: false,
+  RESPONDER_ACTIVE_LONG_PRESS_IN: false,
+  RESPONDER_ACTIVE_LONG_PRESS_OUT: false,
+  ERROR: false,
+};
+
+const IsActive = {
+  ...baseStatesConditions,
+  RESPONDER_ACTIVE_PRESS_OUT: true,
+  RESPONDER_ACTIVE_PRESS_IN: true,
+};
+
+/**
+ * Quick lookup for states that are considered to be "pressing" and are
+ * therefore eligible to result in a "selection" if the press stops.
+ */
+const IsPressingIn = {
+  ...baseStatesConditions,
+  RESPONDER_INACTIVE_PRESS_IN: true,
+  RESPONDER_ACTIVE_PRESS_IN: true,
+  RESPONDER_ACTIVE_LONG_PRESS_IN: true,
+};
+
+const IsLongPressingIn = {
+  ...baseStatesConditions,
+  RESPONDER_ACTIVE_LONG_PRESS_IN: true,
+};
+
+/**
+ * Inputs to the state machine.
+ */
+const Signals = keyMirror({
+  DELAY: null,
+  RESPONDER_GRANT: null,
+  RESPONDER_RELEASE: null,
+  RESPONDER_TERMINATED: null,
+  ENTER_PRESS_RECT: null,
+  LEAVE_PRESS_RECT: null,
+  LONG_PRESS_DETECTED: null,
+});
+
+type Signal =
+  | typeof Signals.DELAY
+  | typeof Signals.RESPONDER_GRANT
+  | typeof Signals.RESPONDER_RELEASE
+  | typeof Signals.RESPONDER_TERMINATED
+  | typeof Signals.ENTER_PRESS_RECT
+  | typeof Signals.LEAVE_PRESS_RECT
+  | typeof Signals.LONG_PRESS_DETECTED;
+
+/**
+ * Mapping from States x Signals => States
+ */
+const Transitions = {
+  NOT_RESPONDER: {
+    DELAY: States.ERROR,
+    RESPONDER_GRANT: States.RESPONDER_INACTIVE_PRESS_IN,
+    RESPONDER_RELEASE: States.ERROR,
+    RESPONDER_TERMINATED: States.ERROR,
+    ENTER_PRESS_RECT: States.ERROR,
+    LEAVE_PRESS_RECT: States.ERROR,
+    LONG_PRESS_DETECTED: States.ERROR,
+  },
+  RESPONDER_INACTIVE_PRESS_IN: {
+    DELAY: States.RESPONDER_ACTIVE_PRESS_IN,
+    RESPONDER_GRANT: States.ERROR,
+    RESPONDER_RELEASE: States.NOT_RESPONDER,
+    RESPONDER_TERMINATED: States.NOT_RESPONDER,
+    ENTER_PRESS_RECT: States.RESPONDER_INACTIVE_PRESS_IN,
+    LEAVE_PRESS_RECT: States.RESPONDER_INACTIVE_PRESS_OUT,
+    LONG_PRESS_DETECTED: States.ERROR,
+  },
+  RESPONDER_INACTIVE_PRESS_OUT: {
+    DELAY: States.RESPONDER_ACTIVE_PRESS_OUT,
+    RESPONDER_GRANT: States.ERROR,
+    RESPONDER_RELEASE: States.NOT_RESPONDER,
+    RESPONDER_TERMINATED: States.NOT_RESPONDER,
+    ENTER_PRESS_RECT: States.RESPONDER_INACTIVE_PRESS_IN,
+    LEAVE_PRESS_RECT: States.RESPONDER_INACTIVE_PRESS_OUT,
+    LONG_PRESS_DETECTED: States.ERROR,
+  },
+  RESPONDER_ACTIVE_PRESS_IN: {
+    DELAY: States.ERROR,
+    RESPONDER_GRANT: States.ERROR,
+    RESPONDER_RELEASE: States.NOT_RESPONDER,
+    RESPONDER_TERMINATED: States.NOT_RESPONDER,
+    ENTER_PRESS_RECT: States.RESPONDER_ACTIVE_PRESS_IN,
+    LEAVE_PRESS_RECT: States.RESPONDER_ACTIVE_PRESS_OUT,
+    LONG_PRESS_DETECTED: States.RESPONDER_ACTIVE_LONG_PRESS_IN,
+  },
+  RESPONDER_ACTIVE_PRESS_OUT: {
+    DELAY: States.ERROR,
+    RESPONDER_GRANT: States.ERROR,
+    RESPONDER_RELEASE: States.NOT_RESPONDER,
+    RESPONDER_TERMINATED: States.NOT_RESPONDER,
+    ENTER_PRESS_RECT: States.RESPONDER_ACTIVE_PRESS_IN,
+    LEAVE_PRESS_RECT: States.RESPONDER_ACTIVE_PRESS_OUT,
+    LONG_PRESS_DETECTED: States.ERROR,
+  },
+  RESPONDER_ACTIVE_LONG_PRESS_IN: {
+    DELAY: States.ERROR,
+    RESPONDER_GRANT: States.ERROR,
+    RESPONDER_RELEASE: States.NOT_RESPONDER,
+    RESPONDER_TERMINATED: States.NOT_RESPONDER,
+    ENTER_PRESS_RECT: States.RESPONDER_ACTIVE_LONG_PRESS_IN,
+    LEAVE_PRESS_RECT: States.RESPONDER_ACTIVE_LONG_PRESS_OUT,
+    LONG_PRESS_DETECTED: States.RESPONDER_ACTIVE_LONG_PRESS_IN,
+  },
+  RESPONDER_ACTIVE_LONG_PRESS_OUT: {
+    DELAY: States.ERROR,
+    RESPONDER_GRANT: States.ERROR,
+    RESPONDER_RELEASE: States.NOT_RESPONDER,
+    RESPONDER_TERMINATED: States.NOT_RESPONDER,
+    ENTER_PRESS_RECT: States.RESPONDER_ACTIVE_LONG_PRESS_IN,
+    LEAVE_PRESS_RECT: States.RESPONDER_ACTIVE_LONG_PRESS_OUT,
+    LONG_PRESS_DETECTED: States.ERROR,
+  },
+  error: {
+    DELAY: States.NOT_RESPONDER,
+    RESPONDER_GRANT: States.RESPONDER_INACTIVE_PRESS_IN,
+    RESPONDER_RELEASE: States.NOT_RESPONDER,
+    RESPONDER_TERMINATED: States.NOT_RESPONDER,
+    ENTER_PRESS_RECT: States.NOT_RESPONDER,
+    LEAVE_PRESS_RECT: States.NOT_RESPONDER,
+    LONG_PRESS_DETECTED: States.NOT_RESPONDER,
+  },
+};
+
+// ==== Typical Constants for integrating into UI components ====
+// var HIT_EXPAND_PX = 20;
+// var HIT_VERT_OFFSET_PX = 10;
+const HIGHLIGHT_DELAY_MS = 130;
+
+const PRESS_EXPAND_PX = 20;
+
+const LONG_PRESS_THRESHOLD = 500;
+
+const LONG_PRESS_DELAY_MS = LONG_PRESS_THRESHOLD - HIGHLIGHT_DELAY_MS;
+
+const LONG_PRESS_ALLOWED_MOVEMENT = 10;
+
+// Default amount "active" region protrudes beyond box
+
+/**
+ * By convention, methods prefixed with underscores are meant to be @private,
+ * and not @protected. Mixers shouldn't access them - not even to provide them
+ * as callback handlers.
+ *
+ *
+ * ========== Geometry =========
+ * `Touchable` only assumes that there exists a `HitRect` node. The `PressRect`
+ * is an abstract box that is extended beyond the `HitRect`.
+ *
+ *  +--------------------------+
+ *  |                          | - "Start" events in `HitRect` cause `HitRect`
+ *  |  +--------------------+  |   to become the responder.
+ *  |  |  +--------------+  |  | - `HitRect` is typically expanded around
+ *  |  |  |              |  |  |   the `VisualRect`, but shifted downward.
+ *  |  |  |  VisualRect  |  |  | - After pressing down, after some delay,
+ *  |  |  |              |  |  |   and before letting up, the Visual React
+ *  |  |  +--------------+  |  |   will become "active". This makes it eligible
+ *  |  |     HitRect        |  |   for being highlighted (so long as the
+ *  |  +--------------------+  |   press remains in the `PressRect`).
+ *  |        PressRect     o   |
+ *  +----------------------|---+
+ *           Out Region    |
+ *                         +-----+ This gap between the `HitRect` and
+ *                                 `PressRect` allows a touch to move far away
+ *                                 from the original hit rect, and remain
+ *                                 highlighted, and eligible for a "Press".
+ *                                 Customize this via
+ *                                 `touchableGetPressRectOffset()`.
+ *
+ *
+ *
+ * ======= State Machine =======
+ *
+ * +-------------+ <---+ RESPONDER_RELEASE
+ * |NOT_RESPONDER|
+ * +-------------+ <---+ RESPONDER_TERMINATED
+ *     +
+ *     | RESPONDER_GRANT (HitRect)
+ *     v
+ * +---------------------------+  DELAY   +-------------------------+  T + DELAY     +------------------------------+
+ * |RESPONDER_INACTIVE_PRESS_IN|+-------->|RESPONDER_ACTIVE_PRESS_IN| +------------> |RESPONDER_ACTIVE_LONG_PRESS_IN|
+ * +---------------------------+          +-------------------------+                +------------------------------+
+ *     +            ^                         +           ^                                 +           ^
+ *     |LEAVE_      |ENTER_                   |LEAVE_     |ENTER_                           |LEAVE_     |ENTER_
+ *     |PRESS_RECT  |PRESS_RECT               |PRESS_RECT |PRESS_RECT                       |PRESS_RECT |PRESS_RECT
+ *     |            |                         |           |                                 |           |
+ *     v            +                         v           +                                 v           +
+ * +----------------------------+  DELAY  +--------------------------+               +-------------------------------+
+ * |RESPONDER_INACTIVE_PRESS_OUT|+------->|RESPONDER_ACTIVE_PRESS_OUT|               |RESPONDER_ACTIVE_LONG_PRESS_OUT|
+ * +----------------------------+         +--------------------------+               +-------------------------------+
+ *
+ * T + DELAY => LONG_PRESS_DELAY_MS + DELAY
+ *
+ * Not drawn are the side effects of each transition. The most important side
+ * effect is the `touchableHandlePress` abstract method invocation that occurs
+ * when a responder is released while in either of the "Press" states.
+ *
+ * The other important side effects are the highlight abstract method
+ * invocations (internal callbacks) to be implemented by the mixer.
+ *
+ *
+ * @lends Touchable.prototype
+ */
+const TouchableMixin = {
+  componentDidMount: function() {
+    if (!Platform.isTV) {
+      return;
+    }
+
+    this._tvEventHandler = new TVEventHandler();
+    this._tvEventHandler.enable(this, function(cmp, evt) {
+      const myTag = ReactNative.findNodeHandle(cmp);
+      evt.dispatchConfig = {};
+      if (myTag === evt.tag) {
+        if (evt.eventType === 'focus') {
+          cmp.touchableHandleFocus(evt);
+        } else if (evt.eventType === 'blur') {
+          cmp.touchableHandleBlur(evt);
+        } else if (evt.eventType === 'select' && Platform.OS !== 'android') {
+          cmp.touchableHandlePress &&
+            !cmp.props.disabled &&
+            cmp.touchableHandlePress(evt);
+        }
+      }
+    });
+  },
+
+  /**
+   * Clear all timeouts on unmount
+   */
+  componentWillUnmount: function() {
+    if (this._tvEventHandler) {
+      this._tvEventHandler.disable();
+      delete this._tvEventHandler;
+    }
+    this.touchableDelayTimeout && clearTimeout(this.touchableDelayTimeout);
+    this.longPressDelayTimeout && clearTimeout(this.longPressDelayTimeout);
+    this.pressOutDelayTimeout && clearTimeout(this.pressOutDelayTimeout);
+  },
+
+  /**
+   * It's prefer that mixins determine state in this way, having the class
+   * explicitly mix the state in the one and only `getInitialState` method.
+   *
+   * @return {object} State object to be placed inside of
+   * `this.state.touchable`.
+   */
+  touchableGetInitialState: function(): $TEMPORARY$object<{|
+    touchable: $TEMPORARY$object<{|responderID: null, touchState: void|}>,
+  |}> {
+    return {
+      touchable: {touchState: undefined, responderID: null},
+    };
+  },
+
+  // ==== Hooks to Gesture Responder system ====
+  /**
+   * Must return true if embedded in a native platform scroll view.
+   */
+  touchableHandleResponderTerminationRequest: function(): any {
+    return !this.props.rejectResponderTermination;
+  },
+
+  /**
+   * Must return true to start the process of `Touchable`.
+   */
+  touchableHandleStartShouldSetResponder: function(): any {
+    return !this.props.disabled;
+  },
+
+  /**
+   * Return true to cancel press on long press.
+   */
+  touchableLongPressCancelsPress: function(): boolean {
+    return true;
+  },
+
+  /**
+   * Place as callback for a DOM element's `onResponderGrant` event.
+   * @param {SyntheticEvent} e Synthetic event from event system.
+   *
+   */
+  touchableHandleResponderGrant: function(e: PressEvent) {
+    const dispatchID = e.currentTarget;
+    // Since e is used in a callback invoked on another event loop
+    // (as in setTimeout etc), we need to call e.persist() on the
+    // event to make sure it doesn't get reused in the event object pool.
+    e.persist();
+
+    this.pressOutDelayTimeout && clearTimeout(this.pressOutDelayTimeout);
+    this.pressOutDelayTimeout = null;
+
+    this.state.touchable.touchState = States.NOT_RESPONDER;
+    this.state.touchable.responderID = dispatchID;
+    this._receiveSignal(Signals.RESPONDER_GRANT, e);
+    let delayMS =
+      this.touchableGetHighlightDelayMS !== undefined
+        ? Math.max(this.touchableGetHighlightDelayMS(), 0)
+        : HIGHLIGHT_DELAY_MS;
+    delayMS = isNaN(delayMS) ? HIGHLIGHT_DELAY_MS : delayMS;
+    if (delayMS !== 0) {
+      this.touchableDelayTimeout = setTimeout(
+        this._handleDelay.bind(this, e),
+        delayMS,
+      );
+    } else {
+      this._handleDelay(e);
+    }
+
+    let longDelayMS =
+      this.touchableGetLongPressDelayMS !== undefined
+        ? Math.max(this.touchableGetLongPressDelayMS(), 10)
+        : LONG_PRESS_DELAY_MS;
+    longDelayMS = isNaN(longDelayMS) ? LONG_PRESS_DELAY_MS : longDelayMS;
+    this.longPressDelayTimeout = setTimeout(
+      this._handleLongDelay.bind(this, e),
+      longDelayMS + delayMS,
+    );
+  },
+
+  /**
+   * Place as callback for a DOM element's `onResponderRelease` event.
+   */
+  touchableHandleResponderRelease: function(e: PressEvent) {
+    this.pressInLocation = null;
+    this._receiveSignal(Signals.RESPONDER_RELEASE, e);
+  },
+
+  /**
+   * Place as callback for a DOM element's `onResponderTerminate` event.
+   */
+  touchableHandleResponderTerminate: function(e: PressEvent) {
+    this.pressInLocation = null;
+    this._receiveSignal(Signals.RESPONDER_TERMINATED, e);
+  },
+
+  /**
+   * Place as callback for a DOM element's `onResponderMove` event.
+   */
+  touchableHandleResponderMove: function(e: PressEvent) {
+    // Measurement may not have returned yet.
+    if (!this.state.touchable.positionOnActivate) {
+      return;
+    }
+
+    const positionOnActivate = this.state.touchable.positionOnActivate;
+    const dimensionsOnActivate = this.state.touchable.dimensionsOnActivate;
+    const pressRectOffset = this.touchableGetPressRectOffset
+      ? this.touchableGetPressRectOffset()
+      : {
+          left: PRESS_EXPAND_PX,
+          right: PRESS_EXPAND_PX,
+          top: PRESS_EXPAND_PX,
+          bottom: PRESS_EXPAND_PX,
+        };
+
+    let pressExpandLeft = pressRectOffset.left;
+    let pressExpandTop = pressRectOffset.top;
+    let pressExpandRight = pressRectOffset.right;
+    let pressExpandBottom = pressRectOffset.bottom;
+
+    const hitSlop = this.touchableGetHitSlop
+      ? this.touchableGetHitSlop()
+      : null;
+
+    if (hitSlop) {
+      pressExpandLeft += hitSlop.left || 0;
+      pressExpandTop += hitSlop.top || 0;
+      pressExpandRight += hitSlop.right || 0;
+      pressExpandBottom += hitSlop.bottom || 0;
+    }
+
+    const touch = extractSingleTouch(e.nativeEvent);
+    const pageX = touch && touch.pageX;
+    const pageY = touch && touch.pageY;
+
+    if (this.pressInLocation) {
+      const movedDistance = this._getDistanceBetweenPoints(
+        pageX,
+        pageY,
+        this.pressInLocation.pageX,
+        this.pressInLocation.pageY,
+      );
+      if (movedDistance > LONG_PRESS_ALLOWED_MOVEMENT) {
+        this._cancelLongPressDelayTimeout();
+      }
+    }
+
+    const isTouchWithinActive =
+      pageX > positionOnActivate.left - pressExpandLeft &&
+      pageY > positionOnActivate.top - pressExpandTop &&
+      pageX <
+        positionOnActivate.left +
+          dimensionsOnActivate.width +
+          pressExpandRight &&
+      pageY <
+        positionOnActivate.top +
+          dimensionsOnActivate.height +
+          pressExpandBottom;
+    if (isTouchWithinActive) {
+      const prevState = this.state.touchable.touchState;
+      this._receiveSignal(Signals.ENTER_PRESS_RECT, e);
+      const curState = this.state.touchable.touchState;
+      if (
+        curState === States.RESPONDER_INACTIVE_PRESS_IN &&
+        prevState !== States.RESPONDER_INACTIVE_PRESS_IN
+      ) {
+        // fix for t7967420
+        this._cancelLongPressDelayTimeout();
+      }
+    } else {
+      this._cancelLongPressDelayTimeout();
+      this._receiveSignal(Signals.LEAVE_PRESS_RECT, e);
+    }
+  },
+
+  /**
+   * Invoked when the item receives focus. Mixers might override this to
+   * visually distinguish the `VisualRect` so that the user knows that it
+   * currently has the focus. Most platforms only support a single element being
+   * focused at a time, in which case there may have been a previously focused
+   * element that was blurred just prior to this. This can be overridden when
+   * using `Touchable.Mixin.withoutDefaultFocusAndBlur`.
+   */
+  touchableHandleFocus: function(e: Event) {
+    this.props.onFocus && this.props.onFocus(e);
+  },
+
+  /**
+   * Invoked when the item loses focus. Mixers might override this to
+   * visually distinguish the `VisualRect` so that the user knows that it
+   * no longer has focus. Most platforms only support a single element being
+   * focused at a time, in which case the focus may have moved to another.
+   * This can be overridden when using
+   * `Touchable.Mixin.withoutDefaultFocusAndBlur`.
+   */
+  touchableHandleBlur: function(e: Event) {
+    this.props.onBlur && this.props.onBlur(e);
+  },
+
+  // ==== Abstract Application Callbacks ====
+
+  /**
+   * Invoked when the item should be highlighted. Mixers should implement this
+   * to visually distinguish the `VisualRect` so that the user knows that
+   * releasing a touch will result in a "selection" (analog to click).
+   *
+   * @abstract
+   * touchableHandleActivePressIn: function,
+   */
+
+  /**
+   * Invoked when the item is "active" (in that it is still eligible to become
+   * a "select") but the touch has left the `PressRect`. Usually the mixer will
+   * want to unhighlight the `VisualRect`. If the user (while pressing) moves
+   * back into the `PressRect` `touchableHandleActivePressIn` will be invoked
+   * again and the mixer should probably highlight the `VisualRect` again. This
+   * event will not fire on an `touchEnd/mouseUp` event, only move events while
+   * the user is depressing the mouse/touch.
+   *
+   * @abstract
+   * touchableHandleActivePressOut: function
+   */
+
+  /**
+   * Invoked when the item is "selected" - meaning the interaction ended by
+   * letting up while the item was either in the state
+   * `RESPONDER_ACTIVE_PRESS_IN` or `RESPONDER_INACTIVE_PRESS_IN`.
+   *
+   * @abstract
+   * touchableHandlePress: function
+   */
+
+  /**
+   * Invoked when the item is long pressed - meaning the interaction ended by
+   * letting up while the item was in `RESPONDER_ACTIVE_LONG_PRESS_IN`. If
+   * `touchableHandleLongPress` is *not* provided, `touchableHandlePress` will
+   * be called as it normally is. If `touchableHandleLongPress` is provided, by
+   * default any `touchableHandlePress` callback will not be invoked. To
+   * override this default behavior, override `touchableLongPressCancelsPress`
+   * to return false. As a result, `touchableHandlePress` will be called when
+   * lifting up, even if `touchableHandleLongPress` has also been called.
+   *
+   * @abstract
+   * touchableHandleLongPress: function
+   */
+
+  /**
+   * Returns the number of millis to wait before triggering a highlight.
+   *
+   * @abstract
+   * touchableGetHighlightDelayMS: function
+   */
+
+  /**
+   * Returns the amount to extend the `HitRect` into the `PressRect`. Positive
+   * numbers mean the size expands outwards.
+   *
+   * @abstract
+   * touchableGetPressRectOffset: function
+   */
+
+  // ==== Internal Logic ====
+
+  /**
+   * Measures the `HitRect` node on activation. The Bounding rectangle is with
+   * respect to viewport - not page, so adding the `pageXOffset/pageYOffset`
+   * should result in points that are in the same coordinate system as an
+   * event's `globalX/globalY` data values.
+   *
+   * - Consider caching this for the lifetime of the component, or possibly
+   *   being able to share this cache between any `ScrollMap` view.
+   *
+   * @sideeffects
+   * @private
+   */
+  _remeasureMetricsOnActivation: function() {
+    const responderID = this.state.touchable.responderID;
+    if (responderID == null) {
+      return;
+    }
+
+    if (typeof responderID === 'number') {
+      UIManager.measure(responderID, this._handleQueryLayout);
+    } else {
+      responderID.measure(this._handleQueryLayout);
+    }
+  },
+
+  _handleQueryLayout: function(
+    l: number,
+    t: number,
+    w: number,
+    h: number,
+    globalX: number,
+    globalY: number,
+  ) {
+    //don't do anything UIManager failed to measure node
+    if (!l && !t && !w && !h && !globalX && !globalY) {
+      return;
+    }
+    this.state.touchable.positionOnActivate &&
+      Position.release(this.state.touchable.positionOnActivate);
+    this.state.touchable.dimensionsOnActivate &&
+      BoundingDimensions.release(this.state.touchable.dimensionsOnActivate);
+    this.state.touchable.positionOnActivate = Position.getPooled(
+      globalX,
+      globalY,
+    );
+    this.state.touchable.dimensionsOnActivate = BoundingDimensions.getPooled(
+      w,
+      h,
+    );
+  },
+
+  _handleDelay: function(e: PressEvent) {
+    this.touchableDelayTimeout = null;
+    this._receiveSignal(Signals.DELAY, e);
+  },
+
+  _handleLongDelay: function(e: PressEvent) {
+    this.longPressDelayTimeout = null;
+    const curState = this.state.touchable.touchState;
+    if (
+      curState === States.RESPONDER_ACTIVE_PRESS_IN ||
+      curState === States.RESPONDER_ACTIVE_LONG_PRESS_IN
+    ) {
+      this._receiveSignal(Signals.LONG_PRESS_DETECTED, e);
+    }
+  },
+
+  /**
+   * Receives a state machine signal, performs side effects of the transition
+   * and stores the new state. Validates the transition as well.
+   *
+   * @param {Signals} signal State machine signal.
+   * @throws Error if invalid state transition or unrecognized signal.
+   * @sideeffects
+   */
+  _receiveSignal: function(signal: Signal, e: PressEvent) {
+    const responderID = this.state.touchable.responderID;
+    const curState = this.state.touchable.touchState;
+    const nextState = Transitions[curState] && Transitions[curState][signal];
+    if (!responderID && signal === Signals.RESPONDER_RELEASE) {
+      return;
+    }
+    if (!nextState) {
+      throw new Error(
+        'Unrecognized signal `' +
+          signal +
+          '` or state `' +
+          curState +
+          '` for Touchable responder `' +
+          typeof this.state.touchable.responderID ===
+        'number'
+          ? this.state.touchable.responderID
+          : 'host component' + '`',
+      );
+    }
+    if (nextState === States.ERROR) {
+      throw new Error(
+        'Touchable cannot transition from `' +
+          curState +
+          '` to `' +
+          signal +
+          '` for responder `' +
+          typeof this.state.touchable.responderID ===
+        'number'
+          ? this.state.touchable.responderID
+          : '<<host component>>' + '`',
+      );
+    }
+    if (curState !== nextState) {
+      this._performSideEffectsForTransition(curState, nextState, signal, e);
+      this.state.touchable.touchState = nextState;
+    }
+  },
+
+  _cancelLongPressDelayTimeout: function() {
+    this.longPressDelayTimeout && clearTimeout(this.longPressDelayTimeout);
+    this.longPressDelayTimeout = null;
+  },
+
+  _isHighlight: function(state: State): boolean {
+    return (
+      state === States.RESPONDER_ACTIVE_PRESS_IN ||
+      state === States.RESPONDER_ACTIVE_LONG_PRESS_IN
+    );
+  },
+
+  _savePressInLocation: function(e: PressEvent) {
+    const touch = extractSingleTouch(e.nativeEvent);
+    const pageX = touch && touch.pageX;
+    const pageY = touch && touch.pageY;
+    const locationX = touch && touch.locationX;
+    const locationY = touch && touch.locationY;
+    this.pressInLocation = {pageX, pageY, locationX, locationY};
+  },
+
+  _getDistanceBetweenPoints: function(
+    aX: number,
+    aY: number,
+    bX: number,
+    bY: number,
+  ): number {
+    const deltaX = aX - bX;
+    const deltaY = aY - bY;
+    return Math.sqrt(deltaX * deltaX + deltaY * deltaY);
+  },
+
+  /**
+   * Will perform a transition between touchable states, and identify any
+   * highlighting or unhighlighting that must be performed for this particular
+   * transition.
+   *
+   * @param {States} curState Current Touchable state.
+   * @param {States} nextState Next Touchable state.
+   * @param {Signal} signal Signal that triggered the transition.
+   * @param {Event} e Native event.
+   * @sideeffects
+   */
+  _performSideEffectsForTransition: function(
+    curState: State,
+    nextState: State,
+    signal: Signal,
+    e: PressEvent,
+  ) {
+    const curIsHighlight = this._isHighlight(curState);
+    const newIsHighlight = this._isHighlight(nextState);
+
+    const isFinalSignal =
+      signal === Signals.RESPONDER_TERMINATED ||
+      signal === Signals.RESPONDER_RELEASE;
+
+    if (isFinalSignal) {
+      this._cancelLongPressDelayTimeout();
+    }
+
+    const isInitialTransition =
+      curState === States.NOT_RESPONDER &&
+      nextState === States.RESPONDER_INACTIVE_PRESS_IN;
+
+    const isActiveTransition = !IsActive[curState] && IsActive[nextState];
+    if (isInitialTransition || isActiveTransition) {
+      this._remeasureMetricsOnActivation();
+    }
+
+    if (IsPressingIn[curState] && signal === Signals.LONG_PRESS_DETECTED) {
+      this.touchableHandleLongPress && this.touchableHandleLongPress(e);
+    }
+
+    if (newIsHighlight && !curIsHighlight) {
+      this._startHighlight(e);
+    } else if (!newIsHighlight && curIsHighlight) {
+      this._endHighlight(e);
+    }
+
+    if (IsPressingIn[curState] && signal === Signals.RESPONDER_RELEASE) {
+      const hasLongPressHandler = !!this.props.onLongPress;
+      const pressIsLongButStillCallOnPress =
+        IsLongPressingIn[curState] && // We *are* long pressing.. // But either has no long handler
+        (!hasLongPressHandler || !this.touchableLongPressCancelsPress()); // or we're told to ignore it.
+
+      const shouldInvokePress =
+        !IsLongPressingIn[curState] || pressIsLongButStillCallOnPress;
+      if (shouldInvokePress && this.touchableHandlePress) {
+        if (!newIsHighlight && !curIsHighlight) {
+          // we never highlighted because of delay, but we should highlight now
+          this._startHighlight(e);
+          this._endHighlight(e);
+        }
+        if (Platform.OS === 'android' && !this.props.touchSoundDisabled) {
+          SoundManager.playTouchSound();
+        }
+        this.touchableHandlePress(e);
+      }
+    }
+
+    this.touchableDelayTimeout && clearTimeout(this.touchableDelayTimeout);
+    this.touchableDelayTimeout = null;
+  },
+
+  _startHighlight: function(e: PressEvent) {
+    this._savePressInLocation(e);
+    this.touchableHandleActivePressIn && this.touchableHandleActivePressIn(e);
+  },
+
+  _endHighlight: function(e: PressEvent) {
+    if (this.touchableHandleActivePressOut) {
+      if (
+        this.touchableGetPressOutDelayMS &&
+        this.touchableGetPressOutDelayMS()
+      ) {
+        this.pressOutDelayTimeout = setTimeout(() => {
+          this.touchableHandleActivePressOut(e);
+        }, this.touchableGetPressOutDelayMS());
+      } else {
+        this.touchableHandleActivePressOut(e);
+      }
+    }
+  },
+
+  withoutDefaultFocusAndBlur: ({}: $TEMPORARY$object<{||}>),
+};
+
+/**
+ * Provide an optional version of the mixin where `touchableHandleFocus` and
+ * `touchableHandleBlur` can be overridden. This allows appropriate defaults to
+ * be set on TV platforms, without breaking existing implementations of
+ * `Touchable`.
+ */
+const {
+  touchableHandleFocus,
+  touchableHandleBlur,
+  ...TouchableMixinWithoutDefaultFocusAndBlur
+} = TouchableMixin;
+TouchableMixin.withoutDefaultFocusAndBlur = TouchableMixinWithoutDefaultFocusAndBlur;
+
+const Touchable = {
+  Mixin: TouchableMixin,
+  TOUCH_TARGET_DEBUG: false, // Highlights all touchable targets. Toggle with Inspector.
+  /**
+   * Renders a debugging overlay to visualize touch target with hitSlop (might not work on Android).
+   */
+  renderDebugView: ({
+    color,
+    hitSlop,
+  }: {
+    color: string | number,
+    hitSlop: EdgeInsetsProp,
+    ...
+  }): null | React.Node => {
+    if (!Touchable.TOUCH_TARGET_DEBUG) {
+      return null;
+    }
+    if (!__DEV__) {
+      throw Error(
+        'Touchable.TOUCH_TARGET_DEBUG should not be enabled in prod!',
+      );
+    }
+    const debugHitSlopStyle = {};
+    hitSlop = hitSlop || {top: 0, bottom: 0, left: 0, right: 0};
+    for (const key in hitSlop) {
+      debugHitSlopStyle[key] = -hitSlop[key];
+    }
+    const normalizedColor = normalizeColor(color);
+    if (typeof normalizedColor !== 'number') {
+      return null;
+    }
+    const hexColor =
+      '#' + ('00000000' + normalizedColor.toString(16)).substr(-8);
+    return (
+      <View
+        pointerEvents="none"
+        style={[
+          styles.debug,
+          /* $FlowFixMe(>=0.111.0 site=react_native_fb) This comment suppresses
+           * an error found when Flow v0.111 was deployed. To see the error,
+           * delete this comment and run Flow. */
+          {
+            borderColor: hexColor.slice(0, -2) + '55', // More opaque
+            backgroundColor: hexColor.slice(0, -2) + '0F', // Less opaque
+            ...debugHitSlopStyle,
+          },
+        ]}
+      />
+    );
+  },
+};
+
+const styles = StyleSheet.create({
+  debug: {
+    position: 'absolute',
+    borderWidth: 1,
+    borderStyle: 'dashed',
+  },
+});
+
+module.exports = Touchable;

node_modules/react-native/Libraries/Components/Touchable/TouchableBounce.js

@@ -0,0 +1,218 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+'use strict';
+
+import Pressability, {
+  type PressabilityConfig,
+} from '../../Pressability/Pressability';
+import {PressabilityDebugView} from '../../Pressability/PressabilityDebug';
+import type {ViewStyleProp} from '../../StyleSheet/StyleSheet';
+import TVTouchable from './TVTouchable';
+import typeof TouchableWithoutFeedback from './TouchableWithoutFeedback';
+import {Animated, Platform} from 'react-native';
+import * as React from 'react';
+
+type Props = $ReadOnly<{|
+  ...React.ElementConfig<TouchableWithoutFeedback>,
+
+  onPressAnimationComplete?: ?() => void,
+  onPressWithCompletion?: ?(callback: () => void) => void,
+  releaseBounciness?: ?number,
+  releaseVelocity?: ?number,
+  style?: ?ViewStyleProp,
+
+  hostRef: React.Ref<typeof Animated.View>,
+|}>;
+
+type State = $ReadOnly<{|
+  pressability: Pressability,
+  scale: Animated.Value,
+|}>;
+
+class TouchableBounce extends React.Component<Props, State> {
+  _tvTouchable: ?TVTouchable;
+
+  state: State = {
+    pressability: new Pressability(this._createPressabilityConfig()),
+    scale: new Animated.Value(1),
+  };
+
+  _createPressabilityConfig(): PressabilityConfig {
+    return {
+      cancelable: !this.props.rejectResponderTermination,
+      disabled: this.props.disabled,
+      hitSlop: this.props.hitSlop,
+      delayLongPress: this.props.delayLongPress,
+      delayPressIn: this.props.delayPressIn,
+      delayPressOut: this.props.delayPressOut,
+      minPressDuration: 0,
+      pressRectOffset: this.props.pressRetentionOffset,
+      android_disableSound: this.props.touchSoundDisabled,
+      onBlur: event => {
+        if (Platform.isTV) {
+          this._bounceTo(1, 0.4, 0);
+        }
+        if (this.props.onBlur != null) {
+          this.props.onBlur(event);
+        }
+      },
+      onFocus: event => {
+        if (Platform.isTV) {
+          this._bounceTo(0.93, 0.1, 0);
+        }
+        if (this.props.onFocus != null) {
+          this.props.onFocus(event);
+        }
+      },
+      onLongPress: event => {
+        if (this.props.onLongPress != null) {
+          this.props.onLongPress(event);
+        }
+      },
+      onPress: event => {
+        const {onPressAnimationComplete, onPressWithCompletion} = this.props;
+        const releaseBounciness = this.props.releaseBounciness ?? 10;
+        const releaseVelocity = this.props.releaseVelocity ?? 10;
+
+        if (onPressWithCompletion != null) {
+          onPressWithCompletion(() => {
+            this.state.scale.setValue(0.93);
+            this._bounceTo(
+              1,
+              releaseVelocity,
+              releaseBounciness,
+              onPressAnimationComplete,
+            );
+          });
+          return;
+        }
+
+        this._bounceTo(
+          1,
+          releaseVelocity,
+          releaseBounciness,
+          onPressAnimationComplete,
+        );
+        if (this.props.onPress != null) {
+          this.props.onPress(event);
+        }
+      },
+      onPressIn: event => {
+        this._bounceTo(0.93, 0.1, 0);
+        if (this.props.onPressIn != null) {
+          this.props.onPressIn(event);
+        }
+      },
+      onPressOut: event => {
+        this._bounceTo(1, 0.4, 0);
+        if (this.props.onPressOut != null) {
+          this.props.onPressOut(event);
+        }
+      },
+    };
+  }
+
+  _bounceTo(
+    toValue: number,
+    velocity: number,
+    bounciness: number,
+    callback?: ?() => void,
+  ) {
+    Animated.spring(this.state.scale, {
+      toValue,
+      velocity,
+      bounciness,
+      useNativeDriver: true,
+    }).start(callback);
+  }
+
+  render(): React.Node {
+    // BACKWARD-COMPATIBILITY: Focus and blur events were never supported before
+    // adopting `Pressability`, so preserve that behavior.
+    const {
+      onBlur,
+      onFocus,
+      ...eventHandlersWithoutBlurAndFocus
+    } = this.state.pressability.getEventHandlers();
+
+    return (
+      <Animated.View
+        style={[{transform: [{scale: this.state.scale}]}, this.props.style]}
+        accessible={this.props.accessible !== false}
+        accessibilityLabel={this.props.accessibilityLabel}
+        accessibilityHint={this.props.accessibilityHint}
+        accessibilityRole={this.props.accessibilityRole}
+        accessibilityState={this.props.accessibilityState}
+        accessibilityActions={this.props.accessibilityActions}
+        onAccessibilityAction={this.props.onAccessibilityAction}
+        accessibilityValue={this.props.accessibilityValue}
+        importantForAccessibility={this.props.importantForAccessibility}
+        accessibilityLiveRegion={this.props.accessibilityLiveRegion}
+        accessibilityViewIsModal={this.props.accessibilityViewIsModal}
+        accessibilityElementsHidden={this.props.accessibilityElementsHidden}
+        nativeID={this.props.nativeID}
+        testID={this.props.testID}
+        hitSlop={this.props.hitSlop}
+        focusable={
+          this.props.focusable !== false &&
+          this.props.onPress !== undefined &&
+          !this.props.disabled
+        }
+        ref={this.props.hostRef}
+        {...eventHandlersWithoutBlurAndFocus}>
+        {this.props.children}
+        {__DEV__ ? (
+          <PressabilityDebugView color="orange" hitSlop={this.props.hitSlop} />
+        ) : null}
+      </Animated.View>
+    );
+  }
+
+  componentDidMount(): void {
+    if (Platform.isTV) {
+      this._tvTouchable = new TVTouchable(this, {
+        getDisabled: () => this.props.disabled === true,
+        onBlur: event => {
+          if (this.props.onBlur != null) {
+            this.props.onBlur(event);
+          }
+        },
+        onFocus: event => {
+          if (this.props.onFocus != null) {
+            this.props.onFocus(event);
+          }
+        },
+        onPress: event => {
+          if (this.props.onPress != null) {
+            this.props.onPress(event);
+          }
+        },
+      });
+    }
+  }
+
+  componentDidUpdate(prevProps: Props, prevState: State) {
+    this.state.pressability.configure(this._createPressabilityConfig());
+  }
+
+  componentWillUnmount(): void {
+    if (Platform.isTV) {
+      if (this._tvTouchable != null) {
+        this._tvTouchable.destroy();
+      }
+    }
+    this.state.pressability.reset();
+  }
+}
+
+module.exports = (React.forwardRef((props, hostRef) => (
+  <TouchableBounce {...props} hostRef={hostRef} />
+)): React.ComponentType<$ReadOnly<$Diff<Props, {|hostRef: mixed|}>>>);

node_modules/react-native/Libraries/Components/Touchable/TouchableHighlight.js

@@ -0,0 +1,384 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+'use strict';
+
+import Pressability, {
+  type PressabilityConfig,
+} from '../../Pressability/Pressability';
+import {PressabilityDebugView} from '../../Pressability/PressabilityDebug';
+import StyleSheet, {type ViewStyleProp} from '../../StyleSheet/StyleSheet';
+import type {ColorValue} from '../../StyleSheet/StyleSheetTypes';
+import TVTouchable from './TVTouchable';
+import typeof TouchableWithoutFeedback from './TouchableWithoutFeedback';
+import Platform from '../../Utilities/Platform';
+import View from '../../Components/View/View';
+import * as React from 'react';
+
+type AndroidProps = $ReadOnly<{|
+  nextFocusDown?: ?number,
+  nextFocusForward?: ?number,
+  nextFocusLeft?: ?number,
+  nextFocusRight?: ?number,
+  nextFocusUp?: ?number,
+|}>;
+
+type IOSProps = $ReadOnly<{|
+  hasTVPreferredFocus?: ?boolean,
+|}>;
+
+type Props = $ReadOnly<{|
+  ...React.ElementConfig<TouchableWithoutFeedback>,
+  ...AndroidProps,
+  ...IOSProps,
+
+  activeOpacity?: ?number,
+  underlayColor?: ?ColorValue,
+  style?: ?ViewStyleProp,
+  onShowUnderlay?: ?() => void,
+  onHideUnderlay?: ?() => void,
+  testOnly_pressed?: ?boolean,
+
+  hostRef: React.Ref<typeof View>,
+|}>;
+
+type ExtraStyles = $ReadOnly<{|
+  child: ViewStyleProp,
+  underlay: ViewStyleProp,
+|}>;
+
+type State = $ReadOnly<{|
+  pressability: Pressability,
+  extraStyles: ?ExtraStyles,
+|}>;
+
+/**
+ * A wrapper for making views respond properly to touches.
+ * On press down, the opacity of the wrapped view is decreased, which allows
+ * the underlay color to show through, darkening or tinting the view.
+ *
+ * The underlay comes from wrapping the child in a new View, which can affect
+ * layout, and sometimes cause unwanted visual artifacts if not used correctly,
+ * for example if the backgroundColor of the wrapped view isn't explicitly set
+ * to an opaque color.
+ *
+ * TouchableHighlight must have one child (not zero or more than one).
+ * If you wish to have several child components, wrap them in a View.
+ *
+ * Example:
+ *
+ * ```
+ * renderButton: function() {
+ *   return (
+ *     <TouchableHighlight onPress={this._onPressButton}>
+ *       <Image
+ *         style={styles.button}
+ *         source={require('./myButton.png')}
+ *       />
+ *     </TouchableHighlight>
+ *   );
+ * },
+ * ```
+ *
+ *
+ * ### Example
+ *
+ * ```ReactNativeWebPlayer
+ * import React, { Component } from 'react'
+ * import {
+ *   AppRegistry,
+ *   StyleSheet,
+ *   TouchableHighlight,
+ *   Text,
+ *   View,
+ * } from 'react-native'
+ *
+ * class App extends Component {
+ *   constructor(props) {
+ *     super(props)
+ *     this.state = { count: 0 }
+ *   }
+ *
+ *   onPress = () => {
+ *     this.setState({
+ *       count: this.state.count+1
+ *     })
+ *   }
+ *
+ *  render() {
+ *     return (
+ *       <View style={styles.container}>
+ *         <TouchableHighlight
+ *          style={styles.button}
+ *          onPress={this.onPress}
+ *         >
+ *          <Text> Touch Here </Text>
+ *         </TouchableHighlight>
+ *         <View style={[styles.countContainer]}>
+ *           <Text style={[styles.countText]}>
+ *             { this.state.count !== 0 ? this.state.count: null}
+ *           </Text>
+ *         </View>
+ *       </View>
+ *     )
+ *   }
+ * }
+ *
+ * const styles = StyleSheet.create({
+ *   container: {
+ *     flex: 1,
+ *     justifyContent: 'center',
+ *     paddingHorizontal: 10
+ *   },
+ *   button: {
+ *     alignItems: 'center',
+ *     backgroundColor: '#DDDDDD',
+ *     padding: 10
+ *   },
+ *   countContainer: {
+ *     alignItems: 'center',
+ *     padding: 10
+ *   },
+ *   countText: {
+ *     color: '#FF00FF'
+ *   }
+ * })
+ *
+ * AppRegistry.registerComponent('App', () => App)
+ * ```
+ *
+ */
+class TouchableHighlight extends React.Component<Props, State> {
+  _hideTimeout: ?TimeoutID;
+  _isMounted: boolean = false;
+  _tvTouchable: ?TVTouchable;
+
+  state: State = {
+    pressability: new Pressability(this._createPressabilityConfig()),
+    extraStyles:
+      this.props.testOnly_pressed === true ? this._createExtraStyles() : null,
+  };
+
+  _createPressabilityConfig(): PressabilityConfig {
+    return {
+      cancelable: !this.props.rejectResponderTermination,
+      disabled: this.props.disabled,
+      hitSlop: this.props.hitSlop,
+      delayLongPress: this.props.delayLongPress,
+      delayPressIn: this.props.delayPressIn,
+      delayPressOut: this.props.delayPressOut,
+      minPressDuration: 0,
+      pressRectOffset: this.props.pressRetentionOffset,
+      android_disableSound: this.props.touchSoundDisabled,
+      onBlur: event => {
+        if (Platform.isTV) {
+          this._hideUnderlay();
+        }
+        if (this.props.onBlur != null) {
+          this.props.onBlur(event);
+        }
+      },
+      onFocus: event => {
+        if (Platform.isTV) {
+          this._showUnderlay();
+        }
+        if (this.props.onFocus != null) {
+          this.props.onFocus(event);
+        }
+      },
+      onLongPress: event => {
+        if (this.props.onLongPress != null) {
+          this.props.onLongPress(event);
+        }
+      },
+      onPress: event => {
+        if (this._hideTimeout != null) {
+          clearTimeout(this._hideTimeout);
+        }
+        if (!Platform.isTV) {
+          this._showUnderlay();
+          this._hideTimeout = setTimeout(() => {
+            this._hideUnderlay();
+          }, this.props.delayPressOut ?? 0);
+        }
+        if (this.props.onPress != null) {
+          this.props.onPress(event);
+        }
+      },
+      onPressIn: event => {
+        if (this._hideTimeout != null) {
+          clearTimeout(this._hideTimeout);
+          this._hideTimeout = null;
+        }
+        this._showUnderlay();
+        if (this.props.onPressIn != null) {
+          this.props.onPressIn(event);
+        }
+      },
+      onPressOut: event => {
+        if (this._hideTimeout == null) {
+          this._hideUnderlay();
+        }
+        if (this.props.onPressOut != null) {
+          this.props.onPressOut(event);
+        }
+      },
+    };
+  }
+
+  _createExtraStyles(): ExtraStyles {
+    return {
+      child: {opacity: this.props.activeOpacity ?? 0.85},
+      underlay: {
+        backgroundColor:
+          this.props.underlayColor === undefined
+            ? 'black'
+            : this.props.underlayColor,
+      },
+    };
+  }
+
+  _showUnderlay(): void {
+    if (!this._isMounted || !this._hasPressHandler()) {
+      return;
+    }
+    this.setState({extraStyles: this._createExtraStyles()});
+    if (this.props.onShowUnderlay != null) {
+      this.props.onShowUnderlay();
+    }
+  }
+
+  _hideUnderlay(): void {
+    if (this._hideTimeout != null) {
+      clearTimeout(this._hideTimeout);
+      this._hideTimeout = null;
+    }
+    if (this.props.testOnly_pressed === true) {
+      return;
+    }
+    if (this._hasPressHandler()) {
+      this.setState({extraStyles: null});
+      if (this.props.onHideUnderlay != null) {
+        this.props.onHideUnderlay();
+      }
+    }
+  }
+
+  _hasPressHandler(): boolean {
+    return (
+      this.props.onPress != null ||
+      this.props.onPressIn != null ||
+      this.props.onPressOut != null ||
+      this.props.onLongPress != null
+    );
+  }
+
+  render(): React.Node {
+    const child = React.Children.only(this.props.children);
+
+    // BACKWARD-COMPATIBILITY: Focus and blur events were never supported before
+    // adopting `Pressability`, so preserve that behavior.
+    const {
+      onBlur,
+      onFocus,
+      ...eventHandlersWithoutBlurAndFocus
+    } = this.state.pressability.getEventHandlers();
+
+    return (
+      <View
+        accessible={this.props.accessible !== false}
+        accessibilityLabel={this.props.accessibilityLabel}
+        accessibilityHint={this.props.accessibilityHint}
+        accessibilityRole={this.props.accessibilityRole}
+        accessibilityState={this.props.accessibilityState}
+        accessibilityValue={this.props.accessibilityValue}
+        accessibilityActions={this.props.accessibilityActions}
+        onAccessibilityAction={this.props.onAccessibilityAction}
+        importantForAccessibility={this.props.importantForAccessibility}
+        accessibilityLiveRegion={this.props.accessibilityLiveRegion}
+        accessibilityViewIsModal={this.props.accessibilityViewIsModal}
+        accessibilityElementsHidden={this.props.accessibilityElementsHidden}
+        style={StyleSheet.compose(
+          this.props.style,
+          this.state.extraStyles?.underlay,
+        )}
+        onLayout={this.props.onLayout}
+        hitSlop={this.props.hitSlop}
+        hasTVPreferredFocus={this.props.hasTVPreferredFocus}
+        nextFocusDown={this.props.nextFocusDown}
+        nextFocusForward={this.props.nextFocusForward}
+        nextFocusLeft={this.props.nextFocusLeft}
+        nextFocusRight={this.props.nextFocusRight}
+        nextFocusUp={this.props.nextFocusUp}
+        focusable={
+          this.props.focusable !== false && this.props.onPress !== undefined
+        }
+        nativeID={this.props.nativeID}
+        testID={this.props.testID}
+        ref={this.props.hostRef}
+        {...eventHandlersWithoutBlurAndFocus}>
+        {React.cloneElement(child, {
+          style: StyleSheet.compose(
+            child.props.style,
+            this.state.extraStyles?.child,
+          ),
+        })}
+        {__DEV__ ? (
+          <PressabilityDebugView color="green" hitSlop={this.props.hitSlop} />
+        ) : null}
+      </View>
+    );
+  }
+
+  componentDidMount(): void {
+    this._isMounted = true;
+    if (Platform.isTV) {
+      this._tvTouchable = new TVTouchable(this, {
+        getDisabled: () => this.props.disabled === true,
+        onBlur: event => {
+          if (this.props.onBlur != null) {
+            this.props.onBlur(event);
+          }
+        },
+        onFocus: event => {
+          if (this.props.onFocus != null) {
+            this.props.onFocus(event);
+          }
+        },
+        onPress: event => {
+          if (this.props.onPress != null) {
+            this.props.onPress(event);
+          }
+        },
+      });
+    }
+  }
+
+  componentDidUpdate(prevProps: Props, prevState: State) {
+    this.state.pressability.configure(this._createPressabilityConfig());
+  }
+
+  componentWillUnmount(): void {
+    this._isMounted = false;
+    if (this._hideTimeout != null) {
+      clearTimeout(this._hideTimeout);
+    }
+    if (Platform.isTV) {
+      if (this._tvTouchable != null) {
+        this._tvTouchable.destroy();
+      }
+    }
+    this.state.pressability.reset();
+  }
+}
+
+module.exports = (React.forwardRef((props, hostRef) => (
+  <TouchableHighlight {...props} hostRef={hostRef} />
+)): React.ComponentType<$ReadOnly<$Diff<Props, {|hostRef: mixed|}>>>);

node_modules/react-native/Libraries/Components/Touchable/TouchableNativeFeedback.js

@@ -0,0 +1,348 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+'use strict';
+
+import Pressability, {
+  type PressabilityConfig,
+} from '../../Pressability/Pressability';
+import {PressabilityDebugView} from '../../Pressability/PressabilityDebug';
+import TVTouchable from './TVTouchable';
+import typeof TouchableWithoutFeedback from './TouchableWithoutFeedback';
+import {Commands} from 'react-native/Libraries/Components/View/ViewNativeComponent';
+import ReactNative from 'react-native/Libraries/Renderer/shims/ReactNative';
+import type {PressEvent} from 'react-native/Libraries/Types/CoreEventTypes';
+import Platform from '../../Utilities/Platform';
+import View from '../../Components/View/View';
+import processColor from '../../StyleSheet/processColor';
+import * as React from 'react';
+import invariant from 'invariant';
+
+type Props = $ReadOnly<{|
+  ...React.ElementConfig<TouchableWithoutFeedback>,
+
+  /**
+   * Determines the type of background drawable that's going to be used to
+   * display feedback. It takes an object with `type` property and extra data
+   * depending on the `type`. It's recommended to use one of the static
+   * methods to generate that dictionary.
+   */
+  background?: ?(
+    | $ReadOnly<{|
+        type: 'ThemeAttrAndroid',
+        attribute:
+          | 'selectableItemBackground'
+          | 'selectableItemBackgroundBorderless',
+        rippleRadius: ?number,
+      |}>
+    | $ReadOnly<{|
+        type: 'RippleAndroid',
+        color: ?number,
+        borderless: boolean,
+        rippleRadius: ?number,
+      |}>
+  ),
+
+  /**
+   * TV preferred focus (see documentation for the View component).
+   */
+  hasTVPreferredFocus?: ?boolean,
+
+  /**
+   * TV next focus down (see documentation for the View component).
+   */
+  nextFocusDown?: ?number,
+
+  /**
+   * TV next focus forward (see documentation for the View component).
+   */
+  nextFocusForward?: ?number,
+
+  /**
+   * TV next focus left (see documentation for the View component).
+   */
+  nextFocusLeft?: ?number,
+
+  /**
+   * TV next focus right (see documentation for the View component).
+   */
+  nextFocusRight?: ?number,
+
+  /**
+   * TV next focus up (see documentation for the View component).
+   */
+  nextFocusUp?: ?number,
+
+  /**
+   * Set to true to add the ripple effect to the foreground of the view, instead
+   * of the background. This is useful if one of your child views has a
+   * background of its own, or you're e.g. displaying images, and you don't want
+   * the ripple to be covered by them.
+   *
+   * Check TouchableNativeFeedback.canUseNativeForeground() first, as this is
+   * only available on Android 6.0 and above. If you try to use this on older
+   * versions, this will fallback to background.
+   */
+  useForeground?: ?boolean,
+|}>;
+
+type State = $ReadOnly<{|
+  pressability: Pressability,
+|}>;
+
+class TouchableNativeFeedback extends React.Component<Props, State> {
+  /**
+   * Creates a value for the `background` prop that uses the Android theme's
+   * default background for selectable elements.
+   */
+  static SelectableBackground: (
+    rippleRadius: ?number,
+  ) => $ReadOnly<{|
+    attribute: 'selectableItemBackground',
+    type: 'ThemeAttrAndroid',
+    rippleRadius: ?number,
+  |}> = (rippleRadius: ?number) => ({
+    type: 'ThemeAttrAndroid',
+    attribute: 'selectableItemBackground',
+    rippleRadius,
+  });
+
+  /**
+   * Creates a value for the `background` prop that uses the Android theme's
+   * default background for borderless selectable elements. Requires API 21+.
+   */
+  static SelectableBackgroundBorderless: (
+    rippleRadius: ?number,
+  ) => $ReadOnly<{|
+    attribute: 'selectableItemBackgroundBorderless',
+    type: 'ThemeAttrAndroid',
+    rippleRadius: ?number,
+  |}> = (rippleRadius: ?number) => ({
+    type: 'ThemeAttrAndroid',
+    attribute: 'selectableItemBackgroundBorderless',
+    rippleRadius,
+  });
+
+  /**
+   * Creates a value for the `background` prop that uses the Android ripple with
+   * the supplied color. If `borderless` is true, the ripple will render outside
+   * of the view bounds. Requires API 21+.
+   */
+  static Ripple: (
+    color: string,
+    borderless: boolean,
+    rippleRadius: ?number,
+  ) => $ReadOnly<{|
+    borderless: boolean,
+    color: ?number,
+    rippleRadius: ?number,
+    type: 'RippleAndroid',
+  |}> = (color: string, borderless: boolean, rippleRadius: ?number) => {
+    const processedColor = processColor(color);
+    invariant(
+      processedColor == null || typeof processedColor === 'number',
+      'Unexpected color given for Ripple color',
+    );
+    return {
+      type: 'RippleAndroid',
+      color: processedColor,
+      borderless,
+      rippleRadius,
+    };
+  };
+
+  /**
+   * Whether `useForeground` is supported.
+   */
+  static canUseNativeForeground: () => boolean = () =>
+    Platform.OS === 'android' && Platform.Version >= 23;
+
+  _tvTouchable: ?TVTouchable;
+
+  state: State = {
+    pressability: new Pressability(this._createPressabilityConfig()),
+  };
+
+  _createPressabilityConfig(): PressabilityConfig {
+    return {
+      cancelable: !this.props.rejectResponderTermination,
+      disabled: this.props.disabled,
+      hitSlop: this.props.hitSlop,
+      delayLongPress: this.props.delayLongPress,
+      delayPressIn: this.props.delayPressIn,
+      delayPressOut: this.props.delayPressOut,
+      minPressDuration: 0,
+      pressRectOffset: this.props.pressRetentionOffset,
+      android_disableSound: this.props.touchSoundDisabled,
+      onLongPress: this.props.onLongPress,
+      onPress: this.props.onPress,
+      onPressIn: event => {
+        if (Platform.OS === 'android') {
+          this._dispatchPressedStateChange(true);
+          this._dispatchHotspotUpdate(event);
+        }
+        if (this.props.onPressIn != null) {
+          this.props.onPressIn(event);
+        }
+      },
+      onPressMove: event => {
+        if (Platform.OS === 'android') {
+          this._dispatchHotspotUpdate(event);
+        }
+      },
+      onPressOut: event => {
+        if (Platform.OS === 'android') {
+          this._dispatchPressedStateChange(false);
+        }
+        if (this.props.onPressOut != null) {
+          this.props.onPressOut(event);
+        }
+      },
+    };
+  }
+
+  _dispatchPressedStateChange(pressed: boolean): void {
+    if (Platform.OS === 'android') {
+      const hostComponentRef = ReactNative.findHostInstance_DEPRECATED(this);
+      if (hostComponentRef == null) {
+        console.warn(
+          'Touchable: Unable to find HostComponent instance. ' +
+            'Has your Touchable component been unmounted?',
+        );
+      } else {
+        Commands.setPressed(hostComponentRef, pressed);
+      }
+    }
+  }
+
+  _dispatchHotspotUpdate(event: PressEvent): void {
+    if (Platform.OS === 'android') {
+      const {locationX, locationY} = event.nativeEvent;
+      const hostComponentRef = ReactNative.findHostInstance_DEPRECATED(this);
+      if (hostComponentRef == null) {
+        console.warn(
+          'Touchable: Unable to find HostComponent instance. ' +
+            'Has your Touchable component been unmounted?',
+        );
+      } else {
+        Commands.hotspotUpdate(
+          hostComponentRef,
+          locationX ?? 0,
+          locationY ?? 0,
+        );
+      }
+    }
+  }
+
+  render(): React.Node {
+    const element = React.Children.only(this.props.children);
+    const children = [element.props.children];
+    if (__DEV__) {
+      if (element.type === View) {
+        children.push(
+          <PressabilityDebugView color="brown" hitSlop={this.props.hitSlop} />,
+        );
+      }
+    }
+
+    // BACKWARD-COMPATIBILITY: Focus and blur events were never supported before
+    // adopting `Pressability`, so preserve that behavior.
+    const {
+      onBlur,
+      onFocus,
+      ...eventHandlersWithoutBlurAndFocus
+    } = this.state.pressability.getEventHandlers();
+
+    return React.cloneElement(
+      element,
+      {
+        ...eventHandlersWithoutBlurAndFocus,
+        ...getBackgroundProp(
+          this.props.background === undefined
+            ? TouchableNativeFeedback.SelectableBackground()
+            : this.props.background,
+          this.props.useForeground === true,
+        ),
+        accessible: this.props.accessible !== false,
+        accessibilityLabel: this.props.accessibilityLabel,
+        accessibilityRole: this.props.accessibilityRole,
+        accessibilityState: this.props.accessibilityState,
+        accessibilityActions: this.props.accessibilityActions,
+        onAccessibilityAction: this.props.onAccessibilityAction,
+        accessibilityValue: this.props.accessibilityValue,
+        importantForAccessibility: this.props.importantForAccessibility,
+        accessibilityLiveRegion: this.props.accessibilityLiveRegion,
+        accessibilityViewIsModal: this.props.accessibilityViewIsModal,
+        accessibilityElementsHidden: this.props.accessibilityElementsHidden,
+        hasTVPreferredFocus: this.props.hasTVPreferredFocus,
+        hitSlop: this.props.hitSlop,
+        focusable:
+          this.props.focusable !== false &&
+          this.props.onPress !== undefined &&
+          !this.props.disabled,
+        nativeID: this.props.nativeID,
+        nextFocusDown: this.props.nextFocusDown,
+        nextFocusForward: this.props.nextFocusForward,
+        nextFocusLeft: this.props.nextFocusLeft,
+        nextFocusRight: this.props.nextFocusRight,
+        nextFocusUp: this.props.nextFocusUp,
+        onLayout: this.props.onLayout,
+        testID: this.props.testID,
+      },
+      ...children,
+    );
+  }
+
+  componentDidMount(): void {
+    if (Platform.isTV) {
+      this._tvTouchable = new TVTouchable(this, {
+        getDisabled: () => this.props.disabled === true,
+        onBlur: event => {
+          if (this.props.onBlur != null) {
+            this.props.onBlur(event);
+          }
+        },
+        onFocus: event => {
+          if (this.props.onFocus != null) {
+            this.props.onFocus(event);
+          }
+        },
+        onPress: event => {
+          if (this.props.onPress != null) {
+            this.props.onPress(event);
+          }
+        },
+      });
+    }
+  }
+
+  componentDidUpdate(prevProps: Props, prevState: State) {
+    this.state.pressability.configure(this._createPressabilityConfig());
+  }
+
+  componentWillUnmount(): void {
+    if (Platform.isTV) {
+      if (this._tvTouchable != null) {
+        this._tvTouchable.destroy();
+      }
+    }
+    this.state.pressability.reset();
+  }
+}
+
+const getBackgroundProp =
+  Platform.OS === 'android'
+    ? (background, useForeground) =>
+        useForeground && TouchableNativeFeedback.canUseNativeForeground()
+          ? {nativeForegroundAndroid: background}
+          : {nativeBackgroundAndroid: background}
+    : (background, useForeground) => null;
+
+module.exports = TouchableNativeFeedback;