yeet

node_modules/react-native-screens/lib/commonjs/createNativeStackNavigator.js

@@ -0,0 +1,318 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _reactNative = require("react-native");
+
+var _reactNativeScreens = require("react-native-screens");
+
+var _reactNavigation = require("react-navigation");
+
+var _reactNavigationStack = require("react-navigation-stack");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function renderComponentOrThunk(componentOrThunk, props) {
+  if (typeof componentOrThunk === 'function') {
+    return componentOrThunk(props);
+  }
+
+  return componentOrThunk;
+}
+
+const REMOVE_ACTION = 'NativeStackNavigator/REMOVE';
+
+class StackView extends _react.default.Component {
+  constructor(...args) {
+    super(...args);
+
+    _defineProperty(this, "_removeScene", route => {
+      this.props.navigation.dispatch({
+        type: REMOVE_ACTION,
+        immediate: true,
+        key: route.key
+      });
+    });
+
+    _defineProperty(this, "_onAppear", (route, descriptor) => {
+      descriptor.options && descriptor.options.onAppear && descriptor.options.onAppear();
+      this.props.navigation.dispatch(_reactNavigation.StackActions.completeTransition({
+        toChildKey: route.key,
+        key: this.props.navigation.state.key
+      }));
+    });
+
+    _defineProperty(this, "_onFinishTransitioning", () => {
+      const {
+        routes
+      } = this.props.navigation.state;
+      const lastRoute = (routes === null || routes === void 0 ? void 0 : routes.length) && routes[routes.length - 1];
+
+      if (lastRoute) {
+        this.props.navigation.dispatch(_reactNavigation.StackActions.completeTransition({
+          toChildKey: lastRoute.key,
+          key: this.props.navigation.state.key
+        }));
+      }
+    });
+
+    _defineProperty(this, "_renderHeaderConfig", (index, route, descriptor) => {
+      const {
+        navigationConfig
+      } = this.props;
+      const {
+        options
+      } = descriptor;
+      const {
+        headerMode
+      } = navigationConfig;
+      const {
+        backButtonInCustomView,
+        direction,
+        headerBackTitle,
+        headerBackTitleStyle,
+        headerBackTitleVisible,
+        headerHideBackButton,
+        headerLargeTitleStyle,
+        headerStyle,
+        headerTintColor,
+        headerTitleStyle,
+        headerTopInsetEnabled = true,
+        hideShadow,
+        largeTitle,
+        statusBarAnimation,
+        statusBarHidden,
+        statusBarStyle,
+        title,
+        translucent
+      } = options;
+      const scene = {
+        index,
+        key: route.key,
+        route,
+        descriptor
+      };
+      const headerOptions = {
+        backButtonInCustomView,
+        backTitle: headerBackTitleVisible === false ? '' : headerBackTitle,
+        backTitleFontFamily: headerBackTitleStyle && headerBackTitleStyle.fontFamily,
+        backTitleFontSize: headerBackTitleStyle && headerBackTitleStyle.fontSize,
+        color: headerTintColor,
+        direction,
+        topInsetEnabled: headerTopInsetEnabled,
+        hideBackButton: headerHideBackButton,
+        hideShadow,
+        largeTitle,
+        largeTitleBackgroundColor: headerLargeTitleStyle && headerLargeTitleStyle.backgroundColor,
+        largeTitleColor: headerLargeTitleStyle && headerLargeTitleStyle.color,
+        largeTitleFontFamily: headerLargeTitleStyle && headerLargeTitleStyle.fontFamily,
+        largeTitleFontSize: headerLargeTitleStyle && headerLargeTitleStyle.fontSize,
+        statusBarAnimation,
+        statusBarHidden,
+        statusBarStyle,
+        title,
+        titleColor: headerTitleStyle && headerTitleStyle.color || headerTintColor,
+        titleFontFamily: headerTitleStyle && headerTitleStyle.fontFamily,
+        titleFontSize: headerTitleStyle && headerTitleStyle.fontSize,
+        translucent: translucent === undefined ? false : translucent
+      };
+      const hasHeader = headerMode !== 'none' && options.header !== null;
+
+      if (!hasHeader) {
+        return /*#__PURE__*/_react.default.createElement(_reactNativeScreens.ScreenStackHeaderConfig, _extends({}, headerOptions, {
+          hidden: true
+        }));
+      }
+
+      if (headerStyle !== undefined) {
+        headerOptions.backgroundColor = headerStyle.backgroundColor;
+        headerOptions.blurEffect = headerStyle.blurEffect;
+      }
+
+      const children = [];
+
+      if (options.backButtonImage) {
+        children.push( /*#__PURE__*/_react.default.createElement(_reactNativeScreens.ScreenStackHeaderBackButtonImage, {
+          key: "backImage",
+          source: options.backButtonImage
+        }));
+      }
+
+      if (options.headerLeft !== undefined) {
+        children.push( /*#__PURE__*/_react.default.createElement(_reactNativeScreens.ScreenStackHeaderLeftView, {
+          key: "left"
+        }, renderComponentOrThunk(options.headerLeft, {
+          scene
+        })));
+      } else if (options.headerBackImage !== undefined) {
+        const goBack = () => {
+          // Go back on next tick because button ripple effect needs to happen on Android
+          requestAnimationFrame(() => {
+            descriptor.navigation.goBack(descriptor.key);
+          });
+        };
+
+        children.push( /*#__PURE__*/_react.default.createElement(_reactNativeScreens.ScreenStackHeaderLeftView, {
+          key: "left"
+        }, /*#__PURE__*/_react.default.createElement(_reactNavigationStack.HeaderBackButton, {
+          onPress: goBack,
+          pressColorAndroid: options.headerPressColorAndroid,
+          tintColor: options.headerTintColor,
+          backImage: options.headerBackImage,
+          title: options.backButtonTitle,
+          truncatedTitle: options.truncatedBackButtonTitle,
+          backTitleVisible: this.props.backTitleVisible,
+          titleStyle: options.headerBackTitleStyle,
+          layoutPreset: this.props.layoutPreset,
+          scene: scene
+        })));
+      }
+
+      if (options.headerTitle) {
+        if (title === undefined && typeof options.headerTitle === 'string') {
+          headerOptions.title = options.headerTitle;
+        } else {
+          children.push( /*#__PURE__*/_react.default.createElement(_reactNativeScreens.ScreenStackHeaderCenterView, {
+            key: "center"
+          }, renderComponentOrThunk(options.headerTitle, {
+            scene
+          })));
+        }
+      }
+
+      if (options.headerRight) {
+        children.push( /*#__PURE__*/_react.default.createElement(_reactNativeScreens.ScreenStackHeaderRightView, {
+          key: "right"
+        }, renderComponentOrThunk(options.headerRight, {
+          scene
+        })));
+      }
+
+      if (children.length > 0) {
+        headerOptions.children = children;
+      }
+
+      return /*#__PURE__*/_react.default.createElement(_reactNativeScreens.ScreenStackHeaderConfig, headerOptions);
+    });
+
+    _defineProperty(this, "_renderScene", (index, route, descriptor) => {
+      const {
+        navigation,
+        getComponent,
+        options
+      } = descriptor;
+      const {
+        mode,
+        transparentCard
+      } = this.props.navigationConfig;
+      const SceneComponent = getComponent();
+      let stackPresentation = 'push';
+
+      if (mode === 'modal' || mode === 'containedModal') {
+        stackPresentation = mode;
+
+        if (transparentCard || options.cardTransparent) {
+          stackPresentation = mode === 'containedModal' ? 'containedTransparentModal' : 'transparentModal';
+        }
+      }
+
+      let stackAnimation = options.stackAnimation;
+
+      if (options.animationEnabled === false) {
+        stackAnimation = 'none';
+      }
+
+      const {
+        screenProps
+      } = this.props;
+      return /*#__PURE__*/_react.default.createElement(_reactNativeScreens.Screen, {
+        key: "screen_".concat(route.key),
+        style: [_reactNative.StyleSheet.absoluteFill, options.cardStyle],
+        stackAnimation: stackAnimation,
+        stackPresentation: stackPresentation,
+        replaceAnimation: options.replaceAnimation === undefined ? 'pop' : options.replaceAnimation,
+        pointerEvents: index === this.props.navigation.state.routes.length - 1 ? 'auto' : 'none',
+        gestureEnabled: _reactNative.Platform.OS === 'android' ? false : options.gestureEnabled === undefined ? true : options.gestureEnabled,
+        onAppear: () => this._onAppear(route, descriptor),
+        onDismissed: () => this._removeScene(route)
+      }, this._renderHeaderConfig(index, route, descriptor), /*#__PURE__*/_react.default.createElement(_reactNavigation.SceneView, {
+        screenProps: screenProps,
+        navigation: navigation,
+        component: SceneComponent
+      }));
+    });
+  }
+
+  render() {
+    const {
+      navigation,
+      descriptors
+    } = this.props;
+    return /*#__PURE__*/_react.default.createElement(_reactNativeScreens.ScreenStack, {
+      style: styles.scenes,
+      onFinishTransitioning: this._onFinishTransitioning
+    }, navigation.state.routes.map((route, i) => this._renderScene(i, route, descriptors[route.key])));
+  }
+
+}
+
+const styles = _reactNative.StyleSheet.create({
+  scenes: {
+    flex: 1
+  }
+});
+
+function createStackNavigator(routeConfigMap, stackConfig = {}) {
+  const router = (0, _reactNavigation.StackRouter)(routeConfigMap, stackConfig); // belowe we override getStateForAction method in order to add handling for
+  // a custom native stack navigation action. The action REMOVE that we want to
+  // add works in a similar way to POP, but it does not remove all the routes
+  // that sit on top of the removed route. For example if we have three routes
+  // [a,b,c] and call POP on b, then both b and c will go away. In case we
+  // call REMOVE on b, only b will be removed from the stack and the resulting
+  // state will be [a, c]
+
+  const superGetStateForAction = router.getStateForAction;
+
+  router.getStateForAction = (action, state) => {
+    if (action.type === REMOVE_ACTION) {
+      const {
+        key,
+        immediate
+      } = action;
+      let backRouteIndex = state.index;
+
+      if (key) {
+        const backRoute = state.routes.find(route => route.key === key);
+        backRouteIndex = state.routes.indexOf(backRoute);
+      }
+
+      if (backRouteIndex > 0) {
+        const newRoutes = [...state.routes];
+        newRoutes.splice(backRouteIndex, 1);
+        return { ...state,
+          routes: newRoutes,
+          index: newRoutes.length - 1,
+          isTransitioning: immediate !== true
+        };
+      }
+    }
+
+    return superGetStateForAction(action, state);
+  }; // Create a navigator with StackView as the view
+
+
+  return (0, _reactNavigation.createNavigator)(StackView, router, stackConfig);
+}
+
+var _default = createStackNavigator;
+exports.default = _default;
+//# sourceMappingURL=createNativeStackNavigator.js.map

