// Module ID: 5553
// Function ID: 47087
// Name: _isNativeReflectConstruct
// Dependencies: []

// Module 5553 (_isNativeReflectConstruct)
let Platform;
let StyleSheet;
function _isNativeReflectConstruct() {
  let closure_0 = !valueOf.call(Reflect.construct(Boolean, [], () => {

  }));
  function _isNativeReflectConstruct() {
    return closure_0;
  }
  const result = _isNativeReflectConstruct();
}
let closure_3 = importDefault(dependencyMap[0]);
let closure_4 = importDefault(dependencyMap[1]);
let closure_5 = importDefault(dependencyMap[2]);
let closure_6 = importDefault(dependencyMap[3]);
let closure_7 = importDefault(dependencyMap[4]);
let closure_8 = importDefault(dependencyMap[5]);
const importAllResult = importAll(dependencyMap[6]);
({ Animated: closure_10, Platform, StyleSheet } = arg1(dependencyMap[7]));
const tmp3 = arg1(dependencyMap[7]);
({ jsx: closure_12, jsxs: closure_13 } = arg1(dependencyMap[8]));
let closure_14 = Object.freeze({ options: {} });
function getInterpolationIndex(arg0, arg1) {
  let diff = arg1 - 1;
  let num = 0;
  let num2 = 0;
  if (diff >= 0) {
    while (true) {
      let tmp3 = arg0[diff];
      let prop;
      if (null != tmp3) {
        prop = tmp3.descriptor.options.cardStyleInterpolator;
      }
      num2 = num;
      if (prop !== tmp) {
        break;
      } else {
        num = num + 1;
        diff = diff - 1;
        num2 = num;
        if (diff < 0) {
          break;
        }
      }
    }
  }
  return num2;
}
function getIsModal(descriptor) {
  if (arg2) {
    return true;
  } else {
    let isModalPresentation = arg1(dependencyMap[9]).getIsModalPresentation(descriptor.descriptor.options.cardStyleInterpolator);
    if (isModalPresentation) {
      isModalPresentation = 0 !== arg1;
    }
    return isModalPresentation;
  }
}
function getHeaderHeights(arr) {
  const arg1 = arr;
  const importDefault = arg1;
  const dependencyMap = arg2;
  let closure_3 = arg3;
  let closure_4 = arg4;
  let closure_5 = arg5;
  return arr.reduce((arg0, descriptor) => {
    const options = descriptor.descriptor.options;
    let headerStatusBarHeight = options.headerStatusBarHeight;
    if (undefined === headerStatusBarHeight) {
      let num = 0;
      if (!arg2) {
        num = descriptor.top;
      }
      headerStatusBarHeight = num;
    }
    let headerStyle = options.headerStyle;
    if (!headerStyle) {
      headerStyle = {};
    }
    const flattenResult = closure_11.flatten(headerStyle);
    if ("height" in flattenResult) {
      if ("number" === typeof flattenResult.height) {
        let height = flattenResult.height;
      }
      if ("number" !== typeof height) {
        height = arg0(arg2[10]).getDefaultHeaderHeight(arg4, tmp10, headerStatusBarHeight);
        const obj2 = arg0(arg2[10]);
      }
      arg0[descriptor.route.key] = height;
      return arg0;
    }
    height = arg5[descriptor.route.key];
  }, {});
}
function getDistanceFromOptions(arg0, options) {
  options = undefined;
  if (null != options) {
    options = options.options;
  }
  if (!options) {
    options = {};
  }
  const gestureDirection = options.gestureDirection;
  if (undefined !== gestureDirection) {
    return importDefault(dependencyMap[12])(arg0, gestureDirection);
  } else if ("modal" === tmp) {
    let gestureDirection2 = options(dependencyMap[11]).ModalTransition.gestureDirection;
  } else {
    gestureDirection2 = options(dependencyMap[11]).DefaultTransition.gestureDirection;
  }
}
function getProgressFromGesture(interpolate, width, options) {
  let obj = { width: Math.max(1, width.width), height: Math.max(1, width.height) };
  const tmp = getDistanceFromOptions(obj, options);
  if (tmp > 0) {
    obj = {};
    const items = [0.229, tmp];
    obj.inputRange = items;
    obj.outputRange = ["getViewManagerConfig", "hasViewManagerConfig"];
    let interpolateResult = interpolate.interpolate(obj);
  } else {
    obj = {};
    const items1 = [tmp, 0];
    obj.inputRange = items1;
    obj.outputRange = [null, null];
    interpolateResult = interpolate.interpolate(obj);
  }
  return interpolateResult;
}
const tmp4 = arg1(dependencyMap[8]);
const styles = StyleSheet.create({ container: { flex: 1 }, absolute: {}, floating: { zIndex: 1 } });