node_modules/react-native-screens/lib/commonjs/index.d.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=index.d.js.map

node_modules/react-native-screens/lib/commonjs/index.d.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","sourcesContent":[]}

node_modules/react-native-screens/lib/commonjs/index.js

@@ -0,0 +1,54 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.enableScreens = enableScreens;
+exports.screensEnabled = screensEnabled;
+exports.NativeScreenContainer = exports.ScreenContainer = exports.Screen = exports.NativeScreen = void 0;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _reactNative = require("react-native");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+
+let ENABLE_SCREENS = true;
+
+function enableScreens(shouldEnableScreens = true) {
+  ENABLE_SCREENS = shouldEnableScreens;
+}
+
+function screensEnabled() {
+  return ENABLE_SCREENS;
+}
+
+class NativeScreen extends _react.default.Component {
+  render() {
+    const {
+      active,
+      style,
+      enabled = true,
+      ...rest
+    } = this.props;
+    return /*#__PURE__*/_react.default.createElement(_reactNative.View, _extends({
+      style: [style, ENABLE_SCREENS && enabled && !active ? {
+        display: 'none'
+      } : null]
+    }, rest));
+  }
+
+}
+
+exports.NativeScreen = NativeScreen;
+
+const Screen = _reactNative.Animated.createAnimatedComponent(NativeScreen);
+
+exports.Screen = Screen;
+const ScreenContainer = _reactNative.View;
+exports.ScreenContainer = ScreenContainer;
+const NativeScreenContainer = _reactNative.View;
+exports.NativeScreenContainer = NativeScreenContainer;
+//# sourceMappingURL=index.js.map

node_modules/react-native-screens/lib/commonjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["index.js"],"names":["ENABLE_SCREENS","enableScreens","shouldEnableScreens","screensEnabled","NativeScreen","React","Component","render","active","style","enabled","rest","props","display","Screen","Animated","createAnimatedComponent","ScreenContainer","View","NativeScreenContainer"],"mappings":";;;;;;;;;AAAA;;AACA;;;;;;AAEA,IAAIA,cAAc,GAAG,IAArB;;AAEO,SAASC,aAAT,CAAuBC,mBAAmB,GAAG,IAA7C,EAAmD;AACxDF,EAAAA,cAAc,GAAGE,mBAAjB;AACD;;AAEM,SAASC,cAAT,GAA0B;AAC/B,SAAOH,cAAP;AACD;;AAEM,MAAMI,YAAN,SAA2BC,eAAMC,SAAjC,CAA2C;AAChDC,EAAAA,MAAM,GAAG;AACP,UAAM;AAAEC,MAAAA,MAAF;AAAUC,MAAAA,KAAV;AAAiBC,MAAAA,OAAO,GAAG,IAA3B;AAAiC,SAAGC;AAApC,QAA6C,KAAKC,KAAxD;AAEA,wBACE,6BAAC,iBAAD;AACE,MAAA,KAAK,EAAE,CACLH,KADK,EAELT,cAAc,IAAIU,OAAlB,IAA6B,CAACF,MAA9B,GAAuC;AAAEK,QAAAA,OAAO,EAAE;AAAX,OAAvC,GAA6D,IAFxD;AADT,OAKMF,IALN,EADF;AASD;;AAb+C;;;;AAgB3C,MAAMG,MAAM,GAAGC,sBAASC,uBAAT,CAAiCZ,YAAjC,CAAf;;;AAEA,MAAMa,eAAe,GAAGC,iBAAxB;;AAEA,MAAMC,qBAAqB,GAAGD,iBAA9B","sourcesContent":["import React from 'react';\nimport { Animated, View } from 'react-native';\n\nlet ENABLE_SCREENS = true;\n\nexport function enableScreens(shouldEnableScreens = true) {\n  ENABLE_SCREENS = shouldEnableScreens;\n}\n\nexport function screensEnabled() {\n  return ENABLE_SCREENS;\n}\n\nexport class NativeScreen extends React.Component {\n  render() {\n    const { active, style, enabled = true, ...rest } = this.props;\n\n    return (\n      <View\n        style={[\n          style,\n          ENABLE_SCREENS && enabled && !active ? { display: 'none' } : null,\n        ]}\n        {...rest}\n      />\n    );\n  }\n}\n\nexport const Screen = Animated.createAnimatedComponent(NativeScreen);\n\nexport const ScreenContainer = View;\n\nexport const NativeScreenContainer = View;\n"]}

node_modules/react-native-screens/lib/commonjs/index.native.js