export default (Component) => {
  class CardStack {
    constructor(arg0) {
      self = this;
      tmp = closure_4(this, CardStack);
      items = [];
      items[0] = Component;
      obj = closure_7(CardStack);
      tmp2 = closure_6;
      if (closure_21()) {
        tmp4 = globalThis;
        _Reflect = Reflect;
        tmp5 = closure_7;
        constructResult = Reflect.construct(obj, items, closure_7(self).constructor);
      } else {
        constructResult = obj.apply(self, items);
      }
      tmp2Result = tmp2(self, constructResult);
      CardStack = tmp2Result;
      tmp2Result.handleLayout = (nativeEvent) => {
        const layout = nativeEvent.nativeEvent.layout;
        const height = layout.height;
        const width = layout.width;
        let closure_2 = { width, height };
        height.setState((layout, insets) => {
          if (height !== layout.layout.height) {
            const obj = { layout: closure_2, headerHeights: callback(layout.scenes, insets.insets, insets.isParentHeaderShown, insets.isParentModal, closure_2, layout.headerHeights) };
            let tmp2 = obj;
          } else {
            tmp2 = null;
          }
          return tmp2;
        });
      };
      tmp2Result.handleHeaderLayout = (arg0) => {
        ({ route: closure_0, height: closure_1 } = arg0);
        tmp2Result.setState((headerHeights) => {
          headerHeights = headerHeights.headerHeights;
          let tmp = null;
          if (headerHeights[closure_0.key] !== closure_1) {
            const obj = {};
            const _Object = Object;
            obj.headerHeights = Object.assign({}, headerHeights, callback({}, key.key, closure_1));
            tmp = obj;
          }
          return tmp;
        });
      };
      tmp2Result.getFocusedRoute = () => {
        const state = tmp2Result.props.state;
        return state.routes[state.index];
      };
      tmp2Result.getPreviousScene = (route) => {
        const scenes = tmp2Result.state.scenes;
        const previousRoute = tmp2Result.props.getPreviousRoute({ route: route.route });
        if (previousRoute) {
          return scenes.find((descriptor) => descriptor.descriptor.route.key === previousRoute.key);
        }
        const obj = { route: route.route };
      };
      obj = { routes: [], scenes: [], gestures: {}, layout: CardStack(closure_2[10]).SafeAreaProviderCompat.initialMetrics.frame, descriptors: tmp2Result.props.descriptors, headerHeights: {} };
      tmp2Result.state = obj;
      return tmp2Result;
    }
  }
  const arg1 = CardStack;
  callback2(CardStack, Component);
  let obj = {
    key: "render",
    value: function render() {
      let detachInactiveScreens;
      let headerHeights;
      let renderHeader;
      let routes;
      let state;
      const self = this;
      const CardStack = this;
      const props = this.props;
      ({ insets: closure_1, state, routes, closingRouteKeys: closure_2, onOpenRoute: closure_3, onCloseRoute: closure_4, renderHeader } = props);
      ({ renderScene: closure_6, isParentHeaderShown: closure_7, isParentModal: closure_8, onTransitionStart: closure_9, onTransitionEnd: closure_10, onGestureStart: closure_11, onGestureEnd: closure_12, onGestureCancel: closure_13, detachInactiveScreens } = props);
      const tmp = undefined === detachInactiveScreens || detachInactiveScreens;
      const state2 = self.state;
      const scenes = state2.scenes;
      const layout = state2.layout;
      ({ gestures: closure_17, headerHeights } = state2);
      const tmp2 = state.routes[state.index];
      const scenes1 = self.state.scenes;
      const substr = scenes1.slice(-2);
      const someResult = substr.some((descriptor) => {
        let options = descriptor.descriptor.options;
        if (null == options) {
          options = {};
        }
        const headerShown = options.headerShown;
        let tmp = !options.headerTransparent;
        if (tmp) {
          tmp = false !== (undefined === headerShown || headerShown);
          const tmp2 = undefined === headerShown || headerShown;
        }
        if (tmp) {
          tmp = "screen" !== options.headerMode;
        }
        return !tmp;
      });
      let num = 1;
      let sum = 1;
      let diff = scenes.length - 1;
      if (diff >= 0) {
        while (true) {
          let options = scenes[diff].descriptor.options;
          let detachPreviousScreen = options.detachPreviousScreen;
          if (undefined === detachPreviousScreen) {
            let tmp5 = "transparentModal" !== options.presentation;
            if (tmp5) {
              let tmp6 = CardStack;
              let tmp7 = closure_2;
              let obj1 = CardStack(closure_2[9]);
              let tmp8 = !obj1.getIsModalPresentation(options.cardStyleInterpolator);
              if (!tmp8) {
                let tmp9 = callback;
                let tmp10 = closure_2;
                tmp8 = diff !== callback(closure_2[13])(scenes, (descriptor) => {
                  const cardStyleInterpolator = descriptor.descriptor.options.cardStyleInterpolator;
                  let tmp = cardStyleInterpolator === self(closure_2[14]).forModalPresentationIOS;
                  if (!tmp) {
                    let name;
                    if (null != cardStyleInterpolator) {
                      name = cardStyleInterpolator.name;
                    }
                    tmp = "forModalPresentationIOS" === name;
                  }
                  return tmp;
                });
              }
              tmp5 = tmp8;
            }
            detachPreviousScreen = tmp5;
          }
          if (false === detachPreviousScreen) {
            sum = num + 1;
            let tmp11 = sum;
            diff = diff - 1;
            num = tmp11;
            if (diff < 0) {
              break;
            }
          } else {
            tmp11 = num;
            if (diff <= scenes.length - 2) {
              break;
            }
          }
          break;
        }
      }
      let obj = {};
      obj = { mode: "float", layout, scenes, getPreviousScene: self.getPreviousScene, getFocusedRoute: self.getFocusedRoute, onContentHeightChange: self.handleHeaderLayout };
      const items = [someResult.floating, ];
      let tmp14 = someResult;
      if (someResult) {
        obj1 = { height: headerHeights[tmp2.key] };
        const items1 = [obj1, someResult.absolute];
        tmp14 = items1;
      }
      items[1] = tmp14;
      obj.style = items;
      obj.children = renderHeader(obj);
      const tmp13Result = callback4(React.Fragment, obj, "header");
      const obj2 = {};
      let tmp18 = null;
      if (!someResult) {
        tmp18 = tmp13Result;
      }
      const items2 = [tmp18, , ];
      const obj3 = {
        enabled: tmp,
        style: someResult.container,
        onLayout: self.handleLayout,
        children: routes.map((key, index) => {
          let bottom;
          let freezeOnBlur;
          let headerStyle;
          let headerTransparent;
          let left;
          let right;
          let top;
          let num = 0;
          if (index >= arg2.length - sum - 1) {
            let num2 = 2;
            if (index !== arg2.length - 1) {
              let num3 = 0;
              if (index >= arg2.length - sum) {
                num3 = 1;
              }
              num2 = num3;
            }
            let num4 = 1;
            if (scenes[arg2.length - 1]) {
              const current = tmp3.progress.current;
              let obj = { inputRange: [] };
              const items = [null, null, num2];
              obj.outputRange = items;
              obj.extrapolate = "clamp";
              num4 = current.interpolate(obj);
            }
            num = num4;
            const tmp2 = scenes;
          }
          const options = tmp.descriptor.options;
          const headerShown = options.headerShown;
          const headerTintColor = options.headerTintColor;
          let num5 = 0;
          ({ headerTransparent, headerStyle, freezeOnBlur } = options);
          ({ top, right, bottom, left } = callback);
          if (false !== (undefined === headerShown || headerShown)) {
            num5 = headerHeights[key.key];
          }
          let isDarkResult;
          if (undefined === headerShown || headerShown) {
            if ("string" === typeof headerTintColor) {
              isDarkResult = callback(closure_2[16])(headerTintColor).isDark();
              const obj3 = callback(closure_2[16])(headerTintColor);
            } else {
              const flattenResult = closure_11.flatten(headerStyle);
              let tmp10 = flattenResult;
              if (flattenResult) {
                tmp10 = "backgroundColor" in flattenResult;
              }
              if (tmp10) {
                tmp10 = "string" === typeof flattenResult.backgroundColor;
              }
              if (tmp10) {
                isDarkResult = !callback(closure_2[16])(flattenResult.backgroundColor).isDark();
                const obj2 = callback(closure_2[16])(flattenResult.backgroundColor);
              }
            }
          }
          const tmp15 = scenes(scenes, index);
          let presentation;
          if (null != scenes[index + 1]) {
            presentation = tmp17.descriptor.options.presentation;
          }
          let detachPreviousScreen;
          if (null != scenes[index + 1]) {
            detachPreviousScreen = tmp19.descriptor.options.detachPreviousScreen;
          }
          obj = { style: closure_11.absoluteFill, enabled: tmp, active: num, freezeOnBlur, pointerEvents: "box-none" };
          obj = { index, interpolationIndex: tmp15, modal: layout(scenes[index], tmp15, closure_8), active: index === arg2.length - 1, focused: tmp2.key === key.key };
          const tmp16 = layout(scenes[index], tmp15, closure_8);
          obj.closing = closure_2.includes(key.key);
          obj.layout = layout;
          obj.gesture = closure_17[key.key];
          obj.scene = scenes[index];
          obj.safeAreaInsetTop = top;
          obj.safeAreaInsetRight = right;
          obj.safeAreaInsetBottom = bottom;
          obj.safeAreaInsetLeft = left;
          obj.onGestureStart = closure_11;
          obj.onGestureCancel = closure_13;
          obj.onGestureEnd = closure_12;
          obj.headerHeight = num5;
          obj.isParentHeaderShown = closure_7;
          ({ handleHeaderLayout: obj5.onHeaderHeightChange, getPreviousScene: obj5.getPreviousScene, getFocusedRoute: obj5.getFocusedRoute } = self);
          obj.headerDarkContent = isDarkResult;
          let tmp23 = someResult;
          if (someResult) {
            tmp23 = !headerTransparent;
          }
          obj.hasAbsoluteFloatHeader = tmp23;
          obj.renderHeader = renderHeader;
          obj.renderScene = closure_6;
          obj.onOpenRoute = closure_3;
          obj.onCloseRoute = closure_4;
          obj.onTransitionStart = closure_9;
          obj.onTransitionEnd = closure_10;
          obj.isNextScreenTransparent = "transparentModal" === presentation;
          obj.detachCurrentScreen = false !== detachPreviousScreen;
          obj.children = closure_12(callback(closure_2[17]), obj);
          return closure_12(self(closure_2[15]).MaybeScreen, obj, key.key);
        })
      };
      items2[1] = callback4(CardStack(closure_2[15]).MaybeScreenContainer, obj3);
      let tmp19 = null;
      if (someResult) {
        tmp19 = tmp13Result;
      }
      items2[2] = tmp19;
      obj2.children = items2;
      return closure_13(CardStack(closure_2[10]).Background, obj2);
    }
  };
  const items = [obj];
  obj = {
    key: "getDerivedStateFromProps",
    value: function getDerivedStateFromProps(routes, routes2) {
      const CardStack = routes;
      if (routes.routes === routes2.routes) {
        if (routes.descriptors === routes2.descriptors) {
          return null;
        }
      }
      routes = routes.routes;
      const reduced = routes.reduce((arg0, key) => {
        let options;
        if (null != arg0.descriptors[key.key]) {
          options = tmp.options;
        }
        if (!options) {
          options = {};
        }
        let value = key.gestures[key.key];
        if (!value) {
          const Value = Value.Value;
          const openingRouteKeys = arg0.openingRouteKeys;
          let num = 0;
          if (openingRouteKeys.includes(key.key)) {
            num = 0;
            if (false !== tmp2) {
              num = callback(key.layout, tmp);
            }
          }
          const prototype = Value.prototype;
          value = new Value(num);
        }
        arg0[key.key] = value;
        return arg0;
      }, {});
      const routes1 = routes.routes;
      const mapped = routes1.map((route) => {
        route = tmp3;
        let tmp9 = route.descriptors[route.key];
        if (!tmp9) {
          tmp9 = arg1.descriptors[route.key];
        }
        if (tmp9) {
          let key;
          if (null != tmp2) {
            key = tmp2.key;
          }
          let tmp15 = route.descriptors[key];
          if (!tmp15) {
            let key1;
            if (null != tmp2) {
              key1 = tmp2.key;
            }
            tmp15 = arg1.descriptors[key1];
          }
          let key2;
          if (null != tmp) {
            key2 = tmp.key;
          }
          let tmp20 = route.descriptors[key2];
          if (!tmp20) {
            let key3;
            if (null != tmp) {
              key3 = tmp.key;
            }
            tmp20 = arg1.descriptors[key3];
          }
          if (arg1 !== arg2.length - 1) {
            if (tmp15) {
              if ("transparentModal" !== tmp15.options.presentation) {
                let options = tmp15.options;
              }
              if ("modal" === options.presentation) {
                let DefaultTransition = route(reduced[11]).ModalTransition;
              } else if ("transparentModal" === options.presentation) {
                DefaultTransition = route(reduced[11]).ModalFadeTransition;
              } else {
                DefaultTransition = route(reduced[11]).DefaultTransition;
              }
              const animationEnabled = options.animationEnabled;
              const gestureEnabled = options.gestureEnabled;
              let gestureDirection = options.gestureDirection;
              if (undefined === gestureDirection) {
                gestureDirection = DefaultTransition.gestureDirection;
              }
              let transitionSpec = options.transitionSpec;
              if (undefined === transitionSpec) {
                transitionSpec = DefaultTransition.transitionSpec;
              }
              const cardStyleInterpolator = options.cardStyleInterpolator;
              if (undefined !== cardStyleInterpolator) {
                let headerStyleInterpolator = options.headerStyleInterpolator;
                if (undefined === headerStyleInterpolator) {
                  headerStyleInterpolator = DefaultTransition.headerStyleInterpolator;
                }
                let cardOverlayEnabled = options.cardOverlayEnabled;
                if (undefined === cardOverlayEnabled) {
                  let isModalPresentation = "transparentModal" !== options.presentation;
                  if (!isModalPresentation) {
                    let obj = route(reduced[9]);
                    isModalPresentation = obj.getIsModalPresentation(cardStyleInterpolator);
                  }
                  cardOverlayEnabled = isModalPresentation;
                }
                let str5 = tmp9.options.headerMode;
                if (null == str5) {
                  let tmp37 = "modal" !== options.presentation;
                  if (tmp37) {
                    tmp37 = "transparentModal" !== options.presentation;
                  }
                  if (tmp37) {
                    let presentation;
                    if (null != tmp15) {
                      presentation = tmp15.options.presentation;
                    }
                    tmp37 = "modal" !== presentation;
                  }
                  if (tmp37) {
                    let presentation1;
                    if (null != tmp15) {
                      presentation1 = tmp15.options.presentation;
                    }
                    tmp37 = "transparentModal" !== presentation1;
                  }
                  str5 = "screen";
                  if (tmp37) {
                    let obj1 = route(reduced[9]);
                    const isModalPresentation1 = obj1.getIsModalPresentation(cardStyleInterpolator);
                    str5 = "screen";
                  }
                }
                obj = { route };
                const _Object = Object;
                obj = {};
                const _Object2 = Object;
                obj1 = { animationEnabled: tmp29, cardOverlayEnabled, cardStyleInterpolator, gestureDirection, gestureEnabled: tmp30, headerStyleInterpolator, transitionSpec, headerMode: str5 };
                obj.options = Object.assign({}, tmp9.options, obj1);
                obj.descriptor = Object.assign({}, tmp9, obj);
                const obj2 = { current: callback2(tmp4, arg1.layout, tmp9) };
                let tmp46;
                if (tmp7) {
                  let presentation2;
                  if (null != tmp15) {
                    presentation2 = tmp15.options.presentation;
                  }
                  if ("transparentModal" !== presentation2) {
                    tmp46 = callback2(tmp7, arg1.layout, tmp15);
                  }
                }
                obj2.next = tmp46;
                let tmp50;
                if (tmp5) {
                  tmp50 = callback2(tmp5, arg1.layout, tmp20);
                }
                obj2.previous = tmp50;
                obj.progress = obj2;
                const items = [arg1.layout, tmp9, tmp15, tmp20, tmp4, tmp7, tmp5];
                obj.__memo = items;
                let tmp54 = obj;
                if (tmp3) {
                  const __memo = obj.__memo;
                  tmp54 = obj;
                  if (__memo.every((arg0, arg1) => tmp3.__memo[arg1] === arg0)) {
                    tmp54 = tmp3;
                  }
                }
                return tmp54;
              } else if (false === tmp29) {
                let cardStyleInterpolator2 = route(reduced[14]).forNoAnimation;
              } else {
                cardStyleInterpolator2 = DefaultTransition.cardStyleInterpolator;
              }
              const tmp30 = undefined !== gestureEnabled && gestureEnabled;
            }
          }
          options = tmp9.options;
        }
      });
      return { routes: routes.routes, scenes: mapped, gestures: reduced, descriptors: routes.descriptors, headerHeights: callback5(mapped, routes.insets, routes.isParentHeaderShown, routes.isParentModal, routes2.layout, routes2.headerHeights) };
    }
  };
  const items1 = [obj];
  return callback(CardStack, items, items1);
}(importAllResult.Component);