@@ -0,0 +1,205 @@
+"use strict";
+
+var _react = _interopRequireDefault(require("react"));
+
+var _reactNative = require("react-native");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+let ENABLE_SCREENS = false;
+
+function enableScreens(shouldEnableScreens = true) {
+  ENABLE_SCREENS = shouldEnableScreens;
+
+  if (ENABLE_SCREENS && !_reactNative.UIManager.getViewManagerConfig('RNSScreen')) {
+    console.error("Screen native module hasn't been linked. Please check the react-native-screens README for more details");
+  }
+} // const that tells if the library should use new implementation, will be undefined for older versions
+
+
+const shouldUseActivityState = true;
+
+function screensEnabled() {
+  return ENABLE_SCREENS;
+} // We initialize these lazily so that importing the module doesn't throw error when not linked
+// This is necessary coz libraries such as React Navigation import the library where it may not be enabled
+
+
+let NativeScreenValue;
+let NativeScreenContainerValue;
+let NativeScreenStack;
+let NativeScreenStackHeaderConfig;
+let NativeScreenStackHeaderSubview;
+let AnimatedNativeScreen;
+const ScreensNativeModules = {
+  get NativeScreen() {
+    NativeScreenValue = NativeScreenValue || (0, _reactNative.requireNativeComponent)('RNSScreen', null);
+    return NativeScreenValue;
+  },
+
+  get NativeScreenContainer() {
+    NativeScreenContainerValue = NativeScreenContainerValue || (0, _reactNative.requireNativeComponent)('RNSScreenContainer', null);
+    return NativeScreenContainerValue;
+  },
+
+  get NativeScreenStack() {
+    NativeScreenStack = NativeScreenStack || (0, _reactNative.requireNativeComponent)('RNSScreenStack', null);
+    return NativeScreenStack;
+  },
+
+  get NativeScreenStackHeaderConfig() {
+    NativeScreenStackHeaderConfig = NativeScreenStackHeaderConfig || (0, _reactNative.requireNativeComponent)('RNSScreenStackHeaderConfig', null);
+    return NativeScreenStackHeaderConfig;
+  },
+
+  get NativeScreenStackHeaderSubview() {
+    NativeScreenStackHeaderSubview = NativeScreenStackHeaderSubview || (0, _reactNative.requireNativeComponent)('RNSScreenStackHeaderSubview', null);
+    return NativeScreenStackHeaderSubview;
+  }
+
+};
+
+class Screen extends _react.default.Component {
+  constructor(...args) {
+    super(...args);
+
+    _defineProperty(this, "setRef", ref => {
+      this._ref = ref;
+      this.props.onComponentRef && this.props.onComponentRef(ref);
+    });
+  }
+
+  setNativeProps(props) {
+    this._ref.setNativeProps(props);
+  }
+
+  render() {
+    const {
+      enabled = true
+    } = this.props;
+
+    if (!ENABLE_SCREENS || !enabled) {
+      // Filter out active prop in this case because it is unused and
+      // can cause problems depending on react-native version:
+      // https://github.com/react-navigation/react-navigation/issues/4886
+
+      /* eslint-disable no-unused-vars */
+      const {
+        active,
+        enabled,
+        onComponentRef,
+        ...rest
+      } = this.props;
+      return /*#__PURE__*/_react.default.createElement(_reactNative.Animated.View, _extends({}, rest, {
+        ref: this.setRef
+      }));
+    } else {
+      AnimatedNativeScreen = AnimatedNativeScreen || _reactNative.Animated.createAnimatedComponent(ScreensNativeModules.NativeScreen);
+      let {
+        enabled,
+        active,
+        activityState,
+        ...rest
+      } = this.props;
+
+      if (active !== undefined && activityState === undefined) {
+        console.warn('It appears that you are using old version of react-navigation library. Please update @react-navigation/bottom-tabs, @react-navigation/stack and @react-navigation/drawer to version 5.10.0 or above to take full advantage of new functionality added to react-native-screens');
+        activityState = active !== 0 ? 2 : 0; // in the new version, we need one of the screens to have value of 2 after the transition
+      }
+
+      return /*#__PURE__*/_react.default.createElement(AnimatedNativeScreen, _extends({}, rest, {
+        activityState: activityState,
+        ref: this.setRef
+      }));
+    }
+  }
+
+}
+
+class ScreenContainer extends _react.default.Component {
+  render() {
+    const {
+      enabled = true,
+      ...rest
+    } = this.props;
+
+    if (!ENABLE_SCREENS || !enabled) {
+      return /*#__PURE__*/_react.default.createElement(_reactNative.View, rest);
+    } else {
+      return /*#__PURE__*/_react.default.createElement(ScreensNativeModules.NativeScreenContainer, this.props);
+    }
+  }
+
+}
+
+const styles = _reactNative.StyleSheet.create({
+  headerSubview: {
+    position: 'absolute',
+    top: 0,
+    right: 0,
+    flexDirection: 'row',
+    alignItems: 'center',
+    justifyContent: 'center'
+  }
+});
+
+const ScreenStackHeaderBackButtonImage = props => /*#__PURE__*/_react.default.createElement(ScreensNativeModules.NativeScreenStackHeaderSubview, {
+  type: "back",
+  style: styles.headerSubview
+}, /*#__PURE__*/_react.default.createElement(_reactNative.Image, _extends({
+  resizeMode: "center",
+  fadeDuration: 0
+}, props)));
+
+const ScreenStackHeaderRightView = props => /*#__PURE__*/_react.default.createElement(ScreensNativeModules.NativeScreenStackHeaderSubview, _extends({}, props, {
+  type: "right",
+  style: styles.headerSubview
+}));
+
+const ScreenStackHeaderLeftView = props => /*#__PURE__*/_react.default.createElement(ScreensNativeModules.NativeScreenStackHeaderSubview, _extends({}, props, {
+  type: "left",
+  style: styles.headerSubview
+}));
+
+const ScreenStackHeaderCenterView = props => /*#__PURE__*/_react.default.createElement(ScreensNativeModules.NativeScreenStackHeaderSubview, _extends({}, props, {
+  type: "center",
+  style: styles.headerSubview
+}));
+
+module.exports = {
+  ScreenContainer,
+  Screen,
+
+  get NativeScreen() {
+    return ScreensNativeModules.NativeScreen;
+  },
+
+  get NativeScreenContainer() {
+    return ScreensNativeModules.NativeScreenContainer;
+  },
+
+  get ScreenStack() {
+    return ScreensNativeModules.NativeScreenStack;
+  },
+
+  get ScreenStackHeaderConfig() {
+    return ScreensNativeModules.NativeScreenStackHeaderConfig;
+  },
+
+  get ScreenStackHeaderSubview() {
+    return ScreensNativeModules.NativeScreenStackHeaderSubview;
+  },
+
+  ScreenStackHeaderBackButtonImage,
+  ScreenStackHeaderRightView,
+  ScreenStackHeaderLeftView,
+  ScreenStackHeaderCenterView,
+  enableScreens,
+  screensEnabled,
+  shouldUseActivityState
+};
+//# sourceMappingURL=index.native.js.map

node_modules/react-native-screens/lib/commonjs/native-stack/index.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "createNativeStackNavigator", {
+  enumerable: true,
+  get: function () {
+    return _createNativeStackNavigator.default;
+  }
+});
+Object.defineProperty(exports, "NativeStackView", {
+  enumerable: true,
+  get: function () {
+    return _NativeStackView.default;
+  }
+});
+
+var _createNativeStackNavigator = _interopRequireDefault(require("./navigators/createNativeStackNavigator"));
+
+var _NativeStackView = _interopRequireDefault(require("./views/NativeStackView"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+//# sourceMappingURL=index.js.map

node_modules/react-native-screens/lib/commonjs/native-stack/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["index.tsx"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;AAGA;;AAKA","sourcesContent":["/**\n * Navigators\n */\nexport { default as createNativeStackNavigator } from './navigators/createNativeStackNavigator';\n\n/**\n * Views\n */\nexport { default as NativeStackView } from './views/NativeStackView';\n\n/**\n * Types\n */\nexport type {\n  NativeStackNavigationOptions,\n  NativeStackNavigationProp,\n} from './types';\n"]}

node_modules/react-native-screens/lib/commonjs/native-stack/navigators/createNativeStackNavigator.js

@@ -0,0 +1,71 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _native = require("@react-navigation/native");
+
+var React = _interopRequireWildcard(require("react"));
+
+var _reactNativeScreens = require("react-native-screens");
+
+var _NativeStackView = _interopRequireDefault(require("../views/NativeStackView"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+
+function NativeStackNavigator({
+  initialRouteName,
+  children,
+  screenOptions,
+  ...rest
+}) {
+  if (!(0, _reactNativeScreens.screensEnabled)()) {
+    throw new Error('Native stack is only available if React Native Screens is enabled.');
+  }
+
+  const {
+    state,
+    descriptors,
+    navigation
+  } = (0, _native.useNavigationBuilder)(_native.StackRouter, {
+    initialRouteName,
+    children,
+    screenOptions
+  });
+  React.useEffect(() => {
+    var _navigation$addListen;
+
+    return navigation === null || navigation === void 0 ? void 0 : (_navigation$addListen = navigation.addListener) === null || _navigation$addListen === void 0 ? void 0 : _navigation$addListen.call(navigation, 'tabPress', e => {
+      const isFocused = navigation.isFocused(); // Run the operation in the next frame so we're sure all listeners have been run
+      // This is necessary to know if preventDefault() has been called
+
+      requestAnimationFrame(() => {
+        if (state.index > 0 && isFocused && !e.defaultPrevented) {
+          // When user taps on already focused tab and we're inside the tab,
+          // reset the stack to replicate native behaviour
+          navigation.dispatch({ ..._native.StackActions.popToTop(),
+            target: state.key
+          });
+        }
+      });
+    });
+  }, [navigation, state.index, state.key]);
+  return /*#__PURE__*/React.createElement(_NativeStackView.default, _extends({}, rest, {
+    state: state,
+    navigation: navigation,
+    descriptors: descriptors
+  }));
+}
+
+var _default = (0, _native.createNavigatorFactory)(NativeStackNavigator);
+
+exports.default = _default;
+//# sourceMappingURL=createNativeStackNavigator.js.map

node_modules/react-native-screens/lib/commonjs/native-stack/navigators/createNativeStackNavigator.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["createNativeStackNavigator.tsx"],"names":["NativeStackNavigator","initialRouteName","children","screenOptions","rest","Error","state","descriptors","navigation","StackRouter","React","useEffect","addListener","e","isFocused","requestAnimationFrame","index","defaultPrevented","dispatch","StackActions","popToTop","target","key"],"mappings":";;;;;;;AAAA;;AAWA;;AACA;;AAMA;;;;;;;;;;AAEA,SAASA,oBAAT,CAA8B;AAC5BC,EAAAA,gBAD4B;AAE5BC,EAAAA,QAF4B;AAG5BC,EAAAA,aAH4B;AAI5B,KAAGC;AAJyB,CAA9B,EAK8B;AAC5B,MAAI,CAAC,yCAAL,EAAuB;AACrB,UAAM,IAAIC,KAAJ,CACJ,oEADI,CAAN;AAGD;;AAED,QAAM;AAAEC,IAAAA,KAAF;AAASC,IAAAA,WAAT;AAAsBC,IAAAA;AAAtB,MAAqC,kCAMzCC,mBANyC,EAM5B;AACbR,IAAAA,gBADa;AAEbC,IAAAA,QAFa;AAGbC,IAAAA;AAHa,GAN4B,CAA3C;AAYAO,EAAAA,KAAK,CAACC,SAAN,CACE;AAAA;;AAAA,WACEH,UADF,aACEA,UADF,gDACEA,UAAU,CAAEI,WADd,0DACE,2BAAAJ,UAAU,EAAgB,UAAhB,EAA6BK,CAAD,IAAO;AAC3C,YAAMC,SAAS,GAAGN,UAAU,CAACM,SAAX,EAAlB,CAD2C,CAG3C;AACA;;AACAC,MAAAA,qBAAqB,CAAC,MAAM;AAC1B,YACET,KAAK,CAACU,KAAN,GAAc,CAAd,IACAF,SADA,IAEA,CAAED,CAAD,CAAkCI,gBAHrC,EAIE;AACA;AACA;AACAT,UAAAA,UAAU,CAACU,QAAX,CAAoB,EAClB,GAAGC,qBAAaC,QAAb,EADe;AAElBC,YAAAA,MAAM,EAAEf,KAAK,CAACgB;AAFI,WAApB;AAID;AACF,OAboB,CAArB;AAcD,KAnBS,CADZ;AAAA,GADF,EAsBE,CAACd,UAAD,EAAaF,KAAK,CAACU,KAAnB,EAA0BV,KAAK,CAACgB,GAAhC,CAtBF;AAyBA,sBACE,oBAAC,wBAAD,eACMlB,IADN;AAEE,IAAA,KAAK,EAAEE,KAFT;AAGE,IAAA,UAAU,EAAEE,UAHd;AAIE,IAAA,WAAW,EAAED;AAJf,KADF;AAQD;;eAEc,oCAKbP,oBALa,C","sourcesContent":["import {\n  createNavigatorFactory,\n  EventArg,\n  StackActions,\n  StackActionHelpers,\n  StackNavigationState,\n  StackRouter,\n  StackRouterOptions,\n  ParamListBase,\n  useNavigationBuilder,\n} from '@react-navigation/native';\nimport * as React from 'react';\nimport { screensEnabled } from 'react-native-screens';\nimport {\n  NativeStackNavigationEventMap,\n  NativeStackNavigationOptions,\n  NativeStackNavigatorProps,\n} from '../types';\nimport NativeStackView from '../views/NativeStackView';\n\nfunction NativeStackNavigator({\n  initialRouteName,\n  children,\n  screenOptions,\n  ...rest\n}: NativeStackNavigatorProps) {\n  if (!screensEnabled()) {\n    throw new Error(\n      'Native stack is only available if React Native Screens is enabled.'\n    );\n  }\n\n  const { state, descriptors, navigation } = useNavigationBuilder<\n    StackNavigationState<ParamListBase>,\n    StackRouterOptions,\n    StackActionHelpers<ParamListBase>,\n    NativeStackNavigationOptions,\n    NativeStackNavigationEventMap\n  >(StackRouter, {\n    initialRouteName,\n    children,\n    screenOptions,\n  });\n\n  React.useEffect(\n    () =>\n      navigation?.addListener?.('tabPress', (e) => {\n        const isFocused = navigation.isFocused();\n\n        // Run the operation in the next frame so we're sure all listeners have been run\n        // This is necessary to know if preventDefault() has been called\n        requestAnimationFrame(() => {\n          if (\n            state.index > 0 &&\n            isFocused &&\n            !(e as EventArg<'tabPress', true>).defaultPrevented\n          ) {\n            // When user taps on already focused tab and we're inside the tab,\n            // reset the stack to replicate native behaviour\n            navigation.dispatch({\n              ...StackActions.popToTop(),\n              target: state.key,\n            });\n          }\n        });\n      }),\n    [navigation, state.index, state.key]\n  );\n\n  return (\n    <NativeStackView\n      {...rest}\n      state={state}\n      navigation={navigation}\n      descriptors={descriptors}\n    />\n  );\n}\n\nexport default createNavigatorFactory<\n  StackNavigationState<ParamListBase>,\n  NativeStackNavigationOptions,\n  NativeStackNavigationEventMap,\n  typeof NativeStackNavigator\n>(NativeStackNavigator);\n"]}

node_modules/react-native-screens/lib/commonjs/native-stack/types.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=types.js.map

node_modules/react-native-screens/lib/commonjs/native-stack/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","sourcesContent":[]}

node_modules/react-native-screens/lib/commonjs/native-stack/views/FontProcessor.expo.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.processFonts = processFonts;
+
+var _expoFont = require("expo-font");
+
+// @ts-ignore this file extension is parsed only in managed workflow, so `expo-font` should be always available there
+// eslint-disable-next-line import/no-unresolved
+function processFonts(fontFamilies) {
+  return fontFamilies.map(fontFamily => (0, _expoFont.processFontFamily)(fontFamily));
+}
+//# sourceMappingURL=FontProcessor.expo.js.map

node_modules/react-native-screens/lib/commonjs/native-stack/views/FontProcessor.expo.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["FontProcessor.expo.tsx"],"names":["processFonts","fontFamilies","map","fontFamily"],"mappings":";;;;;;;AAEA;;AAFA;AACA;AAGO,SAASA,YAAT,CACLC,YADK,EAEmB;AACxB,SAAOA,YAAY,CAACC,GAAb,CAAkBC,UAAD,IAAgB,iCAAkBA,UAAlB,CAAjC,CAAP;AACD","sourcesContent":["// @ts-ignore this file extension is parsed only in managed workflow, so `expo-font` should be always available there\n// eslint-disable-next-line import/no-unresolved\nimport { processFontFamily } from 'expo-font';\n\nexport function processFonts(\n  fontFamilies: (string | undefined)[]\n): (string | undefined)[] {\n  return fontFamilies.map((fontFamily) => processFontFamily(fontFamily));\n}\n"]}

node_modules/react-native-screens/lib/commonjs/native-stack/views/FontProcessor.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.processFonts = processFonts;
+
+// do nothing outside of expo
+function processFonts(fontFamilies) {
+  return fontFamilies;
+}
+//# sourceMappingURL=FontProcessor.js.map

node_modules/react-native-screens/lib/commonjs/native-stack/views/FontProcessor.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["FontProcessor.tsx"],"names":["processFonts","fontFamilies"],"mappings":";;;;;;;AAAA;AACO,SAASA,YAAT,CACLC,YADK,EAEmB;AACxB,SAAOA,YAAP;AACD","sourcesContent":["// do nothing outside of expo\nexport function processFonts(\n  fontFamilies: (string | undefined)[]\n): (string | undefined)[] {\n  return fontFamilies;\n}\n"]}

node_modules/react-native-screens/lib/commonjs/native-stack/views/HeaderConfig.js

@@ -0,0 +1,92 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = HeaderConfig;
+
+var _native = require("@react-navigation/native");
+
+var React = _interopRequireWildcard(require("react"));
+
+var _reactNativeScreens = require("react-native-screens");
+
+var _FontProcessor = require("./FontProcessor");
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function HeaderConfig({
+  backButtonImage,
+  backButtonInCustomView,
+  direction,
+  headerBackTitle,
+  headerBackTitleStyle = {},
+  headerBackTitleVisible = true,
+  headerCenter,
+  headerHideBackButton,
+  headerHideShadow,
+  headerLargeStyle = {},
+  headerLargeTitle,
+  headerLargeTitleHideShadow,
+  headerLargeTitleStyle = {},
+  headerLeft,
+  headerRight,
+  headerShown,
+  headerStyle = {},
+  headerTintColor,
+  headerTitle,
+  headerTitleStyle = {},
+  headerTopInsetEnabled = true,
+  headerTranslucent,
+  route,
+  statusBarAnimation,
+  statusBarHidden,
+  statusBarStyle,
+  title
+}) {
+  const {
+    colors
+  } = (0, _native.useTheme)();
+  const tintColor = headerTintColor !== null && headerTintColor !== void 0 ? headerTintColor : colors.primary;
+  const [backTitleFontFamily, largeTitleFontFamily, titleFontFamily] = (0, _FontProcessor.processFonts)([headerBackTitleStyle.fontFamily, headerLargeTitleStyle.fontFamily, headerTitleStyle.fontFamily]);
+  return /*#__PURE__*/React.createElement(_reactNativeScreens.ScreenStackHeaderConfig, {
+    backButtonInCustomView: backButtonInCustomView,
+    backgroundColor: headerStyle.backgroundColor ? headerStyle.backgroundColor : colors.card,
+    backTitle: headerBackTitleVisible ? headerBackTitle : ' ',
+    backTitleFontFamily: backTitleFontFamily,
+    backTitleFontSize: headerBackTitleStyle.fontSize,
+    blurEffect: headerStyle.blurEffect,
+    color: tintColor,
+    direction: direction,
+    hidden: headerShown === false,
+    hideBackButton: headerHideBackButton,
+    hideShadow: headerHideShadow,
+    largeTitle: headerLargeTitle,
+    largeTitleBackgroundColor: headerLargeStyle.backgroundColor,
+    largeTitleColor: headerLargeTitleStyle.color,
+    largeTitleFontFamily: largeTitleFontFamily,
+    largeTitleFontSize: headerLargeTitleStyle.fontSize,
+    largeTitleHideShadow: headerLargeTitleHideShadow,
+    statusBarAnimation: statusBarAnimation,
+    statusBarHidden: statusBarHidden,
+    statusBarStyle: statusBarStyle,
+    title: headerTitle !== undefined ? headerTitle : title !== undefined ? title : route.name,
+    titleColor: headerTitleStyle.color !== undefined ? headerTitleStyle.color : headerTintColor !== undefined ? headerTintColor : colors.text,
+    titleFontFamily: titleFontFamily,
+    titleFontSize: headerTitleStyle.fontSize,
+    topInsetEnabled: headerTopInsetEnabled,
+    translucent: headerTranslucent === true
+  }, headerRight !== undefined ? /*#__PURE__*/React.createElement(_reactNativeScreens.ScreenStackHeaderRightView, null, headerRight({
+    tintColor
+  })) : null, backButtonImage !== undefined ? /*#__PURE__*/React.createElement(_reactNativeScreens.ScreenStackHeaderBackButtonImage, {
+    key: "backImage",
+    source: backButtonImage
+  }) : null, headerLeft !== undefined ? /*#__PURE__*/React.createElement(_reactNativeScreens.ScreenStackHeaderLeftView, null, headerLeft({
+    tintColor
+  })) : null, headerCenter !== undefined ? /*#__PURE__*/React.createElement(_reactNativeScreens.ScreenStackHeaderCenterView, null, headerCenter({
+    tintColor
+  })) : null);
+}
+//# sourceMappingURL=HeaderConfig.js.map

node_modules/react-native-screens/lib/commonjs/native-stack/views/NativeStackView.js

@@ -0,0 +1,151 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = NativeStackView;
+
+var _native = require("@react-navigation/native");
+
+var React = _interopRequireWildcard(require("react"));
+
+var _reactNative = require("react-native");
+
+var _AppContainer = _interopRequireDefault(require("react-native/Libraries/ReactNative/AppContainer"));
+
+var _reactNativeScreens = require("react-native-screens");
+
+var _HeaderConfig = _interopRequireDefault(require("./HeaderConfig"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+
+const Screen = _reactNativeScreens.Screen;
+const isAndroid = _reactNative.Platform.OS === 'android';
+let Container = _reactNative.View;
+
+if (__DEV__) {
+  const DebugContainer = props => {
+    const {
+      stackAnimation,
+      ...rest
+    } = props;
+
+    if (_reactNative.Platform.OS === 'ios' && stackAnimation !== 'push') {
+      return /*#__PURE__*/React.createElement(_AppContainer.default, null, /*#__PURE__*/React.createElement(_reactNative.View, rest));
+    }
+
+    return /*#__PURE__*/React.createElement(_reactNative.View, rest);
+  }; // @ts-ignore Wrong props
+
+
+  Container = DebugContainer;
+}
+
+function NativeStackView({
+  state,
+  navigation,
+  descriptors
+}) {
+  const {
+    key,
+    routes
+  } = state;
+  const {
+    colors
+  } = (0, _native.useTheme)();
+  return /*#__PURE__*/React.createElement(_reactNativeScreens.ScreenStack, {
+    style: styles.container
+  }, routes.map(route => {
+    const {
+      options,
+      render: renderScene
+    } = descriptors[route.key];
+    const {
+      gestureEnabled,
+      replaceAnimation = 'pop',
+      stackPresentation = 'push',
+      stackAnimation,
+      contentStyle
+    } = options;
+    const viewStyles = [styles.container, stackPresentation !== 'transparentModal' && {
+      backgroundColor: colors.background
+    }, contentStyle];
+    return /*#__PURE__*/React.createElement(Screen, {
+      key: route.key,
+      style: _reactNative.StyleSheet.absoluteFill,
+      gestureEnabled: isAndroid ? false : gestureEnabled,
+      replaceAnimation: replaceAnimation,
+      stackPresentation: stackPresentation,
+      stackAnimation: stackAnimation,
+      onWillAppear: () => {
+        navigation.emit({
+          type: 'transitionStart',
+          data: {
+            closing: false
+          },
+          target: route.key
+        });
+      },
+      onWillDisappear: () => {
+        navigation.emit({
+          type: 'transitionStart',
+          data: {
+            closing: true
+          },
+          target: route.key
+        });
+      },
+      onAppear: () => {
+        navigation.emit({
+          type: 'appear',
+          target: route.key
+        });
+        navigation.emit({
+          type: 'transitionEnd',
+          data: {
+            closing: false
+          },
+          target: route.key
+        });
+      },
+      onDisappear: () => {
+        navigation.emit({
+          type: 'transitionEnd',
+          data: {
+            closing: true
+          },
+          target: route.key
+        });
+      },
+      onDismissed: () => {
+        navigation.emit({
+          type: 'dismiss',
+          target: route.key
+        });
+        navigation.dispatch({ ..._native.StackActions.pop(),
+          source: route.key,
+          target: key
+        });
+      }
+    }, /*#__PURE__*/React.createElement(_HeaderConfig.default, _extends({}, options, {
+      route: route
+    })), /*#__PURE__*/React.createElement(Container, {
+      style: viewStyles // @ts-ignore Wrong props passed to View
+      ,
+      stackPresentation: stackPresentation
+    }, renderScene()));
+  }));
+}
+
+const styles = _reactNative.StyleSheet.create({
+  container: {
+    flex: 1
+  }
+});
+//# sourceMappingURL=NativeStackView.js.map