f0ckapp_react/.vscode/.react/index.bundle

var __BUNDLE_START_TIME__=this.nativePerformanceNow?nativePerformanceNow():Date.now(),__DEV__=true,process=this.process||{};process.env=process.env||{};process.env.NODE_ENV=process.env.NODE_ENV||"development";
(function (global) {
  "use strict";

  global.__r = metroRequire;
  global.__d = define;
  global.__c = clear;
  global.__registerSegment = registerSegment;
  var modules = clear();
  var EMPTY = {};
  var _ref = {},
      hasOwnProperty = _ref.hasOwnProperty;

  if (__DEV__) {
    global.$RefreshReg$ = function () {};

    global.$RefreshSig$ = function () {
      return function (type) {
        return type;
      };
    };
  }

  function clear() {
    modules = Object.create(null);
    return modules;
  }

  if (__DEV__) {
    var verboseNamesToModuleIds = Object.create(null);
    var initializingModuleIds = [];
  }

  function define(factory, moduleId, dependencyMap) {
    if (modules[moduleId] != null) {
      if (__DEV__) {
        var inverseDependencies = arguments[4];

        if (inverseDependencies) {
          global.__accept(moduleId, factory, dependencyMap, inverseDependencies);
        }
      }

      return;
    }

    var mod = {
      dependencyMap: dependencyMap,
      factory: factory,
      hasError: false,
      importedAll: EMPTY,
      importedDefault: EMPTY,
      isInitialized: false,
      publicModule: {
        exports: {}
      }
    };
    modules[moduleId] = mod;

    if (__DEV__) {
      mod.hot = createHotReloadingObject();
      var verboseName = arguments[3];

      if (verboseName) {
        mod.verboseName = verboseName;
        verboseNamesToModuleIds[verboseName] = moduleId;
      }
    }
  }

  function metroRequire(moduleId) {
    if (__DEV__ && typeof moduleId === "string") {
      var verboseName = moduleId;
      moduleId = verboseNamesToModuleIds[verboseName];

      if (moduleId == null) {
        throw new Error("Unknown named module: \"" + verboseName + "\"");
      } else {
        console.warn("Requiring module \"" + verboseName + "\" by name is only supported for " + "debugging purposes and will BREAK IN PRODUCTION!");
      }
    }

    var moduleIdReallyIsNumber = moduleId;

    if (__DEV__) {
      var initializingIndex = initializingModuleIds.indexOf(moduleIdReallyIsNumber);

      if (initializingIndex !== -1) {
        var cycle = initializingModuleIds.slice(initializingIndex).map(function (id) {
          return modules[id] ? modules[id].verboseName : "[unknown]";
        });
        cycle.push(cycle[0]);
        console.warn("Require cycle: " + cycle.join(" -> ") + "\n\n" + "Require cycles are allowed, but can result in uninitialized values. " + "Consider refactoring to remove the need for a cycle.");
      }
    }

    var module = modules[moduleIdReallyIsNumber];
    return module && module.isInitialized ? module.publicModule.exports : guardedLoadModule(moduleIdReallyIsNumber, module);
  }

  function metroImportDefault(moduleId) {
    if (__DEV__ && typeof moduleId === "string") {
      var verboseName = moduleId;
      moduleId = verboseNamesToModuleIds[verboseName];
    }

    var moduleIdReallyIsNumber = moduleId;

    if (modules[moduleIdReallyIsNumber] && modules[moduleIdReallyIsNumber].importedDefault !== EMPTY) {
      return modules[moduleIdReallyIsNumber].importedDefault;
    }

    var exports = metroRequire(moduleIdReallyIsNumber);
    var importedDefault = exports && exports.__esModule ? exports.default : exports;
    return modules[moduleIdReallyIsNumber].importedDefault = importedDefault;
  }

  metroRequire.importDefault = metroImportDefault;

  function metroImportAll(moduleId) {
    if (__DEV__ && typeof moduleId === "string") {
      var verboseName = moduleId;
      moduleId = verboseNamesToModuleIds[verboseName];
    }

    var moduleIdReallyIsNumber = moduleId;

    if (modules[moduleIdReallyIsNumber] && modules[moduleIdReallyIsNumber].importedAll !== EMPTY) {
      return modules[moduleIdReallyIsNumber].importedAll;
    }

    var exports = metroRequire(moduleIdReallyIsNumber);
    var importedAll;

    if (exports && exports.__esModule) {
      importedAll = exports;
    } else {
      importedAll = {};

      if (exports) {
        for (var key in exports) {
          if (hasOwnProperty.call(exports, key)) {
            importedAll[key] = exports[key];
          }
        }
      }

      importedAll.default = exports;
    }

    return modules[moduleIdReallyIsNumber].importedAll = importedAll;
  }

  metroRequire.importAll = metroImportAll;
  var inGuard = false;

  function guardedLoadModule(moduleId, module) {
    if (!inGuard && global.ErrorUtils) {
      inGuard = true;
      var returnValue;

      try {
        returnValue = loadModuleImplementation(moduleId, module);
      } catch (e) {
        global.ErrorUtils.reportFatalError(e);
      }

      inGuard = false;
      return returnValue;
    } else {
      return loadModuleImplementation(moduleId, module);
    }
  }

  var ID_MASK_SHIFT = 16;
  var LOCAL_ID_MASK = ~0 >>> ID_MASK_SHIFT;

  function unpackModuleId(moduleId) {
    var segmentId = moduleId >>> ID_MASK_SHIFT;
    var localId = moduleId & LOCAL_ID_MASK;
    return {
      segmentId: segmentId,
      localId: localId
    };
  }

  metroRequire.unpackModuleId = unpackModuleId;

  function packModuleId(value) {
    return (value.segmentId << ID_MASK_SHIFT) + value.localId;
  }

  metroRequire.packModuleId = packModuleId;
  var moduleDefinersBySegmentID = [];

  function registerSegment(segmentID, moduleDefiner) {
    moduleDefinersBySegmentID[segmentID] = moduleDefiner;
  }

  function loadModuleImplementation(moduleId, module) {
    if (!module && moduleDefinersBySegmentID.length > 0) {
      var _unpackModuleId = unpackModuleId(moduleId),
          segmentId = _unpackModuleId.segmentId,
          localId = _unpackModuleId.localId;

      var definer = moduleDefinersBySegmentID[segmentId];

      if (definer != null) {
        definer(localId);
        module = modules[moduleId];
      }
    }

    var nativeRequire = global.nativeRequire;

    if (!module && nativeRequire) {
      var _unpackModuleId2 = unpackModuleId(moduleId),
          _segmentId = _unpackModuleId2.segmentId,
          _localId = _unpackModuleId2.localId;

      nativeRequire(_localId, _segmentId);
      module = modules[moduleId];
    }

    if (!module) {
      throw unknownModuleError(moduleId);
    }

    if (module.hasError) {
      throw moduleThrewError(moduleId, module.error);
    }

    if (__DEV__) {
      var Systrace = metroRequire.Systrace,
          Refresh = metroRequire.Refresh;
    }

    module.isInitialized = true;
    var _module = module,
        factory = _module.factory,
        dependencyMap = _module.dependencyMap;

    if (__DEV__) {
      initializingModuleIds.push(moduleId);
    }

    try {
      if (__DEV__) {
        Systrace.beginEvent("JS_require_" + (module.verboseName || moduleId));
      }

      var moduleObject = module.publicModule;

      if (__DEV__) {
        moduleObject.hot = module.hot;
        var prevRefreshReg = global.$RefreshReg$;
        var prevRefreshSig = global.$RefreshSig$;

        if (Refresh != null) {
          var RefreshRuntime = Refresh;

          global.$RefreshReg$ = function (type, id) {
            RefreshRuntime.register(type, moduleId + " " + id);
          };

          global.$RefreshSig$ = RefreshRuntime.createSignatureFunctionForTransform;
        }
      }

      moduleObject.id = moduleId;
      factory(global, metroRequire, metroImportDefault, metroImportAll, moduleObject, moduleObject.exports, dependencyMap);

      if (!__DEV__) {
        module.factory = undefined;
        module.dependencyMap = undefined;
      }

      if (__DEV__) {
        Systrace.endEvent();

        if (Refresh != null) {
          registerExportsForReactRefresh(Refresh, moduleObject.exports, moduleId);
        }
      }

      return moduleObject.exports;
    } catch (e) {
      module.hasError = true;
      module.error = e;
      module.isInitialized = false;
      module.publicModule.exports = undefined;
      throw e;
    } finally {
      if (__DEV__) {
        if (initializingModuleIds.pop() !== moduleId) {
          throw new Error("initializingModuleIds is corrupt; something is terribly wrong");
        }

        global.$RefreshReg$ = prevRefreshReg;
        global.$RefreshSig$ = prevRefreshSig;
      }
    }
  }

  function unknownModuleError(id) {
    var message = 'Requiring unknown module "' + id + '".';

    if (__DEV__) {
      message += " If you are sure the module exists, try restarting Metro. " + "You may also want to run `yarn` or `npm install`.";
    }

    return Error(message);
  }

  function moduleThrewError(id, error) {
    var displayName = __DEV__ && modules[id] && modules[id].verboseName || id;
    return Error('Requiring module "' + displayName + '", which threw an exception: ' + error);
  }

  if (__DEV__) {
    metroRequire.Systrace = {
      beginEvent: function beginEvent() {},
      endEvent: function endEvent() {}
    };

    metroRequire.getModules = function () {
      return modules;
    };

    var createHotReloadingObject = function createHotReloadingObject() {
      var hot = {
        _acceptCallback: null,
        _disposeCallback: null,
        _didAccept: false,
        accept: function accept(callback) {
          hot._didAccept = true;
          hot._acceptCallback = callback;
        },
        dispose: function dispose(callback) {
          hot._disposeCallback = callback;
        }
      };
      return hot;
    };

    var reactRefreshTimeout = null;

    var metroHotUpdateModule = function metroHotUpdateModule(id, factory, dependencyMap, inverseDependencies) {
      var mod = modules[id];

      if (!mod) {
        if (factory) {
          return;
        }

        throw unknownModuleError(id);
      }

      if (!mod.hasError && !mod.isInitialized) {
        mod.factory = factory;
        mod.dependencyMap = dependencyMap;
        return;
      }

      var Refresh = metroRequire.Refresh;
      var pendingModuleIDs = [id];
      var updatedModuleIDs = [];
      var seenModuleIDs = new Set();
      var refreshBoundaryIDs = new Set();

      while (pendingModuleIDs.length > 0) {
        var pendingID = pendingModuleIDs.pop();

        if (seenModuleIDs.has(pendingID)) {
          continue;
        }

        seenModuleIDs.add(pendingID);
        var pendingModule = modules[pendingID];

        if (pendingModule != null) {
          var pendingHot = pendingModule.hot;

          if (pendingHot == null) {
            throw new Error("[Refresh] Expected module.hot to always exist in DEV.");
          }

          var canAccept = pendingHot._didAccept;

          if (!canAccept && Refresh != null) {
            var isBoundary = isReactRefreshBoundary(Refresh, pendingModule.publicModule.exports);

            if (isBoundary) {
              canAccept = true;
              refreshBoundaryIDs.add(pendingID);
            }
          }

          if (canAccept) {
            updatedModuleIDs.push(pendingID);
            continue;
          }
        }

        var parentIDs = inverseDependencies[pendingID];

        if (parentIDs.length === 0) {
          performFullRefresh();
          return;
        }

        updatedModuleIDs.push(pendingID);
        parentIDs.forEach(function (parentID) {
          return pendingModuleIDs.push(parentID);
        });
      }

      seenModuleIDs.clear();

      for (var i = 0; i < updatedModuleIDs.length; i++) {
        var updatedID = updatedModuleIDs[i];

        if (seenModuleIDs.has(updatedID)) {
          continue;
        }

        seenModuleIDs.add(updatedID);
        var _mod = modules[updatedID];

        if (_mod == null) {
          throw new Error("[Refresh] Expected to find the updated module.");
        }

        var prevExports = _mod.publicModule.exports;
        var didError = runUpdatedModule(updatedID, updatedID === id ? factory : undefined, updatedID === id ? dependencyMap : undefined);
        var nextExports = _mod.publicModule.exports;

        if (didError) {
          return;
        }

        if (refreshBoundaryIDs.has(updatedID)) {
          var isNoLongerABoundary = !isReactRefreshBoundary(Refresh, nextExports);
          var didInvalidate = shouldInvalidateReactRefreshBoundary(Refresh, prevExports, nextExports);

          if (isNoLongerABoundary || didInvalidate) {
            var _parentIDs = inverseDependencies[updatedID];

            if (_parentIDs.length === 0) {
              performFullRefresh();
              return;
            }

            for (var j = 0; j < _parentIDs.length; j++) {
              var parentID = _parentIDs[j];
              var parentMod = modules[parentID];

              if (parentMod == null) {
                throw new Error("[Refresh] Expected to find parent module.");
              }

              var canAcceptParent = isReactRefreshBoundary(Refresh, parentMod.publicModule.exports);

              if (canAcceptParent) {
                refreshBoundaryIDs.add(parentID);
                updatedModuleIDs.push(parentID);
              } else {
                performFullRefresh();
                return;
              }
            }
          }
        }
      }

      if (Refresh != null) {
        if (reactRefreshTimeout == null) {
          reactRefreshTimeout = setTimeout(function () {
            reactRefreshTimeout = null;
            Refresh.performReactRefresh();
          }, 30);
        }
      }
    };

    var runUpdatedModule = function runUpdatedModule(id, factory, dependencyMap) {
      var mod = modules[id];

      if (mod == null) {
        throw new Error("[Refresh] Expected to find the module.");
      }

      var hot = mod.hot;

      if (!hot) {
        throw new Error("[Refresh] Expected module.hot to always exist in DEV.");
      }

      if (hot._disposeCallback) {
        try {
          hot._disposeCallback();
        } catch (error) {
          console.error("Error while calling dispose handler for module " + id + ": ", error);
        }
      }

      if (factory) {
        mod.factory = factory;
      }

      if (dependencyMap) {
        mod.dependencyMap = dependencyMap;
      }

      mod.hasError = false;
      mod.error = undefined;
      mod.importedAll = EMPTY;
      mod.importedDefault = EMPTY;
      mod.isInitialized = false;
      var prevExports = mod.publicModule.exports;
      mod.publicModule.exports = {};
      hot._didAccept = false;
      hot._acceptCallback = null;
      hot._disposeCallback = null;
      metroRequire(id);

      if (mod.hasError) {
        mod.hasError = false;
        mod.isInitialized = true;
        mod.error = null;
        mod.publicModule.exports = prevExports;
        return true;
      }

      if (hot._acceptCallback) {
        try {
          hot._acceptCallback();
        } catch (error) {
          console.error("Error while calling accept handler for module " + id + ": ", error);
        }
      }

      return false;
    };

    var performFullRefresh = function performFullRefresh() {
      if (typeof window !== "undefined" && window.location != null && typeof window.location.reload === "function") {
        window.location.reload();
      } else {
        var Refresh = metroRequire.Refresh;

        if (Refresh != null) {
          Refresh.performFullRefresh();
        } else {
          console.warn("Could not reload the application after an edit.");
        }
      }
    };

    var isReactRefreshBoundary = function isReactRefreshBoundary(Refresh, moduleExports) {
      if (Refresh.isLikelyComponentType(moduleExports)) {
        return true;
      }

      if (moduleExports == null || typeof moduleExports !== "object") {
        return false;
      }

      var hasExports = false;
      var areAllExportsComponents = true;

      for (var key in moduleExports) {
        hasExports = true;

        if (key === "__esModule") {
          continue;
        }

        var desc = Object.getOwnPropertyDescriptor(moduleExports, key);

        if (desc && desc.get) {
          return false;
        }

        var exportValue = moduleExports[key];

        if (!Refresh.isLikelyComponentType(exportValue)) {
          areAllExportsComponents = false;
        }
      }

      return hasExports && areAllExportsComponents;
    };

    var shouldInvalidateReactRefreshBoundary = function shouldInvalidateReactRefreshBoundary(Refresh, prevExports, nextExports) {
      var prevSignature = getRefreshBoundarySignature(Refresh, prevExports);
      var nextSignature = getRefreshBoundarySignature(Refresh, nextExports);

      if (prevSignature.length !== nextSignature.length) {
        return true;
      }

      for (var i = 0; i < nextSignature.length; i++) {
        if (prevSignature[i] !== nextSignature[i]) {
          return true;
        }
      }

      return false;
    };

    var getRefreshBoundarySignature = function getRefreshBoundarySignature(Refresh, moduleExports) {
      var signature = [];
      signature.push(Refresh.getFamilyByType(moduleExports));

      if (moduleExports == null || typeof moduleExports !== "object") {
        return signature;
      }

      for (var key in moduleExports) {
        if (key === "__esModule") {
          continue;
        }

        var desc = Object.getOwnPropertyDescriptor(moduleExports, key);

        if (desc && desc.get) {
          continue;
        }

        var exportValue = moduleExports[key];
        signature.push(key);
        signature.push(Refresh.getFamilyByType(exportValue));
      }

      return signature;
    };

    var registerExportsForReactRefresh = function registerExportsForReactRefresh(Refresh, moduleExports, moduleID) {
      Refresh.register(moduleExports, moduleID + " %exports%");

      if (moduleExports == null || typeof moduleExports !== "object") {
        return;
      }

      for (var key in moduleExports) {
        var desc = Object.getOwnPropertyDescriptor(moduleExports, key);

        if (desc && desc.get) {
          continue;
        }

        var exportValue = moduleExports[key];
        var typeID = moduleID + " %exports% " + key;
        Refresh.register(exportValue, typeID);
      }
    };

    global.__accept = metroHotUpdateModule;
  }
})(typeof globalThis !== 'undefined' ? globalThis : typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : this);
(function (global) {
  var inspect = function () {
    function inspect(obj, opts) {
      var ctx = {
        seen: [],
        formatValueCalls: 0,
        stylize: stylizeNoColor
      };
      return formatValue(ctx, obj, opts.depth);
    }

    function stylizeNoColor(str, styleType) {
      return str;
    }

    function arrayToHash(array) {
      var hash = {};
      array.forEach(function (val, idx) {
        hash[val] = true;
      });
      return hash;
    }

    function formatValue(ctx, value, recurseTimes) {
      ctx.formatValueCalls++;

      if (ctx.formatValueCalls > 200) {
        return "[TOO BIG formatValueCalls " + ctx.formatValueCalls + " exceeded limit of 200]";
      }

      var primitive = formatPrimitive(ctx, value);

      if (primitive) {
        return primitive;
      }

      var keys = Object.keys(value);
      var visibleKeys = arrayToHash(keys);

      if (isError(value) && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {
        return formatError(value);
      }

      if (keys.length === 0) {
        if (isFunction(value)) {
          var name = value.name ? ': ' + value.name : '';
          return ctx.stylize('[Function' + name + ']', 'special');
        }

        if (isRegExp(value)) {
          return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
        }

        if (isDate(value)) {
          return ctx.stylize(Date.prototype.toString.call(value), 'date');
        }

        if (isError(value)) {
          return formatError(value);
        }
      }

      var base = '',
          array = false,
          braces = ['{', '}'];

      if (isArray(value)) {
        array = true;
        braces = ['[', ']'];
      }

      if (isFunction(value)) {
        var n = value.name ? ': ' + value.name : '';
        base = ' [Function' + n + ']';
      }

      if (isRegExp(value)) {
        base = ' ' + RegExp.prototype.toString.call(value);
      }

      if (isDate(value)) {
        base = ' ' + Date.prototype.toUTCString.call(value);
      }

      if (isError(value)) {
        base = ' ' + formatError(value);
      }

      if (keys.length === 0 && (!array || value.length == 0)) {
        return braces[0] + base + braces[1];
      }

      if (recurseTimes < 0) {
        if (isRegExp(value)) {
          return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
        } else {
          return ctx.stylize('[Object]', 'special');
        }
      }

      ctx.seen.push(value);
      var output;

      if (array) {
        output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
      } else {
        output = keys.map(function (key) {
          return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
        });
      }

      ctx.seen.pop();
      return reduceToSingleString(output, base, braces);
    }

    function formatPrimitive(ctx, value) {
      if (isUndefined(value)) return ctx.stylize('undefined', 'undefined');

      if (isString(value)) {
        var simple = "'" + JSON.stringify(value).replace(/^"|"$/g, '').replace(/'/g, "\\'").replace(/\\"/g, '"') + "'";
        return ctx.stylize(simple, 'string');
      }

      if (isNumber(value)) return ctx.stylize('' + value, 'number');
      if (isBoolean(value)) return ctx.stylize('' + value, 'boolean');
      if (isNull(value)) return ctx.stylize('null', 'null');
    }

    function formatError(value) {
      return '[' + Error.prototype.toString.call(value) + ']';
    }

    function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
      var output = [];

      for (var i = 0, l = value.length; i < l; ++i) {
        if (hasOwnProperty(value, String(i))) {
          output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, String(i), true));
        } else {
          output.push('');
        }
      }

      keys.forEach(function (key) {
        if (!key.match(/^\d+$/)) {
          output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, key, true));
        }
      });
      return output;
    }

    function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
      var name, str, desc;
      desc = Object.getOwnPropertyDescriptor(value, key) || {
        value: value[key]
      };

      if (desc.get) {
        if (desc.set) {
          str = ctx.stylize('[Getter/Setter]', 'special');
        } else {
          str = ctx.stylize('[Getter]', 'special');
        }
      } else {
        if (desc.set) {
          str = ctx.stylize('[Setter]', 'special');
        }
      }

      if (!hasOwnProperty(visibleKeys, key)) {
        name = '[' + key + ']';
      }

      if (!str) {
        if (ctx.seen.indexOf(desc.value) < 0) {
          if (isNull(recurseTimes)) {
            str = formatValue(ctx, desc.value, null);
          } else {
            str = formatValue(ctx, desc.value, recurseTimes - 1);
          }

          if (str.indexOf('\n') > -1) {
            if (array) {
              str = str.split('\n').map(function (line) {
                return '  ' + line;
              }).join('\n').substr(2);
            } else {
              str = '\n' + str.split('\n').map(function (line) {
                return '   ' + line;
              }).join('\n');
            }
          }
        } else {
          str = ctx.stylize('[Circular]', 'special');
        }
      }

      if (isUndefined(name)) {
        if (array && key.match(/^\d+$/)) {
          return str;
        }

        name = JSON.stringify('' + key);

        if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
          name = name.substr(1, name.length - 2);
          name = ctx.stylize(name, 'name');
        } else {
          name = name.replace(/'/g, "\\'").replace(/\\"/g, '"').replace(/(^"|"$)/g, "'");
          name = ctx.stylize(name, 'string');
        }
      }

      return name + ': ' + str;
    }

    function reduceToSingleString(output, base, braces) {
      var numLinesEst = 0;
      var length = output.reduce(function (prev, cur) {
        numLinesEst++;
        if (cur.indexOf('\n') >= 0) numLinesEst++;
        return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1;
      }, 0);

      if (length > 60) {
        return braces[0] + (base === '' ? '' : base + '\n ') + ' ' + output.join(',\n  ') + ' ' + braces[1];
      }

      return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
    }

    function isArray(ar) {
      return Array.isArray(ar);
    }

    function isBoolean(arg) {
      return typeof arg === 'boolean';
    }

    function isNull(arg) {
      return arg === null;
    }

    function isNullOrUndefined(arg) {
      return arg == null;
    }

    function isNumber(arg) {
      return typeof arg === 'number';
    }

    function isString(arg) {
      return typeof arg === 'string';
    }

    function isSymbol(arg) {
      return typeof arg === 'symbol';
    }

    function isUndefined(arg) {
      return arg === void 0;
    }

    function isRegExp(re) {
      return isObject(re) && objectToString(re) === '[object RegExp]';
    }

    function isObject(arg) {
      return typeof arg === 'object' && arg !== null;
    }

    function isDate(d) {
      return isObject(d) && objectToString(d) === '[object Date]';
    }

    function isError(e) {
      return isObject(e) && (objectToString(e) === '[object Error]' || e instanceof Error);
    }

    function isFunction(arg) {
      return typeof arg === 'function';
    }

    function objectToString(o) {
      return Object.prototype.toString.call(o);
    }

    function hasOwnProperty(obj, prop) {
      return Object.prototype.hasOwnProperty.call(obj, prop);
    }

    return inspect;
  }();

  var OBJECT_COLUMN_NAME = '(index)';
  var LOG_LEVELS = {
    trace: 0,
    info: 1,
    warn: 2,
    error: 3
  };
  var INSPECTOR_LEVELS = [];
  INSPECTOR_LEVELS[LOG_LEVELS.trace] = 'debug';
  INSPECTOR_LEVELS[LOG_LEVELS.info] = 'log';
  INSPECTOR_LEVELS[LOG_LEVELS.warn] = 'warning';
  INSPECTOR_LEVELS[LOG_LEVELS.error] = 'error';
  var INSPECTOR_FRAMES_TO_SKIP = __DEV__ ? 2 : 1;

  function getNativeLogFunction(level) {
    return function () {
      var str;

      if (arguments.length === 1 && typeof arguments[0] === 'string') {
        str = arguments[0];
      } else {
        str = Array.prototype.map.call(arguments, function (arg) {
          return inspect(arg, {
            depth: 10
          });
        }).join(', ');
      }

      var logLevel = level;

      if (str.slice(0, 9) === 'Warning: ' && logLevel >= LOG_LEVELS.error) {
        logLevel = LOG_LEVELS.warn;
      }

      if (global.__inspectorLog) {
        global.__inspectorLog(INSPECTOR_LEVELS[logLevel], str, [].slice.call(arguments), INSPECTOR_FRAMES_TO_SKIP);
      }

      if (groupStack.length) {
        str = groupFormat('', str);
      }

      global.nativeLoggingHook(str, logLevel);
    };
  }

  function repeat(element, n) {
    return Array.apply(null, Array(n)).map(function () {
      return element;
    });
  }

  function consoleTablePolyfill(rows) {
    if (!Array.isArray(rows)) {
      var data = rows;
      rows = [];

      for (var key in data) {
        if (data.hasOwnProperty(key)) {
          var row = data[key];
          row[OBJECT_COLUMN_NAME] = key;
          rows.push(row);
        }
      }
    }

    if (rows.length === 0) {
      global.nativeLoggingHook('', LOG_LEVELS.info);
      return;
    }

    var columns = Object.keys(rows[0]).sort();
    var stringRows = [];
    var columnWidths = [];
    columns.forEach(function (k, i) {
      columnWidths[i] = k.length;

      for (var j = 0; j < rows.length; j++) {
        var cellStr = (rows[j][k] || '?').toString();
        stringRows[j] = stringRows[j] || [];
        stringRows[j][i] = cellStr;
        columnWidths[i] = Math.max(columnWidths[i], cellStr.length);
      }
    });

    function joinRow(row, space) {
      var cells = row.map(function (cell, i) {
        var extraSpaces = repeat(' ', columnWidths[i] - cell.length).join('');
        return cell + extraSpaces;
      });
      space = space || ' ';
      return cells.join(space + '|' + space);
    }

    var separators = columnWidths.map(function (columnWidth) {
      return repeat('-', columnWidth).join('');
    });
    var separatorRow = joinRow(separators, '-');
    var header = joinRow(columns);
    var table = [header, separatorRow];

    for (var i = 0; i < rows.length; i++) {
      table.push(joinRow(stringRows[i]));
    }

    global.nativeLoggingHook('\n' + table.join('\n'), LOG_LEVELS.info);
  }

  var GROUP_PAD = "\u2502";
  var GROUP_OPEN = "\u2510";
  var GROUP_CLOSE = "\u2518";
  var groupStack = [];

  function groupFormat(prefix, msg) {
    return groupStack.join('') + prefix + ' ' + (msg || '');
  }

  function consoleGroupPolyfill(label) {
    global.nativeLoggingHook(groupFormat(GROUP_OPEN, label), LOG_LEVELS.info);
    groupStack.push(GROUP_PAD);
  }

  function consoleGroupCollapsedPolyfill(label) {
    global.nativeLoggingHook(groupFormat(GROUP_CLOSE, label), LOG_LEVELS.info);
    groupStack.push(GROUP_PAD);
  }

  function consoleGroupEndPolyfill() {
    groupStack.pop();
    global.nativeLoggingHook(groupFormat(GROUP_CLOSE), LOG_LEVELS.info);
  }

  function consoleAssertPolyfill(expression, label) {
    if (!expression) {
      global.nativeLoggingHook('Assertion failed: ' + label, LOG_LEVELS.error);
    }
  }

  if (global.nativeLoggingHook) {
    var originalConsole = global.console;

    if (__DEV__ && originalConsole) {
      var descriptor = Object.getOwnPropertyDescriptor(global, 'console');

      if (descriptor) {
        Object.defineProperty(global, 'originalConsole', descriptor);
      }
    }

    global.console = {
      error: getNativeLogFunction(LOG_LEVELS.error),
      info: getNativeLogFunction(LOG_LEVELS.info),
      log: getNativeLogFunction(LOG_LEVELS.info),
      warn: getNativeLogFunction(LOG_LEVELS.warn),
      trace: getNativeLogFunction(LOG_LEVELS.trace),
      debug: getNativeLogFunction(LOG_LEVELS.trace),
      table: consoleTablePolyfill,
      group: consoleGroupPolyfill,
      groupEnd: consoleGroupEndPolyfill,
      groupCollapsed: consoleGroupCollapsedPolyfill,
      assert: consoleAssertPolyfill
    };
    Object.defineProperty(console, '_isPolyfilled', {
      value: true,
      enumerable: false
    });

    if (__DEV__ && originalConsole) {
      Object.keys(console).forEach(function (methodName) {
        var reactNativeMethod = console[methodName];

        if (originalConsole[methodName]) {
          console[methodName] = function () {
            if (methodName === 'assert') {
              if (!arguments[0]) {
                originalConsole.assert.apply(originalConsole, arguments);
              }
            } else {
              originalConsole[methodName].apply(originalConsole, arguments);
            }

            reactNativeMethod.apply(console, arguments);
          };
        }
      });
      ['clear', 'dir', 'dirxml', 'groupCollapsed', 'profile', 'profileEnd'].forEach(function (methodName) {
        if (typeof originalConsole[methodName] === 'function') {
          console[methodName] = function () {
            originalConsole[methodName].apply(originalConsole, arguments);
          };
        }
      });
    }
  } else if (!global.console) {
    var log = global.print || function consoleLoggingStub() {};

    global.console = {
      error: log,
      info: log,
      log: log,
      warn: log,
      trace: log,
      debug: log,
      table: log
    };
    Object.defineProperty(console, '_isPolyfilled', {
      value: true,
      enumerable: false
    });
  }
})(typeof globalThis !== 'undefined' ? globalThis : typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : this);
(function (global) {
  var _inGuard = 0;

  var _globalHandler = function onError(e, isFatal) {
    throw e;
  };

  var ErrorUtils = {
    setGlobalHandler: function setGlobalHandler(fun) {
      _globalHandler = fun;
    },
    getGlobalHandler: function getGlobalHandler() {
      return _globalHandler;
    },
    reportError: function reportError(error) {
      _globalHandler && _globalHandler(error, false);
    },
    reportFatalError: function reportFatalError(error) {
      _globalHandler && _globalHandler(error, true);
    },
    applyWithGuard: function applyWithGuard(fun, context, args, unused_onError, unused_name) {
      try {
        _inGuard++;
        return fun.apply(context, args);
      } catch (e) {
        ErrorUtils.reportError(e);
      } finally {
        _inGuard--;
      }

      return null;
    },
    applyWithGuardIfNeeded: function applyWithGuardIfNeeded(fun, context, args) {
      if (ErrorUtils.inGuard()) {
        return fun.apply(context, args);
      } else {
        ErrorUtils.applyWithGuard(fun, context, args);
      }

      return null;
    },
    inGuard: function inGuard() {
      return !!_inGuard;
    },
    guard: function guard(fun, name, context) {
      var _ref;

      if (typeof fun !== 'function') {
        console.warn('A function must be passed to ErrorUtils.guard, got ', fun);
        return null;
      }

      var guardName = (_ref = name != null ? name : fun.name) != null ? _ref : '<generated guard>';

      function guarded() {
        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
          args[_key] = arguments[_key];
        }

        return ErrorUtils.applyWithGuard(fun, context != null ? context : this, args, null, guardName);
      }

      return guarded;
    }
  };
  global.ErrorUtils = ErrorUtils;
})(typeof globalThis !== 'undefined' ? globalThis : typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : this);
(function (global) {
  (function () {
    'use strict';

    var hasOwnProperty = Object.prototype.hasOwnProperty;

    if (typeof Object.entries !== 'function') {
      Object.entries = function (object) {
        if (object == null) {
          throw new TypeError('Object.entries called on non-object');
        }

        var entries = [];

        for (var key in object) {
          if (hasOwnProperty.call(object, key)) {
            entries.push([key, object[key]]);
          }
        }

        return entries;
      };
    }

    if (typeof Object.values !== 'function') {
      Object.values = function (object) {
        if (object == null) {
          throw new TypeError('Object.values called on non-object');
        }

        var values = [];

        for (var key in object) {
          if (hasOwnProperty.call(object, key)) {
            values.push(object[key]);
          }
        }

        return values;
      };
    }
  })();
})(typeof globalThis !== 'undefined' ? globalThis : typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : this);
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _reactNative = _$$_REQUIRE(_dependencyMap[1], "react-native");

  var _App = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "./src/App"));

  var _app = _$$_REQUIRE(_dependencyMap[3], "./app.json");

  _reactNative.AppRegistry.registerComponent(_app.name, function () {
    return _App.default;
  });
},0,[1,2,447,786],"index.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      "default": obj
    };
  }

  module.exports = _interopRequireDefault;
},1,[],"node_modules/@babel/runtime/helpers/interopRequireDefault.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var invariant = _$$_REQUIRE(_dependencyMap[0], "invariant");

  var warnOnce = _$$_REQUIRE(_dependencyMap[1], "../Utilities/warnOnce");

  module.exports = {
    get AccessibilityInfo() {
      return _$$_REQUIRE(_dependencyMap[2], "../Components/AccessibilityInfo/AccessibilityInfo");
    },

    get ActivityIndicator() {
      return _$$_REQUIRE(_dependencyMap[3], "../Components/ActivityIndicator/ActivityIndicator");
    },

    get ART() {
      warnOnce('art-moved', 'React Native ART has been extracted from react-native core and will be removed in a future release. ' + "It can now be installed and imported from '@react-native-community/art' instead of 'react-native'. " + 'See https://github.com/react-native-community/art');
      return _$$_REQUIRE(_dependencyMap[4], "../ART/ReactNativeART");
    },

    get Button() {
      return _$$_REQUIRE(_dependencyMap[5], "../Components/Button");
    },

    get CheckBox() {
      warnOnce('checkBox-moved', 'CheckBox has been extracted from react-native core and will be removed in a future release. ' + "It can now be installed and imported from '@react-native-community/checkbox' instead of 'react-native'. " + 'See https://github.com/react-native-community/react-native-checkbox');
      return _$$_REQUIRE(_dependencyMap[6], "../Components/CheckBox/CheckBox");
    },

    get DatePickerIOS() {
      warnOnce('DatePickerIOS-merged', 'DatePickerIOS has been merged with DatePickerAndroid and will be removed in a future release. ' + "It can now be installed and imported from '@react-native-community/datetimepicker' instead of 'react-native'. " + 'See https://github.com/react-native-community/react-native-datetimepicker');
      return _$$_REQUIRE(_dependencyMap[7], "../Components/DatePicker/DatePickerIOS");
    },

    get DrawerLayoutAndroid() {
      return _$$_REQUIRE(_dependencyMap[8], "../Components/DrawerAndroid/DrawerLayoutAndroid");
    },

    get FlatList() {
      return _$$_REQUIRE(_dependencyMap[9], "../Lists/FlatList");
    },

    get Image() {
      return _$$_REQUIRE(_dependencyMap[10], "../Image/Image");
    },

    get ImageBackground() {
      return _$$_REQUIRE(_dependencyMap[11], "../Image/ImageBackground");
    },

    get InputAccessoryView() {
      return _$$_REQUIRE(_dependencyMap[12], "../Components/TextInput/InputAccessoryView");
    },

    get KeyboardAvoidingView() {
      return _$$_REQUIRE(_dependencyMap[13], "../Components/Keyboard/KeyboardAvoidingView");
    },

    get MaskedViewIOS() {
      warnOnce('maskedviewios-moved', 'MaskedViewIOS has been extracted from react-native core and will be removed in a future release. ' + "It can now be installed and imported from '@react-native-community/masked-view' instead of 'react-native'. " + 'See https://github.com/react-native-community/react-native-masked-view');
      return _$$_REQUIRE(_dependencyMap[14], "../Components/MaskedView/MaskedViewIOS");
    },

    get Modal() {
      return _$$_REQUIRE(_dependencyMap[15], "../Modal/Modal");
    },

    get Picker() {
      return _$$_REQUIRE(_dependencyMap[16], "../Components/Picker/Picker");
    },

    get PickerIOS() {
      return _$$_REQUIRE(_dependencyMap[17], "../Components/Picker/PickerIOS");
    },

    get ProgressBarAndroid() {
      return _$$_REQUIRE(_dependencyMap[18], "../Components/ProgressBarAndroid/ProgressBarAndroid");
    },

    get ProgressViewIOS() {
      return _$$_REQUIRE(_dependencyMap[19], "../Components/ProgressViewIOS/ProgressViewIOS");
    },

    get SafeAreaView() {
      return _$$_REQUIRE(_dependencyMap[20], "../Components/SafeAreaView/SafeAreaView");
    },

    get ScrollView() {
      return _$$_REQUIRE(_dependencyMap[21], "../Components/ScrollView/ScrollView");
    },

    get SectionList() {
      return _$$_REQUIRE(_dependencyMap[22], "../Lists/SectionList");
    },

    get SegmentedControlIOS() {
      return _$$_REQUIRE(_dependencyMap[23], "../Components/SegmentedControlIOS/SegmentedControlIOS");
    },

    get Slider() {
      warnOnce('slider-moved', 'Slider has been extracted from react-native core and will be removed in a future release. ' + "It can now be installed and imported from '@react-native-community/slider' instead of 'react-native'. " + 'See https://github.com/react-native-community/react-native-slider');
      return _$$_REQUIRE(_dependencyMap[24], "../Components/Slider/Slider");
    },

    get Switch() {
      return _$$_REQUIRE(_dependencyMap[25], "../Components/Switch/Switch");
    },

    get RefreshControl() {
      return _$$_REQUIRE(_dependencyMap[26], "../Components/RefreshControl/RefreshControl");
    },

    get StatusBar() {
      return _$$_REQUIRE(_dependencyMap[27], "../Components/StatusBar/StatusBar");
    },

    get Text() {
      return _$$_REQUIRE(_dependencyMap[28], "../Text/Text");
    },

    get TextInput() {
      return _$$_REQUIRE(_dependencyMap[29], "../Components/TextInput/TextInput");
    },

    get Touchable() {
      return _$$_REQUIRE(_dependencyMap[30], "../Components/Touchable/Touchable");
    },

    get TouchableHighlight() {
      return _$$_REQUIRE(_dependencyMap[31], "../Components/Touchable/TouchableHighlight");
    },

    get TouchableNativeFeedback() {
      return _$$_REQUIRE(_dependencyMap[32], "../Components/Touchable/TouchableNativeFeedback");
    },

    get TouchableOpacity() {
      return _$$_REQUIRE(_dependencyMap[33], "../Components/Touchable/TouchableOpacity");
    },

    get TouchableWithoutFeedback() {
      return _$$_REQUIRE(_dependencyMap[34], "../Components/Touchable/TouchableWithoutFeedback");
    },

    get View() {
      return _$$_REQUIRE(_dependencyMap[35], "../Components/View/View");
    },

    get VirtualizedList() {
      return _$$_REQUIRE(_dependencyMap[36], "../Lists/VirtualizedList");
    },

    get VirtualizedSectionList() {
      return _$$_REQUIRE(_dependencyMap[37], "../Lists/VirtualizedSectionList");
    },

    get ActionSheetIOS() {
      return _$$_REQUIRE(_dependencyMap[38], "../ActionSheetIOS/ActionSheetIOS");
    },

    get Alert() {
      return _$$_REQUIRE(_dependencyMap[39], "../Alert/Alert");
    },

    get Animated() {
      return _$$_REQUIRE(_dependencyMap[40], "../Animated/src/Animated");
    },

    get AppRegistry() {
      return _$$_REQUIRE(_dependencyMap[41], "../ReactNative/AppRegistry");
    },

    get AppState() {
      return _$$_REQUIRE(_dependencyMap[42], "../AppState/AppState");
    },

    get AsyncStorage() {
      warnOnce('async-storage-moved', 'AsyncStorage has been extracted from react-native core and will be removed in a future release. ' + "It can now be installed and imported from '@react-native-community/async-storage' instead of 'react-native'. " + 'See https://github.com/react-native-community/react-native-async-storage');
      return _$$_REQUIRE(_dependencyMap[43], "../Storage/AsyncStorage");
    },

    get BackHandler() {
      return _$$_REQUIRE(_dependencyMap[44], "../Utilities/BackHandler");
    },

    get Clipboard() {
      return _$$_REQUIRE(_dependencyMap[45], "../Components/Clipboard/Clipboard");
    },

    get DatePickerAndroid() {
      warnOnce('DatePickerAndroid-merged', 'DatePickerAndroid has been merged with DatePickerIOS and will be removed in a future release. ' + "It can now be installed and imported from '@react-native-community/datetimepicker' instead of 'react-native'. " + 'See https://github.com/react-native-community/react-native-datetimepicker');
      return _$$_REQUIRE(_dependencyMap[46], "../Components/DatePickerAndroid/DatePickerAndroid");
    },

    get DeviceInfo() {
      return _$$_REQUIRE(_dependencyMap[47], "../Utilities/DeviceInfo");
    },

    get Dimensions() {
      return _$$_REQUIRE(_dependencyMap[48], "../Utilities/Dimensions");
    },

    get Easing() {
      return _$$_REQUIRE(_dependencyMap[49], "../Animated/src/Easing");
    },

    get findNodeHandle() {
      return _$$_REQUIRE(_dependencyMap[50], "../Renderer/shims/ReactNative").findNodeHandle;
    },

    get I18nManager() {
      return _$$_REQUIRE(_dependencyMap[51], "../ReactNative/I18nManager");
    },

    get ImagePickerIOS() {
      warnOnce('imagePickerIOS-moved', 'ImagePickerIOS has been extracted from react-native core and will be removed in a future release. ' + "Please upgrade to use either '@react-native-community/react-native-image-picker' or 'expo-image-picker'. " + "If you cannot upgrade to a different library, please install the deprecated '@react-native-community/image-picker-ios' package. " + 'See https://github.com/react-native-community/react-native-image-picker-ios');
      return _$$_REQUIRE(_dependencyMap[52], "../Image/ImagePickerIOS");
    },

    get InteractionManager() {
      return _$$_REQUIRE(_dependencyMap[53], "../Interaction/InteractionManager");
    },

    get Keyboard() {
      return _$$_REQUIRE(_dependencyMap[54], "../Components/Keyboard/Keyboard");
    },

    get LayoutAnimation() {
      return _$$_REQUIRE(_dependencyMap[55], "../LayoutAnimation/LayoutAnimation");
    },

    get Linking() {
      return _$$_REQUIRE(_dependencyMap[56], "../Linking/Linking");
    },

    get NativeDialogManagerAndroid() {
      return _$$_REQUIRE(_dependencyMap[57], "../NativeModules/specs/NativeDialogManagerAndroid").default;
    },

    get NativeEventEmitter() {
      return _$$_REQUIRE(_dependencyMap[58], "../EventEmitter/NativeEventEmitter");
    },

    get PanResponder() {
      return _$$_REQUIRE(_dependencyMap[59], "../Interaction/PanResponder");
    },

    get PermissionsAndroid() {
      return _$$_REQUIRE(_dependencyMap[60], "../PermissionsAndroid/PermissionsAndroid");
    },

    get PixelRatio() {
      return _$$_REQUIRE(_dependencyMap[61], "../Utilities/PixelRatio");
    },

    get PushNotificationIOS() {
      warnOnce('pushNotificationIOS-moved', 'PushNotificationIOS has been extracted from react-native core and will be removed in a future release. ' + "It can now be installed and imported from '@react-native-community/push-notification-ios' instead of 'react-native'. " + 'See https://github.com/react-native-community/react-native-push-notification-ios');
      return _$$_REQUIRE(_dependencyMap[62], "../PushNotificationIOS/PushNotificationIOS");
    },

    get Settings() {
      return _$$_REQUIRE(_dependencyMap[63], "../Settings/Settings");
    },

    get Share() {
      return _$$_REQUIRE(_dependencyMap[64], "../Share/Share");
    },

    get StatusBarIOS() {
      warnOnce('StatusBarIOS-merged', 'StatusBarIOS has been merged with StatusBar and will be removed in a future release. Use StatusBar for mutating the status bar');
      return _$$_REQUIRE(_dependencyMap[65], "../Components/StatusBar/StatusBarIOS");
    },

    get StyleSheet() {
      return _$$_REQUIRE(_dependencyMap[66], "../StyleSheet/StyleSheet");
    },

    get Systrace() {
      return _$$_REQUIRE(_dependencyMap[67], "../Performance/Systrace");
    },

    get TimePickerAndroid() {
      warnOnce('TimePickerAndroid-merged', 'TimePickerAndroid has been merged with DatePickerIOS and DatePickerAndroid and will be removed in a future release. ' + "It can now be installed and imported from '@react-native-community/datetimepicker' instead of 'react-native'. " + 'See https://github.com/react-native-community/react-native-datetimepicker');
      return _$$_REQUIRE(_dependencyMap[68], "../Components/TimePickerAndroid/TimePickerAndroid");
    },

    get ToastAndroid() {
      return _$$_REQUIRE(_dependencyMap[69], "../Components/ToastAndroid/ToastAndroid");
    },

    get TurboModuleRegistry() {
      return _$$_REQUIRE(_dependencyMap[70], "../TurboModule/TurboModuleRegistry");
    },

    get TVEventHandler() {
      return _$$_REQUIRE(_dependencyMap[71], "../Components/AppleTV/TVEventHandler");
    },

    get UIManager() {
      return _$$_REQUIRE(_dependencyMap[72], "../ReactNative/UIManager");
    },

    get unstable_batchedUpdates() {
      return _$$_REQUIRE(_dependencyMap[50], "../Renderer/shims/ReactNative").unstable_batchedUpdates;
    },

    get useWindowDimensions() {
      return _$$_REQUIRE(_dependencyMap[73], "../Utilities/useWindowDimensions").default;
    },

    get UTFSequence() {
      return _$$_REQUIRE(_dependencyMap[74], "../UTFSequence");
    },

    get Vibration() {
      return _$$_REQUIRE(_dependencyMap[75], "../Vibration/Vibration");
    },

    get YellowBox() {
      return _$$_REQUIRE(_dependencyMap[76], "../YellowBox/YellowBox");
    },

    get DeviceEventEmitter() {
      return _$$_REQUIRE(_dependencyMap[77], "../EventEmitter/RCTDeviceEventEmitter");
    },

    get NativeAppEventEmitter() {
      return _$$_REQUIRE(_dependencyMap[78], "../EventEmitter/RCTNativeAppEventEmitter");
    },

    get NativeModules() {
      return _$$_REQUIRE(_dependencyMap[79], "../BatchedBridge/NativeModules");
    },

    get Platform() {
      return _$$_REQUIRE(_dependencyMap[80], "../Utilities/Platform");
    },

    get processColor() {
      return _$$_REQUIRE(_dependencyMap[81], "../StyleSheet/processColor");
    },

    get requireNativeComponent() {
      return _$$_REQUIRE(_dependencyMap[82], "../ReactNative/requireNativeComponent");
    },

    get unstable_RootTagContext() {
      return _$$_REQUIRE(_dependencyMap[83], "../ReactNative/RootTagContext");
    },

    get ColorPropType() {
      return _$$_REQUIRE(_dependencyMap[84], "../DeprecatedPropTypes/DeprecatedColorPropType");
    },

    get EdgeInsetsPropType() {
      return _$$_REQUIRE(_dependencyMap[85], "../DeprecatedPropTypes/DeprecatedEdgeInsetsPropType");
    },

    get PointPropType() {
      return _$$_REQUIRE(_dependencyMap[86], "../DeprecatedPropTypes/DeprecatedPointPropType");
    },

    get ViewPropTypes() {
      return _$$_REQUIRE(_dependencyMap[87], "../DeprecatedPropTypes/DeprecatedViewPropTypes");
    }

  };

  if (__DEV__) {
    Object.defineProperty(module.exports, 'ListView', {
      configurable: true,
      get: function get() {
        invariant(false, 'ListView has been removed from React Native. ' + 'See https://fb.me/nolistview for more information or use ' + '`deprecated-react-native-listview`.');
      }
    });
    Object.defineProperty(module.exports, 'SwipeableListView', {
      configurable: true,
      get: function get() {
        invariant(false, 'SwipeableListView has been removed from React Native. ' + 'See https://fb.me/nolistview for more information or use ' + '`deprecated-react-native-swipeable-listview`.');
      }
    });
    Object.defineProperty(module.exports, 'WebView', {
      configurable: true,
      get: function get() {
        invariant(false, 'WebView has been removed from React Native. ' + "It can now be installed and imported from 'react-native-webview' instead of 'react-native'. " + 'See https://github.com/react-native-community/react-native-webview');
      }
    });
    Object.defineProperty(module.exports, 'NetInfo', {
      configurable: true,
      get: function get() {
        invariant(false, 'NetInfo has been removed from React Native. ' + "It can now be installed and imported from 'react-native-netinfo' instead of 'react-native'. " + 'See https://github.com/react-native-community/react-native-netinfo');
      }
    });
    Object.defineProperty(module.exports, 'CameraRoll', {
      configurable: true,
      get: function get() {
        invariant(false, 'CameraRoll has been removed from React Native. ' + "It can now be installed and imported from 'react-native-cameraroll' instead of 'react-native'. " + 'See https://github.com/react-native-community/react-native-cameraroll');
      }
    });
    Object.defineProperty(module.exports, 'ImageStore', {
      configurable: true,
      get: function get() {
        invariant(false, 'ImageStore has been removed from React Native. ' + 'To get a base64-encoded string from a local image use either of the following third-party libraries:' + "* expo-file-system: `readAsStringAsync(filepath, 'base64')`" + "* react-native-fs: `readFile(filepath, 'base64')`");
      }
    });
    Object.defineProperty(module.exports, 'ImageEditor', {
      configurable: true,
      get: function get() {
        invariant(false, 'ImageEditor has been removed from React Native. ' + "It can now be installed and imported from 'react-native-image-editor' instead of 'react-native'. " + 'See https://github.com/react-native-community/react-native-image-editor');
      }
    });
    Object.defineProperty(module.exports, 'ViewPagerAndroid', {
      configurable: true,
      get: function get() {
        invariant(false, 'ViewPagerAndroid has been removed from React Native. ' + "It can now be installed and imported from 'react-native-viewpager' instead of 'react-native'. " + 'See https://github.com/react-native-community/react-native-viewpager');
      }
    });
  }
},2,[3,4,7,51,224,234,326,329,330,293,314,335,336,338,339,341,383,387,220,388,366,300,321,389,390,392,297,333,235,395,241,357,250,260,251,86,294,322,403,148,261,405,180,420,415,422,424,426,62,289,88,351,427,270,304,306,429,149,134,431,433,61,435,437,438,440,60,27,441,171,11,245,43,443,373,444,364,31,158,12,48,80,218,345,66,237,446,315],"node_modules/react-native/Libraries/react-native/react-native-implementation.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var invariant = function invariant(condition, format, a, b, c, d, e, f) {
    if (process.env.NODE_ENV !== 'production') {
      if (format === undefined) {
        throw new Error('invariant requires an error message argument');
      }
    }

    if (!condition) {
      var error;

      if (format === undefined) {
        error = new Error('Minified exception occurred; use the non-minified dev environment ' + 'for the full error message and additional helpful warnings.');
      } else {
        var args = [a, b, c, d, e, f];
        var argIndex = 0;
        error = new Error(format.replace(/%s/g, function () {
          return args[argIndex++];
        }));
        error.name = 'Invariant Violation';
      }

      error.framesToPop = 1;
      throw error;
    }
  };

  module.exports = invariant;
},3,[],"node_modules/invariant/browser.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var warning = _$$_REQUIRE(_dependencyMap[0], "fbjs/lib/warning");

  var warnedKeys = {};

  function warnOnce(key, message) {
    if (warnedKeys[key]) {
      return;
    }

    warning(false, message);
    warnedKeys[key] = true;
  }

  module.exports = warnOnce;
},4,[5],"node_modules/react-native/Libraries/Utilities/warnOnce.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var emptyFunction = _$$_REQUIRE(_dependencyMap[0], "./emptyFunction");

  function printWarning(format) {
    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
      args[_key - 1] = arguments[_key];
    }

    var argIndex = 0;
    var message = 'Warning: ' + format.replace(/%s/g, function () {
      return args[argIndex++];
    });

    if (typeof console !== 'undefined') {
      console.error(message);
    }

    try {
      throw new Error(message);
    } catch (x) {}
  }

  var warning = process.env.NODE_ENV !== "production" ? function (condition, format) {
    if (format === undefined) {
      throw new Error('`warning(condition, format, ...args)` requires a warning ' + 'message argument');
    }

    if (!condition) {
      for (var _len2 = arguments.length, args = new Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
        args[_key2 - 2] = arguments[_key2];
      }

      printWarning.apply(void 0, [format].concat(args));
    }
  } : emptyFunction;
  module.exports = warning;
},5,[6],"node_modules/fbjs/lib/warning.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  "use strict";

  function makeEmptyFunction(arg) {
    return function () {
      return arg;
    };
  }

  var emptyFunction = function emptyFunction() {};

  emptyFunction.thatReturns = makeEmptyFunction;
  emptyFunction.thatReturnsFalse = makeEmptyFunction(false);
  emptyFunction.thatReturnsTrue = makeEmptyFunction(true);
  emptyFunction.thatReturnsNull = makeEmptyFunction(null);

  emptyFunction.thatReturnsThis = function () {
    return this;
  };

  emptyFunction.thatReturnsArgument = function (arg) {
    return arg;
  };

  module.exports = emptyFunction;
},6,[],"node_modules/fbjs/lib/emptyFunction.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _NativeAccessibilityInfo = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./NativeAccessibilityInfo"));

  var RCTDeviceEventEmitter = _$$_REQUIRE(_dependencyMap[2], "../../EventEmitter/RCTDeviceEventEmitter");

  var UIManager = _$$_REQUIRE(_dependencyMap[3], "../../ReactNative/UIManager");

  var REDUCE_MOTION_EVENT = 'reduceMotionDidChange';
  var TOUCH_EXPLORATION_EVENT = 'touchExplorationDidChange';

  var _subscriptions = new Map();

  var AccessibilityInfo = {
    isBoldTextEnabled: function isBoldTextEnabled() {
      return Promise.resolve(false);
    },
    isGrayscaleEnabled: function isGrayscaleEnabled() {
      return Promise.resolve(false);
    },
    isInvertColorsEnabled: function isInvertColorsEnabled() {
      return Promise.resolve(false);
    },
    isReduceMotionEnabled: function isReduceMotionEnabled() {
      return new Promise(function (resolve, reject) {
        if (_NativeAccessibilityInfo.default) {
          _NativeAccessibilityInfo.default.isReduceMotionEnabled(resolve);
        } else {
          reject(false);
        }
      });
    },
    isReduceTransparencyEnabled: function isReduceTransparencyEnabled() {
      return Promise.resolve(false);
    },
    isScreenReaderEnabled: function isScreenReaderEnabled() {
      return new Promise(function (resolve, reject) {
        if (_NativeAccessibilityInfo.default) {
          _NativeAccessibilityInfo.default.isTouchExplorationEnabled(resolve);
        } else {
          reject(false);
        }
      });
    },

    get fetch() {
      return this.isScreenReaderEnabled;
    },

    addEventListener: function addEventListener(eventName, handler) {
      var listener;

      if (eventName === 'change' || eventName === 'screenReaderChanged') {
        listener = RCTDeviceEventEmitter.addListener(TOUCH_EXPLORATION_EVENT, function (enabled) {
          handler(enabled);
        });
      } else if (eventName === 'reduceMotionChanged') {
        listener = RCTDeviceEventEmitter.addListener(REDUCE_MOTION_EVENT, function (enabled) {
          handler(enabled);
        });
      }

      _subscriptions.set(handler, listener);
    },
    removeEventListener: function removeEventListener(eventName, handler) {
      var listener = _subscriptions.get(handler);

      if (!listener) {
        return;
      }

      listener.remove();

      _subscriptions.delete(handler);
    },
    setAccessibilityFocus: function setAccessibilityFocus(reactTag) {
      UIManager.sendAccessibilityEvent(reactTag, UIManager.getConstants().AccessibilityEventTypes.typeViewFocused);
    },
    announceForAccessibility: function announceForAccessibility(announcement) {
      if (_NativeAccessibilityInfo.default) {
        _NativeAccessibilityInfo.default.announceForAccessibility(announcement);
      }
    }
  };
  module.exports = AccessibilityInfo;
},7,[1,8,31,43],"node_modules/react-native/Libraries/Components/AccessibilityInfo/AccessibilityInfo.android.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireWildcard");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[1], "../../TurboModule/TurboModuleRegistry"));

  var _default = TurboModuleRegistry.get('AccessibilityInfo');

  exports.default = _default;
},8,[9,11],"node_modules/react-native/Libraries/Components/AccessibilityInfo/NativeAccessibilityInfo.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _typeof = _$$_REQUIRE(_dependencyMap[0], "../helpers/typeof");

  function _getRequireWildcardCache() {
    if (typeof WeakMap !== "function") return null;
    var cache = new WeakMap();

    _getRequireWildcardCache = function _getRequireWildcardCache() {
      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;
  }

  module.exports = _interopRequireWildcard;
},9,[10],"node_modules/@babel/runtime/helpers/interopRequireWildcard.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  function _typeof(obj) {
    if (typeof Symbol === "function" && typeof (typeof Symbol === "function" ? Symbol.iterator : "@@iterator") === "symbol") {
      module.exports = _typeof = function _typeof(obj) {
        return typeof obj;
      };
    } else {
      module.exports = _typeof = function _typeof(obj) {
        return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== (typeof Symbol === "function" ? Symbol.prototype : "@@prototype") ? "symbol" : typeof obj;
      };
    }

    return _typeof(obj);
  }

  module.exports = _typeof;
},10,[],"node_modules/@babel/runtime/helpers/typeof.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.get = get;
  exports.getEnforcing = getEnforcing;

  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "invariant"));

  var NativeModules = _$$_REQUIRE(_dependencyMap[2], "../BatchedBridge/NativeModules");

  var turboModuleProxy = global.__turboModuleProxy;

  function get(name) {
    if (!global.RN$Bridgeless) {
      var legacyModule = NativeModules[name];

      if (legacyModule != null) {
        return legacyModule;
      }
    }

    if (turboModuleProxy != null) {
      var module = turboModuleProxy(name);
      return module;
    }

    return null;
  }

  function getEnforcing(name) {
    var module = get(name);
    (0, _invariant.default)(module != null, "TurboModuleRegistry.getEnforcing(...): '" + name + "' could not be found. " + 'Verify that a module by this name is registered in the native binary.');
    return module;
  }
},11,[1,3,12],"node_modules/react-native/Libraries/TurboModule/TurboModuleRegistry.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");

  var _slicedToArray = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/slicedToArray");

  var BatchedBridge = _$$_REQUIRE(_dependencyMap[2], "./BatchedBridge");

  var invariant = _$$_REQUIRE(_dependencyMap[3], "invariant");

  function genModule(config, moduleID) {
    if (!config) {
      return null;
    }

    var _config = _slicedToArray(config, 5),
        moduleName = _config[0],
        constants = _config[1],
        methods = _config[2],
        promiseMethods = _config[3],
        syncMethods = _config[4];

    invariant(!moduleName.startsWith('RCT') && !moduleName.startsWith('RK'), "Module name prefixes should've been stripped by the native side " + "but wasn't for " + moduleName);

    if (!constants && !methods) {
      return {
        name: moduleName
      };
    }

    var module = {};
    methods && methods.forEach(function (methodName, methodID) {
      var isPromise = promiseMethods && arrayContains(promiseMethods, methodID);
      var isSync = syncMethods && arrayContains(syncMethods, methodID);
      invariant(!isPromise || !isSync, 'Cannot have a method that is both async and a sync hook');
      var methodType = isPromise ? 'promise' : isSync ? 'sync' : 'async';
      module[methodName] = genMethod(moduleID, methodID, methodType);
    });

    _extends(module, constants);

    if (module.getConstants == null) {
      module.getConstants = function () {
        return constants || Object.freeze({});
      };
    } else {
      console.warn("Unable to define method 'getConstants()' on NativeModule '" + moduleName + "'. NativeModule '" + moduleName + "' already has a constant or method called 'getConstants'. Please remove it.");
    }

    if (__DEV__) {
      BatchedBridge.createDebugLookup(moduleID, moduleName, methods);
    }

    return {
      name: moduleName,
      module: module
    };
  }

  global.__fbGenNativeModule = genModule;

  function loadModule(name, moduleID) {
    invariant(global.nativeRequireModuleConfig, "Can't lazily create module without nativeRequireModuleConfig");
    var config = global.nativeRequireModuleConfig(name);
    var info = genModule(config, moduleID);
    return info && info.module;
  }

  function genMethod(moduleID, methodID, type) {
    var fn = null;

    if (type === 'promise') {
      fn = function fn() {
        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
          args[_key] = arguments[_key];
        }

        var enqueueingFrameError = new Error();
        enqueueingFrameError.framesToPop = 1;
        return new Promise(function (resolve, reject) {
          BatchedBridge.enqueueNativeCall(moduleID, methodID, args, function (data) {
            return resolve(data);
          }, function (errorData) {
            return reject(updateErrorWithErrorData(errorData, enqueueingFrameError));
          });
        });
      };
    } else {
      fn = function fn() {
        for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
          args[_key2] = arguments[_key2];
        }

        var lastArg = args.length > 0 ? args[args.length - 1] : null;
        var secondLastArg = args.length > 1 ? args[args.length - 2] : null;
        var hasSuccessCallback = typeof lastArg === 'function';
        var hasErrorCallback = typeof secondLastArg === 'function';
        hasErrorCallback && invariant(hasSuccessCallback, 'Cannot have a non-function arg after a function arg.');
        var onSuccess = hasSuccessCallback ? lastArg : null;
        var onFail = hasErrorCallback ? secondLastArg : null;
        var callbackCount = hasSuccessCallback + hasErrorCallback;
        args = args.slice(0, args.length - callbackCount);

        if (type === 'sync') {
          return BatchedBridge.callNativeSyncHook(moduleID, methodID, args, onFail, onSuccess);
        } else {
          BatchedBridge.enqueueNativeCall(moduleID, methodID, args, onFail, onSuccess);
        }
      };
    }

    fn.type = type;
    return fn;
  }

  function arrayContains(array, value) {
    return array.indexOf(value) !== -1;
  }

  function updateErrorWithErrorData(errorData, error) {
    return _extends(error, errorData || {});
  }

  var NativeModules = {};

  if (global.nativeModuleProxy) {
    NativeModules = global.nativeModuleProxy;
  } else if (!global.nativeExtensions) {
    var bridgeConfig = global.__fbBatchedBridgeConfig;
    invariant(bridgeConfig, '__fbBatchedBridgeConfig is not set, cannot invoke native modules');

    var defineLazyObjectProperty = _$$_REQUIRE(_dependencyMap[4], "../Utilities/defineLazyObjectProperty");

    (bridgeConfig.remoteModuleConfig || []).forEach(function (config, moduleID) {
      var info = genModule(config, moduleID);

      if (!info) {
        return;
      }

      if (info.module) {
        NativeModules[info.name] = info.module;
      } else {
          defineLazyObjectProperty(NativeModules, info.name, {
            get: function get() {
              return loadModule(info.name, moduleID);
            }
          });
        }
    });
  }

  module.exports = NativeModules;
},12,[13,14,18,3,30],"node_modules/react-native/Libraries/BatchedBridge/NativeModules.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  function _extends() {
    module.exports = _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);
  }

  module.exports = _extends;
},13,[],"node_modules/@babel/runtime/helpers/extends.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var arrayWithHoles = _$$_REQUIRE(_dependencyMap[0], "./arrayWithHoles");

  var iterableToArrayLimit = _$$_REQUIRE(_dependencyMap[1], "./iterableToArrayLimit");

  var nonIterableRest = _$$_REQUIRE(_dependencyMap[2], "./nonIterableRest");

  function _slicedToArray(arr, i) {
    return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || nonIterableRest();
  }

  module.exports = _slicedToArray;
},14,[15,16,17],"node_modules/@babel/runtime/helpers/slicedToArray.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  function _arrayWithHoles(arr) {
    if (Array.isArray(arr)) return arr;
  }

  module.exports = _arrayWithHoles;
},15,[],"node_modules/@babel/runtime/helpers/arrayWithHoles.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  function _iterableToArrayLimit(arr, i) {
    if (!((typeof Symbol === "function" ? Symbol.iterator : "@@iterator") in Object(arr) || Object.prototype.toString.call(arr) === "[object Arguments]")) {
      return;
    }

    var _arr = [];
    var _n = true;
    var _d = false;
    var _e = undefined;

    try {
      for (var _i = arr[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"](), _s; !(_n = (_s = _i.next()).done); _n = true) {
        _arr.push(_s.value);

        if (i && _arr.length === i) break;
      }
    } catch (err) {
      _d = true;
      _e = err;
    } finally {
      try {
        if (!_n && _i["return"] != null) _i["return"]();
      } finally {
        if (_d) throw _e;
      }
    }

    return _arr;
  }

  module.exports = _iterableToArrayLimit;
},16,[],"node_modules/@babel/runtime/helpers/iterableToArrayLimit.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  function _nonIterableRest() {
    throw new TypeError("Invalid attempt to destructure non-iterable instance");
  }

  module.exports = _nonIterableRest;
},17,[],"node_modules/@babel/runtime/helpers/nonIterableRest.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var MessageQueue = _$$_REQUIRE(_dependencyMap[0], "./MessageQueue");

  var BatchedBridge = new MessageQueue();
  Object.defineProperty(global, '__fbBatchedBridge', {
    configurable: true,
    value: BatchedBridge
  });
  module.exports = BatchedBridge;
},18,[19],"node_modules/react-native/Libraries/BatchedBridge/BatchedBridge.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _toConsumableArray = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/toConsumableArray");

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass");

  var ErrorUtils = _$$_REQUIRE(_dependencyMap[3], "../vendor/core/ErrorUtils");

  var Systrace = _$$_REQUIRE(_dependencyMap[4], "../Performance/Systrace");

  var deepFreezeAndThrowOnMutationInDev = _$$_REQUIRE(_dependencyMap[5], "../Utilities/deepFreezeAndThrowOnMutationInDev");

  var invariant = _$$_REQUIRE(_dependencyMap[6], "invariant");

  var stringifySafe = _$$_REQUIRE(_dependencyMap[7], "../Utilities/stringifySafe");

  var warnOnce = _$$_REQUIRE(_dependencyMap[8], "../Utilities/warnOnce");

  var TO_JS = 0;
  var TO_NATIVE = 1;
  var MODULE_IDS = 0;
  var METHOD_IDS = 1;
  var PARAMS = 2;
  var MIN_TIME_BETWEEN_FLUSHES_MS = 5;
  var TRACE_TAG_REACT_APPS = 1 << 17;
  var DEBUG_INFO_LIMIT = 32;

  var MessageQueue = function () {
    function MessageQueue() {
      _classCallCheck(this, MessageQueue);

      this._lazyCallableModules = {};
      this._queue = [[], [], [], 0];
      this._successCallbacks = new Map();
      this._failureCallbacks = new Map();
      this._callID = 0;
      this._lastFlush = 0;
      this._eventLoopStartTime = Date.now();
      this._immediatesCallback = null;

      if (__DEV__) {
        this._debugInfo = {};
        this._remoteModuleTable = {};
        this._remoteMethodTable = {};
      }

      this.callFunctionReturnFlushedQueue = this.callFunctionReturnFlushedQueue.bind(this);
      this.callFunctionReturnResultAndFlushedQueue = this.callFunctionReturnResultAndFlushedQueue.bind(this);
      this.flushedQueue = this.flushedQueue.bind(this);
      this.invokeCallbackAndReturnFlushedQueue = this.invokeCallbackAndReturnFlushedQueue.bind(this);
    }

    _createClass(MessageQueue, [{
      key: "callFunctionReturnFlushedQueue",
      value: function callFunctionReturnFlushedQueue(module, method, args) {
        var _this = this;

        this.__guard(function () {
          _this.__callFunction(module, method, args);
        });

        return this.flushedQueue();
      }
    }, {
      key: "callFunctionReturnResultAndFlushedQueue",
      value: function callFunctionReturnResultAndFlushedQueue(module, method, args) {
        var _this2 = this;

        var result;

        this.__guard(function () {
          result = _this2.__callFunction(module, method, args);
        });

        return [result, this.flushedQueue()];
      }
    }, {
      key: "invokeCallbackAndReturnFlushedQueue",
      value: function invokeCallbackAndReturnFlushedQueue(cbID, args) {
        var _this3 = this;

        this.__guard(function () {
          _this3.__invokeCallback(cbID, args);
        });

        return this.flushedQueue();
      }
    }, {
      key: "flushedQueue",
      value: function flushedQueue() {
        var _this4 = this;

        this.__guard(function () {
          _this4.__callImmediates();
        });

        var queue = this._queue;
        this._queue = [[], [], [], this._callID];
        return queue[0].length ? queue : null;
      }
    }, {
      key: "getEventLoopRunningTime",
      value: function getEventLoopRunningTime() {
        return Date.now() - this._eventLoopStartTime;
      }
    }, {
      key: "registerCallableModule",
      value: function registerCallableModule(name, module) {
        this._lazyCallableModules[name] = function () {
          return module;
        };
      }
    }, {
      key: "registerLazyCallableModule",
      value: function registerLazyCallableModule(name, factory) {
        var module;
        var getValue = factory;

        this._lazyCallableModules[name] = function () {
          if (getValue) {
            module = getValue();
            getValue = null;
          }

          return module;
        };
      }
    }, {
      key: "getCallableModule",
      value: function getCallableModule(name) {
        var getValue = this._lazyCallableModules[name];
        return getValue ? getValue() : null;
      }
    }, {
      key: "callNativeSyncHook",
      value: function callNativeSyncHook(moduleID, methodID, params, onFail, onSucc) {
        if (__DEV__) {
          invariant(global.nativeCallSyncHook, 'Calling synchronous methods on native ' + 'modules is not supported in Chrome.\n\n Consider providing alternative ' + 'methods to expose this method in debug mode, e.g. by exposing constants ' + 'ahead-of-time.');
        }

        this.processCallbacks(moduleID, methodID, params, onFail, onSucc);

        try {
          return global.nativeCallSyncHook(moduleID, methodID, params);
        } catch (e) {
          if (typeof e === 'object' && e != null && typeof e.framesToPop === 'undefined' && /^Exception in HostFunction: /.test(e.message)) {
            e.framesToPop = 2;
          }

          throw e;
        }
      }
    }, {
      key: "processCallbacks",
      value: function processCallbacks(moduleID, methodID, params, onFail, onSucc) {
        var _this5 = this;

        if (onFail || onSucc) {
          if (__DEV__) {
            this._debugInfo[this._callID] = [moduleID, methodID];

            if (this._callID > DEBUG_INFO_LIMIT) {
              delete this._debugInfo[this._callID - DEBUG_INFO_LIMIT];
            }

            if (this._successCallbacks.size > 500) {
              var info = {};

              this._successCallbacks.forEach(function (_, callID) {
                var debug = _this5._debugInfo[callID];
                var module = debug && _this5._remoteModuleTable[debug[0]];
                var method = debug && _this5._remoteMethodTable[debug[0]][debug[1]];
                info[callID] = {
                  module: module,
                  method: method
                };
              });

              warnOnce('excessive-number-of-pending-callbacks', "Please report: Excessive number of pending callbacks: " + this._successCallbacks.size + ". Some pending callbacks that might have leaked by never being called from native code: " + stringifySafe(info));
            }
          }

          onFail && params.push(this._callID << 1);
          onSucc && params.push(this._callID << 1 | 1);

          this._successCallbacks.set(this._callID, onSucc);

          this._failureCallbacks.set(this._callID, onFail);
        }

        if (__DEV__) {
          global.nativeTraceBeginAsyncFlow && global.nativeTraceBeginAsyncFlow(TRACE_TAG_REACT_APPS, 'native', this._callID);
        }

        this._callID++;
      }
    }, {
      key: "enqueueNativeCall",
      value: function enqueueNativeCall(moduleID, methodID, params, onFail, onSucc) {
        this.processCallbacks(moduleID, methodID, params, onFail, onSucc);

        this._queue[MODULE_IDS].push(moduleID);

        this._queue[METHOD_IDS].push(methodID);

        if (__DEV__) {
          var isValidArgument = function isValidArgument(val) {
            var t = typeof val;

            if (t === 'undefined' || t === 'null' || t === 'boolean' || t === 'string') {
              return true;
            }

            if (t === 'number') {
              return isFinite(val);
            }

            if (t === 'function' || t !== 'object') {
              return false;
            }

            if (Array.isArray(val)) {
              return val.every(isValidArgument);
            }

            for (var k in val) {
              if (typeof val[k] !== 'function' && !isValidArgument(val[k])) {
                return false;
              }
            }

            return true;
          };

          var replacer = function replacer(key, val) {
            var t = typeof val;

            if (t === 'function') {
              return '<<Function ' + val.name + '>>';
            } else if (t === 'number' && !isFinite(val)) {
              return '<<' + val.toString() + '>>';
            } else {
              return val;
            }
          };

          invariant(isValidArgument(params), '%s is not usable as a native method argument', JSON.stringify(params, replacer));
          deepFreezeAndThrowOnMutationInDev(params);
        }

        this._queue[PARAMS].push(params);

        var now = Date.now();

        if (global.nativeFlushQueueImmediate && now - this._lastFlush >= MIN_TIME_BETWEEN_FLUSHES_MS) {
          var queue = this._queue;
          this._queue = [[], [], [], this._callID];
          this._lastFlush = now;
          global.nativeFlushQueueImmediate(queue);
        }

        Systrace.counterEvent('pending_js_to_native_queue', this._queue[0].length);

        if (__DEV__ && this.__spy && isFinite(moduleID)) {
          this.__spy({
            type: TO_NATIVE,
            module: this._remoteModuleTable[moduleID],
            method: this._remoteMethodTable[moduleID][methodID],
            args: params
          });
        } else if (this.__spy) {
          this.__spy({
            type: TO_NATIVE,
            module: moduleID + '',
            method: methodID,
            args: params
          });
        }
      }
    }, {
      key: "createDebugLookup",
      value: function createDebugLookup(moduleID, name, methods) {
        if (__DEV__) {
          this._remoteModuleTable[moduleID] = name;
          this._remoteMethodTable[moduleID] = methods || [];
        }
      }
    }, {
      key: "setImmediatesCallback",
      value: function setImmediatesCallback(fn) {
        this._immediatesCallback = fn;
      }
    }, {
      key: "__guard",
      value: function __guard(fn) {
        if (this.__shouldPauseOnThrow()) {
          fn();
        } else {
          try {
            fn();
          } catch (error) {
            ErrorUtils.reportFatalError(error);
          }
        }
      }
    }, {
      key: "__shouldPauseOnThrow",
      value: function __shouldPauseOnThrow() {
        return typeof DebuggerInternal !== 'undefined' && DebuggerInternal.shouldPauseOnThrow === true;
      }
    }, {
      key: "__callImmediates",
      value: function __callImmediates() {
        Systrace.beginEvent('JSTimers.callImmediates()');

        if (this._immediatesCallback != null) {
          this._immediatesCallback();
        }

        Systrace.endEvent();
      }
    }, {
      key: "__callFunction",
      value: function __callFunction(module, method, args) {
        this._lastFlush = Date.now();
        this._eventLoopStartTime = this._lastFlush;

        if (__DEV__ || this.__spy) {
          Systrace.beginEvent(module + "." + method + "(" + stringifySafe(args) + ")");
        } else {
          Systrace.beginEvent(module + "." + method + "(...)");
        }

        if (this.__spy) {
          this.__spy({
            type: TO_JS,
            module: module,
            method: method,
            args: args
          });
        }

        var moduleMethods = this.getCallableModule(module);
        invariant(!!moduleMethods, 'Module %s is not a registered callable module (calling %s)', module, method);
        invariant(!!moduleMethods[method], 'Method %s does not exist on module %s', method, module);
        var result = moduleMethods[method].apply(moduleMethods, args);
        Systrace.endEvent();
        return result;
      }
    }, {
      key: "__invokeCallback",
      value: function __invokeCallback(cbID, args) {
        this._lastFlush = Date.now();
        this._eventLoopStartTime = this._lastFlush;
        var callID = cbID >>> 1;
        var isSuccess = cbID & 1;
        var callback = isSuccess ? this._successCallbacks.get(callID) : this._failureCallbacks.get(callID);

        if (__DEV__) {
          var debug = this._debugInfo[callID];

          var _module = debug && this._remoteModuleTable[debug[0]];

          var method = debug && this._remoteMethodTable[debug[0]][debug[1]];
          invariant(callback, "No callback found with cbID " + cbID + " and callID " + callID + " for " + (method ? " " + _module + "." + method + " - most likely the callback was already invoked" : "module " + (_module || '<unknown>')) + (". Args: '" + stringifySafe(args) + "'"));
          var profileName = debug ? '<callback for ' + _module + '.' + method + '>' : cbID;

          if (callback && this.__spy) {
            this.__spy({
              type: TO_JS,
              module: null,
              method: profileName,
              args: args
            });
          }

          Systrace.beginEvent("MessageQueue.invokeCallback(" + profileName + ", " + stringifySafe(args) + ")");
        }

        if (!callback) {
          return;
        }

        this._successCallbacks.delete(callID);

        this._failureCallbacks.delete(callID);

        callback.apply(void 0, _toConsumableArray(args));

        if (__DEV__) {
          Systrace.endEvent();
        }
      }
    }], [{
      key: "spy",
      value: function spy(spyOrToggle) {
        if (spyOrToggle === true) {
          MessageQueue.prototype.__spy = function (info) {
            console.log((info.type === TO_JS ? 'N->JS' : 'JS->N') + " : " + ("" + (info.module ? info.module + '.' : '') + info.method) + ("(" + JSON.stringify(info.args) + ")"));
          };
        } else if (spyOrToggle === false) {
          MessageQueue.prototype.__spy = null;
        } else {
          MessageQueue.prototype.__spy = spyOrToggle;
        }
      }
    }]);

    return MessageQueue;
  }();

  module.exports = MessageQueue;
},19,[20,24,25,26,27,28,3,29,4],"node_modules/react-native/Libraries/BatchedBridge/MessageQueue.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var arrayWithoutHoles = _$$_REQUIRE(_dependencyMap[0], "./arrayWithoutHoles");

  var iterableToArray = _$$_REQUIRE(_dependencyMap[1], "./iterableToArray");

  var nonIterableSpread = _$$_REQUIRE(_dependencyMap[2], "./nonIterableSpread");

  function _toConsumableArray(arr) {
    return arrayWithoutHoles(arr) || iterableToArray(arr) || nonIterableSpread();
  }

  module.exports = _toConsumableArray;
},20,[21,22,23],"node_modules/@babel/runtime/helpers/toConsumableArray.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  function _arrayWithoutHoles(arr) {
    if (Array.isArray(arr)) {
      for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) {
        arr2[i] = arr[i];
      }

      return arr2;
    }
  }

  module.exports = _arrayWithoutHoles;
},21,[],"node_modules/@babel/runtime/helpers/arrayWithoutHoles.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  function _iterableToArray(iter) {
    if ((typeof Symbol === "function" ? Symbol.iterator : "@@iterator") in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter);
  }

  module.exports = _iterableToArray;
},22,[],"node_modules/@babel/runtime/helpers/iterableToArray.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  function _nonIterableSpread() {
    throw new TypeError("Invalid attempt to spread non-iterable instance");
  }

  module.exports = _nonIterableSpread;
},23,[],"node_modules/@babel/runtime/helpers/nonIterableSpread.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  function _classCallCheck(instance, Constructor) {
    if (!(instance instanceof Constructor)) {
      throw new TypeError("Cannot call a class as a function");
    }
  }

  module.exports = _classCallCheck;
},24,[],"node_modules/@babel/runtime/helpers/classCallCheck.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  function _defineProperties(target, props) {
    for (var i = 0; i < props.length; i++) {
      var descriptor = props[i];
      descriptor.enumerable = descriptor.enumerable || false;
      descriptor.configurable = true;
      if ("value" in descriptor) descriptor.writable = true;
      Object.defineProperty(target, descriptor.key, descriptor);
    }
  }

  function _createClass(Constructor, protoProps, staticProps) {
    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
    if (staticProps) _defineProperties(Constructor, staticProps);
    return Constructor;
  }

  module.exports = _createClass;
},25,[],"node_modules/@babel/runtime/helpers/createClass.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  module.exports = global.ErrorUtils;
},26,[],"node_modules/react-native/Libraries/vendor/core/ErrorUtils.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var invariant = _$$_REQUIRE(_dependencyMap[0], "invariant");

  var TRACE_TAG_REACT_APPS = 1 << 17;
  var TRACE_TAG_JS_VM_CALLS = 1 << 27;
  var _enabled = false;
  var _asyncCookie = 0;
  var _markStack = [];

  var _markStackIndex = -1;

  var _canInstallReactHook = false;
  var REACT_MARKER = "\u269B";
  var userTimingPolyfill = __DEV__ ? {
    mark: function mark(markName) {
      if (_enabled) {
        _markStackIndex++;
        _markStack[_markStackIndex] = markName;
        var systraceLabel = markName;

        if (markName[0] === REACT_MARKER) {
          var indexOfId = markName.lastIndexOf(' (#');
          var cutoffIndex = indexOfId !== -1 ? indexOfId : markName.length;
          systraceLabel = markName.slice(2, cutoffIndex);
        }

        Systrace.beginEvent(systraceLabel);
      }
    },
    measure: function measure(measureName, startMark, endMark) {
      if (_enabled) {
        invariant(typeof measureName === 'string' && typeof startMark === 'string' && typeof endMark === 'undefined', 'Only performance.measure(string, string) overload is supported.');
        var topMark = _markStack[_markStackIndex];
        invariant(startMark === topMark, 'There was a mismatching performance.measure() call. ' + 'Expected "%s" but got "%s."', topMark, startMark);
        _markStackIndex--;
        Systrace.endEvent();
      }
    },
    clearMarks: function clearMarks(markName) {
      if (_enabled) {
        if (_markStackIndex === -1) {
          return;
        }

        if (markName === _markStack[_markStackIndex]) {
          if (userTimingPolyfill != null) {
            userTimingPolyfill.measure(markName, markName);
          }
        }
      }
    },
    clearMeasures: function clearMeasures() {}
  } : null;
  var Systrace = {
    installReactHook: function installReactHook() {
      if (_enabled) {
        if (__DEV__) {
          global.performance = userTimingPolyfill;
        }
      }

      _canInstallReactHook = true;
    },
    setEnabled: function setEnabled(enabled) {
      if (_enabled !== enabled) {
        if (__DEV__) {
          if (enabled) {
            global.nativeTraceBeginLegacy && global.nativeTraceBeginLegacy(TRACE_TAG_JS_VM_CALLS);
          } else {
            global.nativeTraceEndLegacy && global.nativeTraceEndLegacy(TRACE_TAG_JS_VM_CALLS);
          }

          if (_canInstallReactHook) {
            if (enabled && global.performance === undefined) {
              global.performance = userTimingPolyfill;
            }
          }
        }

        _enabled = enabled;
      }
    },
    isEnabled: function isEnabled() {
      return _enabled;
    },
    beginEvent: function beginEvent(profileName, args) {
      if (_enabled) {
        profileName = typeof profileName === 'function' ? profileName() : profileName;
        global.nativeTraceBeginSection(TRACE_TAG_REACT_APPS, profileName, args);
      }
    },
    endEvent: function endEvent() {
      if (_enabled) {
        global.nativeTraceEndSection(TRACE_TAG_REACT_APPS);
      }
    },
    beginAsyncEvent: function beginAsyncEvent(profileName) {
      var cookie = _asyncCookie;

      if (_enabled) {
        _asyncCookie++;
        profileName = typeof profileName === 'function' ? profileName() : profileName;
        global.nativeTraceBeginAsyncSection(TRACE_TAG_REACT_APPS, profileName, cookie);
      }

      return cookie;
    },
    endAsyncEvent: function endAsyncEvent(profileName, cookie) {
      if (_enabled) {
        profileName = typeof profileName === 'function' ? profileName() : profileName;
        global.nativeTraceEndAsyncSection(TRACE_TAG_REACT_APPS, profileName, cookie);
      }
    },
    counterEvent: function counterEvent(profileName, value) {
      if (_enabled) {
        profileName = typeof profileName === 'function' ? profileName() : profileName;
        global.nativeTraceCounter && global.nativeTraceCounter(TRACE_TAG_REACT_APPS, profileName, value);
      }
    }
  };

  if (__DEV__) {
    _$$_REQUIRE.Systrace = Systrace;
  }

  module.exports = Systrace;
},27,[3],"node_modules/react-native/Libraries/Performance/Systrace.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  function deepFreezeAndThrowOnMutationInDev(object) {
    if (__DEV__) {
      if (typeof object !== 'object' || object === null || Object.isFrozen(object) || Object.isSealed(object)) {
        return object;
      }

      var keys = Object.keys(object);
      var _hasOwnProperty = Object.prototype.hasOwnProperty;

      for (var i = 0; i < keys.length; i++) {
        var key = keys[i];

        if (_hasOwnProperty.call(object, key)) {
          Object.defineProperty(object, key, {
            get: identity.bind(null, object[key])
          });
          Object.defineProperty(object, key, {
            set: throwOnImmutableMutation.bind(null, key)
          });
        }
      }

      Object.freeze(object);
      Object.seal(object);

      for (var _i = 0; _i < keys.length; _i++) {
        var _key = keys[_i];

        if (_hasOwnProperty.call(object, _key)) {
          deepFreezeAndThrowOnMutationInDev(object[_key]);
        }
      }
    }

    return object;
  }

  function throwOnImmutableMutation(key, value) {
    throw Error('You attempted to set the key `' + key + '` with the value `' + JSON.stringify(value) + '` on an object that is meant to be immutable ' + 'and has been frozen.');
  }

  function identity(value) {
    return value;
  }

  module.exports = deepFreezeAndThrowOnMutationInDev;
},28,[],"node_modules/react-native/Libraries/Utilities/deepFreezeAndThrowOnMutationInDev.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  function stringifySafe(arg) {
    var ret;
    var type = typeof arg;

    if (arg === undefined) {
      ret = 'undefined';
    } else if (arg === null) {
      ret = 'null';
    } else if (type === 'string') {
      ret = '"' + arg + '"';
    } else if (type === 'function') {
      try {
        ret = arg.toString();
      } catch (e) {
        ret = '[function unknown]';
      }
    } else if (arg instanceof Error) {
      ret = arg.name + ': ' + arg.message;
    } else {
      try {
        ret = JSON.stringify(arg);
      } catch (e) {
        if (typeof arg.toString === 'function') {
          try {
            ret = arg.toString();
          } catch (E) {}
        }
      }
    }

    return ret || '["' + type + '" failed to stringify]';
  }

  module.exports = stringifySafe;
},29,[],"node_modules/react-native/Libraries/Utilities/stringifySafe.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  function defineLazyObjectProperty(object, name, descriptor) {
    var get = descriptor.get;
    var enumerable = descriptor.enumerable !== false;
    var writable = descriptor.writable !== false;
    var value;
    var valueSet = false;

    function getValue() {
      if (!valueSet) {
        valueSet = true;
        setValue(get());
      }

      return value;
    }

    function setValue(newValue) {
      value = newValue;
      valueSet = true;
      Object.defineProperty(object, name, {
        value: newValue,
        configurable: true,
        enumerable: enumerable,
        writable: writable
      });
    }

    Object.defineProperty(object, name, {
      get: getValue,
      set: setValue,
      configurable: true,
      enumerable: enumerable
    });
  }

  module.exports = defineLazyObjectProperty;
},30,[],"node_modules/react-native/Libraries/Utilities/defineLazyObjectProperty.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");

  var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");

  var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");

  var _get = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/get");

  var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");

  var EventEmitter = _$$_REQUIRE(_dependencyMap[6], "../vendor/emitter/EventEmitter");

  var EventSubscriptionVendor = _$$_REQUIRE(_dependencyMap[7], "../vendor/emitter/EventSubscriptionVendor");

  function checkNativeEventModule(eventType) {
    if (eventType) {
      if (eventType.lastIndexOf('statusBar', 0) === 0) {
        throw new Error('`' + eventType + '` event should be registered via the StatusBarIOS module');
      }

      if (eventType.lastIndexOf('keyboard', 0) === 0) {
        throw new Error('`' + eventType + '` event should be registered via the Keyboard module');
      }

      if (eventType === 'appStateDidChange' || eventType === 'memoryWarning') {
        throw new Error('`' + eventType + '` event should be registered via the AppState module');
      }
    }
  }

  var RCTDeviceEventEmitter = function (_EventEmitter) {
    _inherits(RCTDeviceEventEmitter, _EventEmitter);

    function RCTDeviceEventEmitter() {
      var _this;

      _classCallCheck(this, RCTDeviceEventEmitter);

      var sharedSubscriber = new EventSubscriptionVendor();
      _this = _possibleConstructorReturn(this, _getPrototypeOf(RCTDeviceEventEmitter).call(this, sharedSubscriber));
      _this.sharedSubscriber = sharedSubscriber;
      return _this;
    }

    _createClass(RCTDeviceEventEmitter, [{
      key: "addListener",
      value: function addListener(eventType, listener, context) {
        if (__DEV__) {
          checkNativeEventModule(eventType);
        }

        return _get(_getPrototypeOf(RCTDeviceEventEmitter.prototype), "addListener", this).call(this, eventType, listener, context);
      }
    }, {
      key: "removeAllListeners",
      value: function removeAllListeners(eventType) {
        if (__DEV__) {
          checkNativeEventModule(eventType);
        }

        _get(_getPrototypeOf(RCTDeviceEventEmitter.prototype), "removeAllListeners", this).call(this, eventType);
      }
    }, {
      key: "removeSubscription",
      value: function removeSubscription(subscription) {
        if (subscription.emitter !== this) {
          subscription.emitter.removeSubscription(subscription);
        } else {
          _get(_getPrototypeOf(RCTDeviceEventEmitter.prototype), "removeSubscription", this).call(this, subscription);
        }
      }
    }]);

    return RCTDeviceEventEmitter;
  }(EventEmitter);

  module.exports = new RCTDeviceEventEmitter();
},31,[24,25,32,34,35,37,39,42],"node_modules/react-native/Libraries/EventEmitter/RCTDeviceEventEmitter.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _typeof = _$$_REQUIRE(_dependencyMap[0], "../helpers/typeof");

  var assertThisInitialized = _$$_REQUIRE(_dependencyMap[1], "./assertThisInitialized");

  function _possibleConstructorReturn(self, call) {
    if (call && (_typeof(call) === "object" || typeof call === "function")) {
      return call;
    }

    return assertThisInitialized(self);
  }

  module.exports = _possibleConstructorReturn;
},32,[10,33],"node_modules/@babel/runtime/helpers/possibleConstructorReturn.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  function _assertThisInitialized(self) {
    if (self === void 0) {
      throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
    }

    return self;
  }

  module.exports = _assertThisInitialized;
},33,[],"node_modules/@babel/runtime/helpers/assertThisInitialized.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  function _getPrototypeOf(o) {
    module.exports = _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
      return o.__proto__ || Object.getPrototypeOf(o);
    };
    return _getPrototypeOf(o);
  }

  module.exports = _getPrototypeOf;
},34,[],"node_modules/@babel/runtime/helpers/getPrototypeOf.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var superPropBase = _$$_REQUIRE(_dependencyMap[0], "./superPropBase");

  function _get(target, property, receiver) {
    if (typeof Reflect !== "undefined" && Reflect.get) {
      module.exports = _get = Reflect.get;
    } else {
      module.exports = _get = function _get(target, property, receiver) {
        var base = superPropBase(target, property);
        if (!base) return;
        var desc = Object.getOwnPropertyDescriptor(base, property);

        if (desc.get) {
          return desc.get.call(receiver);
        }

        return desc.value;
      };
    }

    return _get(target, property, receiver || target);
  }

  module.exports = _get;
},35,[36],"node_modules/@babel/runtime/helpers/get.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var getPrototypeOf = _$$_REQUIRE(_dependencyMap[0], "./getPrototypeOf");

  function _superPropBase(object, property) {
    while (!Object.prototype.hasOwnProperty.call(object, property)) {
      object = getPrototypeOf(object);
      if (object === null) break;
    }

    return object;
  }

  module.exports = _superPropBase;
},36,[34],"node_modules/@babel/runtime/helpers/superPropBase.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var setPrototypeOf = _$$_REQUIRE(_dependencyMap[0], "./setPrototypeOf");

  function _inherits(subClass, superClass) {
    if (typeof superClass !== "function" && superClass !== null) {
      throw new TypeError("Super expression must either be null or a function");
    }

    subClass.prototype = Object.create(superClass && superClass.prototype, {
      constructor: {
        value: subClass,
        writable: true,
        configurable: true
      }
    });
    if (superClass) setPrototypeOf(subClass, superClass);
  }

  module.exports = _inherits;
},37,[38],"node_modules/@babel/runtime/helpers/inherits.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  function _setPrototypeOf(o, p) {
    module.exports = _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
      o.__proto__ = p;
      return o;
    };

    return _setPrototypeOf(o, p);
  }

  module.exports = _setPrototypeOf;
},38,[],"node_modules/@babel/runtime/helpers/setPrototypeOf.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");

  var EmitterSubscription = _$$_REQUIRE(_dependencyMap[2], "./EmitterSubscription");

  var EventSubscriptionVendor = _$$_REQUIRE(_dependencyMap[3], "./EventSubscriptionVendor");

  var invariant = _$$_REQUIRE(_dependencyMap[4], "invariant");

  var sparseFilterPredicate = function sparseFilterPredicate() {
    return true;
  };

  var EventEmitter = function () {
    function EventEmitter(subscriber) {
      _classCallCheck(this, EventEmitter);

      this._subscriber = subscriber || new EventSubscriptionVendor();
    }

    _createClass(EventEmitter, [{
      key: "addListener",
      value: function addListener(eventType, listener, context) {
        return this._subscriber.addSubscription(eventType, new EmitterSubscription(this, this._subscriber, listener, context));
      }
    }, {
      key: "once",
      value: function once(eventType, listener, context) {
        var _this = this;

        return this.addListener(eventType, function () {
          _this.removeCurrentListener();

          for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
            args[_key] = arguments[_key];
          }

          listener.apply(context, args);
        });
      }
    }, {
      key: "removeAllListeners",
      value: function removeAllListeners(eventType) {
        this._subscriber.removeAllSubscriptions(eventType);
      }
    }, {
      key: "removeCurrentListener",
      value: function removeCurrentListener() {
        invariant(!!this._currentSubscription, 'Not in an emitting cycle; there is no current subscription');
        this.removeSubscription(this._currentSubscription);
      }
    }, {
      key: "removeSubscription",
      value: function removeSubscription(subscription) {
        invariant(subscription.emitter === this, 'Subscription does not belong to this emitter.');

        this._subscriber.removeSubscription(subscription);
      }
    }, {
      key: "listeners",
      value: function listeners(eventType) {
        var subscriptions = this._subscriber.getSubscriptionsForType(eventType);

        return subscriptions ? subscriptions.filter(sparseFilterPredicate).map(function (subscription) {
          return subscription.listener;
        }) : [];
      }
    }, {
      key: "emit",
      value: function emit(eventType) {
        var subscriptions = this._subscriber.getSubscriptionsForType(eventType);

        if (subscriptions) {
          for (var i = 0, l = subscriptions.length; i < l; i++) {
            var subscription = subscriptions[i];

            if (subscription && subscription.listener) {
              this._currentSubscription = subscription;
              subscription.listener.apply(subscription.context, Array.prototype.slice.call(arguments, 1));
            }
          }

          this._currentSubscription = null;
        }
      }
    }, {
      key: "removeListener",
      value: function removeListener(eventType, listener) {
        var subscriptions = this._subscriber.getSubscriptionsForType(eventType);

        if (subscriptions) {
          for (var i = 0, l = subscriptions.length; i < l; i++) {
            var subscription = subscriptions[i];

            if (subscription && subscription.listener === listener) {
              subscription.remove();
            }
          }
        }
      }
    }]);

    return EventEmitter;
  }();

  module.exports = EventEmitter;
},39,[24,25,40,42,3],"node_modules/react-native/Libraries/vendor/emitter/EventEmitter.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");

  var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");

  var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");

  var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");

  var EventSubscription = _$$_REQUIRE(_dependencyMap[5], "./EventSubscription");

  var EmitterSubscription = function (_EventSubscription) {
    _inherits(EmitterSubscription, _EventSubscription);

    function EmitterSubscription(emitter, subscriber, listener, context) {
      var _this;

      _classCallCheck(this, EmitterSubscription);

      _this = _possibleConstructorReturn(this, _getPrototypeOf(EmitterSubscription).call(this, subscriber));
      _this.emitter = emitter;
      _this.listener = listener;
      _this.context = context;
      return _this;
    }

    _createClass(EmitterSubscription, [{
      key: "remove",
      value: function remove() {
        this.emitter.removeSubscription(this);
      }
    }]);

    return EmitterSubscription;
  }(EventSubscription);

  module.exports = EmitterSubscription;
},40,[24,25,32,34,37,41],"node_modules/react-native/Libraries/vendor/emitter/EmitterSubscription.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");

  var EventSubscription = function () {
    function EventSubscription(subscriber) {
      _classCallCheck(this, EventSubscription);

      this.subscriber = subscriber;
    }

    _createClass(EventSubscription, [{
      key: "remove",
      value: function remove() {
        this.subscriber.removeSubscription(this);
      }
    }]);

    return EventSubscription;
  }();

  module.exports = EventSubscription;
},41,[24,25],"node_modules/react-native/Libraries/vendor/emitter/EventSubscription.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");

  var invariant = _$$_REQUIRE(_dependencyMap[2], "invariant");

  var EventSubscriptionVendor = function () {
    function EventSubscriptionVendor() {
      _classCallCheck(this, EventSubscriptionVendor);

      this._subscriptionsForType = {};
      this._currentSubscription = null;
    }

    _createClass(EventSubscriptionVendor, [{
      key: "addSubscription",
      value: function addSubscription(eventType, subscription) {
        invariant(subscription.subscriber === this, 'The subscriber of the subscription is incorrectly set.');

        if (!this._subscriptionsForType[eventType]) {
          this._subscriptionsForType[eventType] = [];
        }

        var key = this._subscriptionsForType[eventType].length;

        this._subscriptionsForType[eventType].push(subscription);

        subscription.eventType = eventType;
        subscription.key = key;
        return subscription;
      }
    }, {
      key: "removeAllSubscriptions",
      value: function removeAllSubscriptions(eventType) {
        if (eventType === undefined) {
          this._subscriptionsForType = {};
        } else {
          delete this._subscriptionsForType[eventType];
        }
      }
    }, {
      key: "removeSubscription",
      value: function removeSubscription(subscription) {
        var eventType = subscription.eventType;
        var key = subscription.key;
        var subscriptionsForType = this._subscriptionsForType[eventType];

        if (subscriptionsForType) {
          delete subscriptionsForType[key];
        }
      }
    }, {
      key: "getSubscriptionsForType",
      value: function getSubscriptionsForType(eventType) {
        return this._subscriptionsForType[eventType];
      }
    }]);

    return EventSubscriptionVendor;
  }();

  module.exports = EventSubscriptionVendor;
},42,[24,25,3],"node_modules/react-native/Libraries/vendor/emitter/EventSubscriptionVendor.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var UIManager = global.RN$Bridgeless === true ? _$$_REQUIRE(_dependencyMap[0], "./DummyUIManager") : _$$_REQUIRE(_dependencyMap[1], "./PaperUIManager");
  module.exports = UIManager;
},43,[44,45],"node_modules/react-native/Libraries/ReactNative/UIManager.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  module.exports = {
    getViewManagerConfig: function getViewManagerConfig(viewManagerName) {
      console.warn('Attempting to get config for view manager: ' + viewManagerName);
      return null;
    },
    getConstants: function getConstants() {
      return {};
    },
    getConstantsForViewManager: function getConstantsForViewManager(viewManagerName) {},
    getDefaultEventTypes: function getDefaultEventTypes() {
      return [];
    },
    playTouchSound: function playTouchSound() {},
    lazilyLoadView: function lazilyLoadView(name) {},
    createView: function createView(reactTag, viewName, rootTag, props) {},
    updateView: function updateView(reactTag, viewName, props) {},
    focus: function focus(reactTag) {},
    blur: function blur(reactTag) {},
    findSubviewIn: function findSubviewIn(reactTag, point, callback) {},
    dispatchViewManagerCommand: function dispatchViewManagerCommand(reactTag, commandID, commandArgs) {},
    measure: function measure(reactTag, callback) {},
    measureInWindow: function measureInWindow(reactTag, callback) {},
    viewIsDescendantOf: function viewIsDescendantOf(reactTag, ancestorReactTag, callback) {},
    measureLayout: function measureLayout(reactTag, ancestorReactTag, errorCallback, callback) {},
    measureLayoutRelativeToParent: function measureLayoutRelativeToParent(reactTag, errorCallback, callback) {},
    setJSResponder: function setJSResponder(reactTag, blockNativeResponder) {},
    clearJSResponder: function clearJSResponder() {},
    configureNextLayoutAnimation: function configureNextLayoutAnimation(config, callback, errorCallback) {},
    removeSubviewsFromContainerWithID: function removeSubviewsFromContainerWithID(containerID) {},
    replaceExistingNonRootView: function replaceExistingNonRootView(reactTag, newReactTag) {},
    setChildren: function setChildren(containerTag, reactTags) {},
    manageChildren: function manageChildren(containerTag, moveFromIndices, moveToIndices, addChildReactTags, addAtIndices, removeAtIndices) {},
    setLayoutAnimationEnabledExperimental: function setLayoutAnimationEnabledExperimental(enabled) {},
    sendAccessibilityEvent: function sendAccessibilityEvent(reactTag, eventType) {},
    showPopupMenu: function showPopupMenu(reactTag, items, error, success) {},
    dismissPopupMenu: function dismissPopupMenu() {}
  };
},44,[],"node_modules/react-native/Libraries/ReactNative/DummyUIManager.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _defineProperty2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/defineProperty"));

  var _NativeUIManager = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "./NativeUIManager"));

  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

  var NativeModules = _$$_REQUIRE(_dependencyMap[3], "../BatchedBridge/NativeModules");

  var Platform = _$$_REQUIRE(_dependencyMap[4], "../Utilities/Platform");

  var UIManagerProperties = _$$_REQUIRE(_dependencyMap[5], "./UIManagerProperties");

  var defineLazyObjectProperty = _$$_REQUIRE(_dependencyMap[6], "../Utilities/defineLazyObjectProperty");

  var viewManagerConfigs = {};
  var triedLoadingConfig = new Set();
  var NativeUIManagerConstants = {};
  var isNativeUIManagerConstantsSet = false;

  function _getConstants() {
    if (!isNativeUIManagerConstantsSet) {
      NativeUIManagerConstants = _NativeUIManager.default.getConstants();
      isNativeUIManagerConstantsSet = true;
    }

    return NativeUIManagerConstants;
  }

  var UIManagerJS = _objectSpread({}, _NativeUIManager.default, {
    getConstants: function getConstants() {
      return _getConstants();
    },
    getViewManagerConfig: function getViewManagerConfig(viewManagerName) {
      if (viewManagerConfigs[viewManagerName] === undefined && _NativeUIManager.default.getConstantsForViewManager) {
        try {
          viewManagerConfigs[viewManagerName] = _NativeUIManager.default.getConstantsForViewManager(viewManagerName);
        } catch (e) {
          viewManagerConfigs[viewManagerName] = null;
        }
      }

      var config = viewManagerConfigs[viewManagerName];

      if (config) {
        return config;
      }

      if (!global.nativeCallSyncHook) {
        return config;
      }

      if (_NativeUIManager.default.lazilyLoadView && !triedLoadingConfig.has(viewManagerName)) {
        var result = _NativeUIManager.default.lazilyLoadView(viewManagerName);

        triedLoadingConfig.add(viewManagerName);

        if (result.viewConfig) {
          _getConstants()[viewManagerName] = result.viewConfig;
          lazifyViewManagerConfig(viewManagerName);
        }
      }

      return viewManagerConfigs[viewManagerName];
    }
  });

  _NativeUIManager.default.getViewManagerConfig = UIManagerJS.getViewManagerConfig;

  function lazifyViewManagerConfig(viewName) {
    var viewConfig = _getConstants()[viewName];

    viewManagerConfigs[viewName] = viewConfig;

    if (viewConfig.Manager) {
      defineLazyObjectProperty(viewConfig, 'Constants', {
        get: function get() {
          var viewManager = NativeModules[viewConfig.Manager];
          var constants = {};
          viewManager && Object.keys(viewManager).forEach(function (key) {
            var value = viewManager[key];

            if (typeof value !== 'function') {
              constants[key] = value;
            }
          });
          return constants;
        }
      });
      defineLazyObjectProperty(viewConfig, 'Commands', {
        get: function get() {
          var viewManager = NativeModules[viewConfig.Manager];
          var commands = {};
          var index = 0;
          viewManager && Object.keys(viewManager).forEach(function (key) {
            var value = viewManager[key];

            if (typeof value === 'function') {
              commands[key] = index++;
            }
          });
          return commands;
        }
      });
    }
  }

  if ("android" === 'ios') {
    Object.keys(_getConstants()).forEach(function (viewName) {
      lazifyViewManagerConfig(viewName);
    });
  } else if (_getConstants().ViewManagerNames) {
    _NativeUIManager.default.getConstants().ViewManagerNames.forEach(function (viewManagerName) {
      defineLazyObjectProperty(_NativeUIManager.default, viewManagerName, {
        get: function get() {
          return _NativeUIManager.default.getConstantsForViewManager(viewManagerName);
        }
      });
    });
  }

  if (!global.nativeCallSyncHook) {
    Object.keys(_getConstants()).forEach(function (viewManagerName) {
      if (!UIManagerProperties.includes(viewManagerName)) {
        if (!viewManagerConfigs[viewManagerName]) {
          viewManagerConfigs[viewManagerName] = _getConstants()[viewManagerName];
        }

        defineLazyObjectProperty(_NativeUIManager.default, viewManagerName, {
          get: function get() {
            console.warn("Accessing view manager configs directly off UIManager via UIManager['" + viewManagerName + "'] " + ("is no longer supported. Use UIManager.getViewManagerConfig('" + viewManagerName + "') instead."));
            return UIManagerJS.getViewManagerConfig(viewManagerName);
          }
        });
      }
    });
  }

  module.exports = UIManagerJS;
},45,[1,46,47,12,48,50,30],"node_modules/react-native/Libraries/ReactNative/PaperUIManager.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  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;
  }

  module.exports = _defineProperty;
},46,[],"node_modules/@babel/runtime/helpers/defineProperty.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireWildcard");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[1], "../TurboModule/TurboModuleRegistry"));

  var _default = TurboModuleRegistry.getEnforcing('UIManager');

  exports.default = _default;
},47,[9,11],"node_modules/react-native/Libraries/ReactNative/NativeUIManager.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _NativePlatformConstantsAndroid = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./NativePlatformConstantsAndroid"));

  var Platform = {
    __constants: null,
    OS: 'android',

    get Version() {
      return this.constants.Version;
    },

    get constants() {
      if (this.__constants == null) {
        this.__constants = _NativePlatformConstantsAndroid.default.getConstants();
      }

      return this.__constants;
    },

    get isTesting() {
      if (__DEV__) {
        return this.constants.isTesting;
      }

      return false;
    },

    get isTV() {
      return this.constants.uiMode === 'tv';
    },

    select: function select(spec) {
      return 'android' in spec ? spec.android : spec.default;
    }
  };
  module.exports = Platform;
},48,[1,49],"node_modules/react-native/Libraries/Utilities/Platform.android.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireWildcard");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[1], "../TurboModule/TurboModuleRegistry"));

  var _default = TurboModuleRegistry.getEnforcing('PlatformConstants');

  exports.default = _default;
},49,[9,11],"node_modules/react-native/Libraries/Utilities/NativePlatformConstantsAndroid.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  module.exports = ['clearJSResponder', 'configureNextLayoutAnimation', 'createView', 'dismissPopupMenu', 'dispatchViewManagerCommand', 'findSubviewIn', 'getConstantsForViewManager', 'getDefaultEventTypes', 'manageChildren', 'measure', 'measureInWindow', 'measureLayout', 'measureLayoutRelativeToParent', 'playTouchSound', 'removeRootView', 'removeSubviewsFromContainerWithID', 'replaceExistingNonRootView', 'sendAccessibilityEvent', 'setChildren', 'setJSResponder', 'setLayoutAnimationEnabledExperimental', 'showPopupMenu', 'updateView', 'viewIsDescendantOf', 'PopupMenu', 'LazyViewManagersEnabled', 'ViewManagerNames', 'StyleConstants', 'AccessibilityEventTypes', 'UIView', 'getViewManagerConfig', 'blur', 'focus', 'genericBubblingEventTypes', 'genericDirectEventTypes', 'lazilyLoadView'];
},50,[],"node_modules/react-native/Libraries/ReactNative/UIManagerProperties.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");

  var _defineProperty = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/defineProperty");

  var _objectWithoutProperties = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/objectWithoutProperties");

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native/Libraries/Components/ActivityIndicator/ActivityIndicator.js";

  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

  var Platform = _$$_REQUIRE(_dependencyMap[3], "../../Utilities/Platform");

  var React = _$$_REQUIRE(_dependencyMap[4], "react");

  var StyleSheet = _$$_REQUIRE(_dependencyMap[5], "../../StyleSheet/StyleSheet");

  var View = _$$_REQUIRE(_dependencyMap[6], "../View/View");

  var PlatformActivityIndicator = "android" === 'android' ? _$$_REQUIRE(_dependencyMap[7], "../ProgressBarAndroid/ProgressBarAndroid") : _$$_REQUIRE(_dependencyMap[8], "./ActivityIndicatorViewNativeComponent").default;
  var GRAY = '#999999';

  var ActivityIndicator = function ActivityIndicator(props, forwardedRef) {
    var onLayout = props.onLayout,
        style = props.style,
        size = props.size,
        restProps = _objectWithoutProperties(props, ["onLayout", "style", "size"]);

    var sizeStyle;
    var 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;
    }

    var nativeProps = _objectSpread({}, restProps, {
      ref: forwardedRef,
      style: sizeStyle,
      size: sizeProp
    });

    var androidProps = {
      styleAttr: 'Normal',
      indeterminate: true
    };
    return React.createElement(View, {
      onLayout: onLayout,
      style: StyleSheet.compose(styles.container, style),
      __source: {
        fileName: _jsxFileName,
        lineNumber: 102
      }
    }, "android" === 'android' ? React.createElement(PlatformActivityIndicator, _extends({}, nativeProps, androidProps, {
      __source: {
        fileName: _jsxFileName,
        lineNumber: 110
      }
    })) : React.createElement(PlatformActivityIndicator, _extends({}, nativeProps, {
      __source: {
        fileName: _jsxFileName,
        lineNumber: 112
      }
    })));
  };

  var ActivityIndicatorWithRef = React.forwardRef(ActivityIndicator);
  ActivityIndicatorWithRef.displayName = 'ActivityIndicator';
  ActivityIndicatorWithRef.defaultProps = {
    animating: true,
    color: "android" === 'ios' ? GRAY : null,
    hidesWhenStopped: true,
    size: 'small'
  };
  var styles = StyleSheet.create({
    container: {
      alignItems: 'center',
      justifyContent: 'center'
    },
    sizeSmall: {
      width: 20,
      height: 20
    },
    sizeLarge: {
      width: 36,
      height: 36
    }
  });
  module.exports = ActivityIndicatorWithRef;
},51,[13,46,52,48,54,60,86,220,223],"node_modules/react-native/Libraries/Components/ActivityIndicator/ActivityIndicator.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var objectWithoutPropertiesLoose = _$$_REQUIRE(_dependencyMap[0], "./objectWithoutPropertiesLoose");

  function _objectWithoutProperties(source, excluded) {
    if (source == null) return {};
    var target = objectWithoutPropertiesLoose(source, excluded);
    var key, i;

    if (Object.getOwnPropertySymbols) {
      var sourceSymbolKeys = Object.getOwnPropertySymbols(source);

      for (i = 0; i < sourceSymbolKeys.length; i++) {
        key = sourceSymbolKeys[i];
        if (excluded.indexOf(key) >= 0) continue;
        if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
        target[key] = source[key];
      }
    }

    return target;
  }

  module.exports = _objectWithoutProperties;
},52,[53],"node_modules/@babel/runtime/helpers/objectWithoutProperties.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  function _objectWithoutPropertiesLoose(source, excluded) {
    if (source == null) return {};
    var target = {};
    var sourceKeys = Object.keys(source);
    var key, i;

    for (i = 0; i < sourceKeys.length; i++) {
      key = sourceKeys[i];
      if (excluded.indexOf(key) >= 0) continue;
      target[key] = source[key];
    }

    return target;
  }

  module.exports = _objectWithoutPropertiesLoose;
},53,[],"node_modules/@babel/runtime/helpers/objectWithoutPropertiesLoose.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  if (process.env.NODE_ENV === 'production') {
    module.exports = _$$_REQUIRE(_dependencyMap[0], "./cjs/react.production.min.js");
  } else {
    module.exports = _$$_REQUIRE(_dependencyMap[1], "./cjs/react.development.js");
  }
},54,[55,57],"node_modules/react/index.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  /** @license React v16.9.0
   * react.production.min.js
   *
   * 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.
   */
  'use strict';

  var h = _$$_REQUIRE(_dependencyMap[0], "object-assign"),
      n = "function" === typeof Symbol && (typeof Symbol === "function" ? Symbol.for : "@@for"),
      p = n ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.element") : 60103,
      q = n ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.portal") : 60106,
      r = n ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.fragment") : 60107,
      t = n ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.strict_mode") : 60108,
      u = n ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.profiler") : 60114,
      v = n ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.provider") : 60109,
      w = n ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.context") : 60110,
      x = n ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.forward_ref") : 60112,
      y = n ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.suspense") : 60113,
      aa = n ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.suspense_list") : 60120,
      ba = n ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.memo") : 60115,
      ca = n ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.lazy") : 60116;

  n && (typeof Symbol === "function" ? Symbol.for : "@@for")("react.fundamental");
  n && (typeof Symbol === "function" ? Symbol.for : "@@for")("react.responder");
  var z = "function" === typeof Symbol && (typeof Symbol === "function" ? Symbol.iterator : "@@iterator");

  function A(a) {
    for (var b = a.message, d = "https://reactjs.org/docs/error-decoder.html?invariant=" + b, c = 1; c < arguments.length; c++) {
      d += "&args[]=" + encodeURIComponent(arguments[c]);
    }

    a.message = "Minified React error #" + b + "; visit " + d + " for the full message or use the non-minified dev environment for full errors and additional helpful warnings. ";
    return a;
  }

  var B = {
    isMounted: function isMounted() {
      return !1;
    },
    enqueueForceUpdate: function enqueueForceUpdate() {},
    enqueueReplaceState: function enqueueReplaceState() {},
    enqueueSetState: function enqueueSetState() {}
  },
      C = {};

  function D(a, b, d) {
    this.props = a;
    this.context = b;
    this.refs = C;
    this.updater = d || B;
  }

  D.prototype.isReactComponent = {};

  D.prototype.setState = function (a, b) {
    if ("object" !== typeof a && "function" !== typeof a && null != a) throw A(Error(85));
    this.updater.enqueueSetState(this, a, b, "setState");
  };

  D.prototype.forceUpdate = function (a) {
    this.updater.enqueueForceUpdate(this, a, "forceUpdate");
  };

  function E() {}

  E.prototype = D.prototype;

  function F(a, b, d) {
    this.props = a;
    this.context = b;
    this.refs = C;
    this.updater = d || B;
  }

  var G = F.prototype = new E();
  G.constructor = F;
  h(G, D.prototype);
  G.isPureReactComponent = !0;
  var H = {
    current: null
  },
      I = {
    suspense: null
  },
      J = {
    current: null
  },
      K = Object.prototype.hasOwnProperty,
      L = {
    key: !0,
    ref: !0,
    __self: !0,
    __source: !0
  };

  function M(a, b, d) {
    var c = void 0,
        e = {},
        g = null,
        k = null;
    if (null != b) for (c in void 0 !== b.ref && (k = b.ref), void 0 !== b.key && (g = "" + b.key), b) {
      K.call(b, c) && !L.hasOwnProperty(c) && (e[c] = b[c]);
    }
    var f = arguments.length - 2;
    if (1 === f) e.children = d;else if (1 < f) {
      for (var l = Array(f), m = 0; m < f; m++) {
        l[m] = arguments[m + 2];
      }

      e.children = l;
    }
    if (a && a.defaultProps) for (c in f = a.defaultProps, f) {
      void 0 === e[c] && (e[c] = f[c]);
    }
    return {
      $$typeof: p,
      type: a,
      key: g,
      ref: k,
      props: e,
      _owner: J.current
    };
  }

  function da(a, b) {
    return {
      $$typeof: p,
      type: a.type,
      key: b,
      ref: a.ref,
      props: a.props,
      _owner: a._owner
    };
  }

  function N(a) {
    return "object" === typeof a && null !== a && a.$$typeof === p;
  }

  function escape(a) {
    var b = {
      "=": "=0",
      ":": "=2"
    };
    return "$" + ("" + a).replace(/[=:]/g, function (a) {
      return b[a];
    });
  }

  var O = /\/+/g,
      P = [];

  function Q(a, b, d, c) {
    if (P.length) {
      var e = P.pop();
      e.result = a;
      e.keyPrefix = b;
      e.func = d;
      e.context = c;
      e.count = 0;
      return e;
    }

    return {
      result: a,
      keyPrefix: b,
      func: d,
      context: c,
      count: 0
    };
  }

  function R(a) {
    a.result = null;
    a.keyPrefix = null;
    a.func = null;
    a.context = null;
    a.count = 0;
    10 > P.length && P.push(a);
  }

  function S(a, b, d, c) {
    var e = typeof a;
    if ("undefined" === e || "boolean" === e) a = null;
    var g = !1;
    if (null === a) g = !0;else switch (e) {
      case "string":
      case "number":
        g = !0;
        break;

      case "object":
        switch (a.$$typeof) {
          case p:
          case q:
            g = !0;
        }

    }
    if (g) return d(c, a, "" === b ? "." + T(a, 0) : b), 1;
    g = 0;
    b = "" === b ? "." : b + ":";
    if (Array.isArray(a)) for (var k = 0; k < a.length; k++) {
      e = a[k];
      var f = b + T(e, k);
      g += S(e, f, d, c);
    } else if (null === a || "object" !== typeof a ? f = null : (f = z && a[z] || a["@@iterator"], f = "function" === typeof f ? f : null), "function" === typeof f) for (a = f.call(a), k = 0; !(e = a.next()).done;) {
      e = e.value, f = b + T(e, k++), g += S(e, f, d, c);
    } else if ("object" === e) throw d = "" + a, A(Error(31), "[object Object]" === d ? "object with keys {" + Object.keys(a).join(", ") + "}" : d, "");
    return g;
  }

  function U(a, b, d) {
    return null == a ? 0 : S(a, "", b, d);
  }

  function T(a, b) {
    return "object" === typeof a && null !== a && null != a.key ? escape(a.key) : b.toString(36);
  }

  function ea(a, b) {
    a.func.call(a.context, b, a.count++);
  }

  function fa(a, b, d) {
    var c = a.result,
        e = a.keyPrefix;
    a = a.func.call(a.context, b, a.count++);
    Array.isArray(a) ? V(a, c, d, function (a) {
      return a;
    }) : null != a && (N(a) && (a = da(a, e + (!a.key || b && b.key === a.key ? "" : ("" + a.key).replace(O, "$&/") + "/") + d)), c.push(a));
  }

  function V(a, b, d, c, e) {
    var g = "";
    null != d && (g = ("" + d).replace(O, "$&/") + "/");
    b = Q(b, g, c, e);
    U(a, fa, b);
    R(b);
  }

  function W() {
    var a = H.current;
    if (null === a) throw A(Error(321));
    return a;
  }

  var X = {
    Children: {
      map: function map(a, b, d) {
        if (null == a) return a;
        var c = [];
        V(a, c, null, b, d);
        return c;
      },
      forEach: function forEach(a, b, d) {
        if (null == a) return a;
        b = Q(null, null, b, d);
        U(a, ea, b);
        R(b);
      },
      count: function count(a) {
        return U(a, function () {
          return null;
        }, null);
      },
      toArray: function toArray(a) {
        var b = [];
        V(a, b, null, function (a) {
          return a;
        });
        return b;
      },
      only: function only(a) {
        if (!N(a)) throw A(Error(143));
        return a;
      }
    },
    createRef: function createRef() {
      return {
        current: null
      };
    },
    Component: D,
    PureComponent: F,
    createContext: function createContext(a, b) {
      void 0 === b && (b = null);
      a = {
        $$typeof: w,
        _calculateChangedBits: b,
        _currentValue: a,
        _currentValue2: a,
        _threadCount: 0,
        Provider: null,
        Consumer: null
      };
      a.Provider = {
        $$typeof: v,
        _context: a
      };
      return a.Consumer = a;
    },
    forwardRef: function forwardRef(a) {
      return {
        $$typeof: x,
        render: a
      };
    },
    lazy: function lazy(a) {
      return {
        $$typeof: ca,
        _ctor: a,
        _status: -1,
        _result: null
      };
    },
    memo: function memo(a, b) {
      return {
        $$typeof: ba,
        type: a,
        compare: void 0 === b ? null : b
      };
    },
    useCallback: function useCallback(a, b) {
      return W().useCallback(a, b);
    },
    useContext: function useContext(a, b) {
      return W().useContext(a, b);
    },
    useEffect: function useEffect(a, b) {
      return W().useEffect(a, b);
    },
    useImperativeHandle: function useImperativeHandle(a, b, d) {
      return W().useImperativeHandle(a, b, d);
    },
    useDebugValue: function useDebugValue() {},
    useLayoutEffect: function useLayoutEffect(a, b) {
      return W().useLayoutEffect(a, b);
    },
    useMemo: function useMemo(a, b) {
      return W().useMemo(a, b);
    },
    useReducer: function useReducer(a, b, d) {
      return W().useReducer(a, b, d);
    },
    useRef: function useRef(a) {
      return W().useRef(a);
    },
    useState: function useState(a) {
      return W().useState(a);
    },
    Fragment: r,
    Profiler: u,
    StrictMode: t,
    Suspense: y,
    unstable_SuspenseList: aa,
    createElement: M,
    cloneElement: function cloneElement(a, b, d) {
      if (null === a || void 0 === a) throw A(Error(267), a);
      var c = void 0,
          e = h({}, a.props),
          g = a.key,
          k = a.ref,
          f = a._owner;

      if (null != b) {
        void 0 !== b.ref && (k = b.ref, f = J.current);
        void 0 !== b.key && (g = "" + b.key);
        var l = void 0;
        a.type && a.type.defaultProps && (l = a.type.defaultProps);

        for (c in b) {
          K.call(b, c) && !L.hasOwnProperty(c) && (e[c] = void 0 === b[c] && void 0 !== l ? l[c] : b[c]);
        }
      }

      c = arguments.length - 2;
      if (1 === c) e.children = d;else if (1 < c) {
        l = Array(c);

        for (var m = 0; m < c; m++) {
          l[m] = arguments[m + 2];
        }

        e.children = l;
      }
      return {
        $$typeof: p,
        type: a.type,
        key: g,
        ref: k,
        props: e,
        _owner: f
      };
    },
    createFactory: function createFactory(a) {
      var b = M.bind(null, a);
      b.type = a;
      return b;
    },
    isValidElement: N,
    version: "16.9.0",
    unstable_withSuspenseConfig: function unstable_withSuspenseConfig(a, b) {
      var d = I.suspense;
      I.suspense = void 0 === b ? null : b;

      try {
        a();
      } finally {
        I.suspense = d;
      }
    },
    __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED: {
      ReactCurrentDispatcher: H,
      ReactCurrentBatchConfig: I,
      ReactCurrentOwner: J,
      IsSomeRendererActing: {
        current: !1
      },
      assign: h
    }
  },
      Y = {
    default: X
  },
      Z = Y && X || Y;
  module.exports = Z.default || Z;
},55,[56],"node_modules/react/cjs/react.production.min.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  /*
  object-assign
  (c) Sindre Sorhus
  @license MIT
  */
  'use strict';

  var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");

  var getOwnPropertySymbols = Object.getOwnPropertySymbols;
  var hasOwnProperty = Object.prototype.hasOwnProperty;
  var propIsEnumerable = Object.prototype.propertyIsEnumerable;

  function toObject(val) {
    if (val === null || val === undefined) {
      throw new TypeError('Object.assign cannot be called with null or undefined');
    }

    return Object(val);
  }

  function shouldUseNative() {
    try {
      if (!Object.assign) {
        return false;
      }

      var test1 = new String('abc');
      test1[5] = 'de';

      if (Object.getOwnPropertyNames(test1)[0] === '5') {
        return false;
      }

      var test2 = {};

      for (var i = 0; i < 10; i++) {
        test2['_' + String.fromCharCode(i)] = i;
      }

      var order2 = Object.getOwnPropertyNames(test2).map(function (n) {
        return test2[n];
      });

      if (order2.join('') !== '0123456789') {
        return false;
      }

      var test3 = {};
      'abcdefghijklmnopqrst'.split('').forEach(function (letter) {
        test3[letter] = letter;
      });

      if (Object.keys(_extends({}, test3)).join('') !== 'abcdefghijklmnopqrst') {
        return false;
      }

      return true;
    } catch (err) {
      return false;
    }
  }

  module.exports = shouldUseNative() ? Object.assign : function (target, source) {
    var from;
    var to = toObject(target);
    var symbols;

    for (var s = 1; s < arguments.length; s++) {
      from = Object(arguments[s]);

      for (var key in from) {
        if (hasOwnProperty.call(from, key)) {
          to[key] = from[key];
        }
      }

      if (getOwnPropertySymbols) {
        symbols = getOwnPropertySymbols(from);

        for (var i = 0; i < symbols.length; i++) {
          if (propIsEnumerable.call(from, symbols[i])) {
            to[symbols[i]] = from[symbols[i]];
          }
        }
      }
    }

    return to;
  };
},56,[13],"node_modules/object-assign/index.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  /** @license React v16.9.0
   * react.development.js
   *
   * 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.
   */
  'use strict';

  if (process.env.NODE_ENV !== "production") {
    (function () {
      'use strict';

      var _assign = _$$_REQUIRE(_dependencyMap[0], "object-assign");

      var checkPropTypes = _$$_REQUIRE(_dependencyMap[1], "prop-types/checkPropTypes");

      var ReactVersion = '16.9.0';
      var hasSymbol = typeof Symbol === 'function' && (typeof Symbol === "function" ? Symbol.for : "@@for");
      var REACT_ELEMENT_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.element') : 0xeac7;
      var REACT_PORTAL_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.portal') : 0xeaca;
      var REACT_FRAGMENT_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.fragment') : 0xeacb;
      var REACT_STRICT_MODE_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.strict_mode') : 0xeacc;
      var REACT_PROFILER_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.profiler') : 0xead2;
      var REACT_PROVIDER_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.provider') : 0xeacd;
      var REACT_CONTEXT_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.context') : 0xeace;
      var REACT_CONCURRENT_MODE_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.concurrent_mode') : 0xeacf;
      var REACT_FORWARD_REF_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.forward_ref') : 0xead0;
      var REACT_SUSPENSE_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.suspense') : 0xead1;
      var REACT_SUSPENSE_LIST_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.suspense_list') : 0xead8;
      var REACT_MEMO_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.memo') : 0xead3;
      var REACT_LAZY_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.lazy') : 0xead4;
      var REACT_FUNDAMENTAL_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.fundamental') : 0xead5;
      var REACT_RESPONDER_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.responder') : 0xead6;
      var MAYBE_ITERATOR_SYMBOL = typeof Symbol === 'function' && (typeof Symbol === "function" ? Symbol.iterator : "@@iterator");
      var FAUX_ITERATOR_SYMBOL = '@@iterator';

      function getIteratorFn(maybeIterable) {
        if (maybeIterable === null || typeof maybeIterable !== 'object') {
          return null;
        }

        var maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];

        if (typeof maybeIterator === 'function') {
          return maybeIterator;
        }

        return null;
      }

      function ReactError(error) {
        error.name = 'Invariant Violation';
        return error;
      }

      var lowPriorityWarning = function lowPriorityWarning() {};

      {
        var printWarning = function printWarning(format) {
          for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
            args[_key - 1] = arguments[_key];
          }

          var argIndex = 0;
          var message = 'Warning: ' + format.replace(/%s/g, function () {
            return args[argIndex++];
          });

          if (typeof console !== 'undefined') {
            console.warn(message);
          }

          try {
            throw new Error(message);
          } catch (x) {}
        };

        lowPriorityWarning = function lowPriorityWarning(condition, format) {
          if (format === undefined) {
            throw new Error('`lowPriorityWarning(condition, format, ...args)` requires a warning ' + 'message argument');
          }

          if (!condition) {
            for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
              args[_key2 - 2] = arguments[_key2];
            }

            printWarning.apply(undefined, [format].concat(args));
          }
        };
      }
      var lowPriorityWarning$1 = lowPriorityWarning;

      var warningWithoutStack = function warningWithoutStack() {};

      {
        warningWithoutStack = function warningWithoutStack(condition, format) {
          for (var _len = arguments.length, args = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
            args[_key - 2] = arguments[_key];
          }

          if (format === undefined) {
            throw new Error('`warningWithoutStack(condition, format, ...args)` requires a warning ' + 'message argument');
          }

          if (args.length > 8) {
            throw new Error('warningWithoutStack() currently supports at most 8 arguments.');
          }

          if (condition) {
            return;
          }

          if (typeof console !== 'undefined') {
            var argsWithFormat = args.map(function (item) {
              return '' + item;
            });
            argsWithFormat.unshift('Warning: ' + format);
            Function.prototype.apply.call(console.error, console, argsWithFormat);
          }

          try {
            var argIndex = 0;
            var message = 'Warning: ' + format.replace(/%s/g, function () {
              return args[argIndex++];
            });
            throw new Error(message);
          } catch (x) {}
        };
      }
      var warningWithoutStack$1 = warningWithoutStack;
      var didWarnStateUpdateForUnmountedComponent = {};

      function warnNoop(publicInstance, callerName) {
        {
          var _constructor = publicInstance.constructor;
          var componentName = _constructor && (_constructor.displayName || _constructor.name) || 'ReactClass';
          var warningKey = componentName + '.' + callerName;

          if (didWarnStateUpdateForUnmountedComponent[warningKey]) {
            return;
          }

          warningWithoutStack$1(false, "Can't call %s on a component that is not yet mounted. " + 'This is a no-op, but it might indicate a bug in your application. ' + 'Instead, assign to `this.state` directly or define a `state = {};` ' + 'class property with the desired state in the %s component.', callerName, componentName);
          didWarnStateUpdateForUnmountedComponent[warningKey] = true;
        }
      }

      var ReactNoopUpdateQueue = {
        isMounted: function isMounted(publicInstance) {
          return false;
        },
        enqueueForceUpdate: function enqueueForceUpdate(publicInstance, callback, callerName) {
          warnNoop(publicInstance, 'forceUpdate');
        },
        enqueueReplaceState: function enqueueReplaceState(publicInstance, completeState, callback, callerName) {
          warnNoop(publicInstance, 'replaceState');
        },
        enqueueSetState: function enqueueSetState(publicInstance, partialState, callback, callerName) {
          warnNoop(publicInstance, 'setState');
        }
      };
      var emptyObject = {};
      {
        Object.freeze(emptyObject);
      }

      function Component(props, context, updater) {
        this.props = props;
        this.context = context;
        this.refs = emptyObject;
        this.updater = updater || ReactNoopUpdateQueue;
      }

      Component.prototype.isReactComponent = {};

      Component.prototype.setState = function (partialState, callback) {
        (function () {
          if (!(typeof partialState === 'object' || typeof partialState === 'function' || partialState == null)) {
            {
              throw ReactError(Error('setState(...): takes an object of state variables to update or a function which returns an object of state variables.'));
            }
          }
        })();

        this.updater.enqueueSetState(this, partialState, callback, 'setState');
      };

      Component.prototype.forceUpdate = function (callback) {
        this.updater.enqueueForceUpdate(this, callback, 'forceUpdate');
      };

      {
        var deprecatedAPIs = {
          isMounted: ['isMounted', 'Instead, make sure to clean up subscriptions and pending requests in ' + 'componentWillUnmount to prevent memory leaks.'],
          replaceState: ['replaceState', 'Refactor your code to use setState instead (see ' + 'https://github.com/facebook/react/issues/3236).']
        };

        var defineDeprecationWarning = function defineDeprecationWarning(methodName, info) {
          Object.defineProperty(Component.prototype, methodName, {
            get: function get() {
              lowPriorityWarning$1(false, '%s(...) is deprecated in plain JavaScript React classes. %s', info[0], info[1]);
              return undefined;
            }
          });
        };

        for (var fnName in deprecatedAPIs) {
          if (deprecatedAPIs.hasOwnProperty(fnName)) {
            defineDeprecationWarning(fnName, deprecatedAPIs[fnName]);
          }
        }
      }

      function ComponentDummy() {}

      ComponentDummy.prototype = Component.prototype;

      function PureComponent(props, context, updater) {
        this.props = props;
        this.context = context;
        this.refs = emptyObject;
        this.updater = updater || ReactNoopUpdateQueue;
      }

      var pureComponentPrototype = PureComponent.prototype = new ComponentDummy();
      pureComponentPrototype.constructor = PureComponent;

      _assign(pureComponentPrototype, Component.prototype);

      pureComponentPrototype.isPureReactComponent = true;

      function createRef() {
        var refObject = {
          current: null
        };
        {
          Object.seal(refObject);
        }
        return refObject;
      }

      var ReactCurrentDispatcher = {
        current: null
      };
      var ReactCurrentBatchConfig = {
        suspense: null
      };
      var ReactCurrentOwner = {
        current: null
      };
      var BEFORE_SLASH_RE = /^(.*)[\\\/]/;

      var describeComponentFrame = function describeComponentFrame(name, source, ownerName) {
        var sourceInfo = '';

        if (source) {
          var path = source.fileName;
          var fileName = path.replace(BEFORE_SLASH_RE, '');
          {
            if (/^index\./.test(fileName)) {
              var match = path.match(BEFORE_SLASH_RE);

              if (match) {
                var pathBeforeSlash = match[1];

                if (pathBeforeSlash) {
                  var folderName = pathBeforeSlash.replace(BEFORE_SLASH_RE, '');
                  fileName = folderName + '/' + fileName;
                }
              }
            }
          }
          sourceInfo = ' (at ' + fileName + ':' + source.lineNumber + ')';
        } else if (ownerName) {
          sourceInfo = ' (created by ' + ownerName + ')';
        }

        return '\n    in ' + (name || 'Unknown') + sourceInfo;
      };

      var Resolved = 1;

      function refineResolvedLazyComponent(lazyComponent) {
        return lazyComponent._status === Resolved ? lazyComponent._result : null;
      }

      function getWrappedName(outerType, innerType, wrapperName) {
        var functionName = innerType.displayName || innerType.name || '';
        return outerType.displayName || (functionName !== '' ? wrapperName + '(' + functionName + ')' : wrapperName);
      }

      function getComponentName(type) {
        if (type == null) {
          return null;
        }

        {
          if (typeof type.tag === 'number') {
            warningWithoutStack$1(false, 'Received an unexpected object in getComponentName(). ' + 'This is likely a bug in React. Please file an issue.');
          }
        }

        if (typeof type === 'function') {
          return type.displayName || type.name || null;
        }

        if (typeof type === 'string') {
          return type;
        }

        switch (type) {
          case REACT_FRAGMENT_TYPE:
            return 'Fragment';

          case REACT_PORTAL_TYPE:
            return 'Portal';

          case REACT_PROFILER_TYPE:
            return 'Profiler';

          case REACT_STRICT_MODE_TYPE:
            return 'StrictMode';

          case REACT_SUSPENSE_TYPE:
            return 'Suspense';

          case REACT_SUSPENSE_LIST_TYPE:
            return 'SuspenseList';
        }

        if (typeof type === 'object') {
          switch (type.$$typeof) {
            case REACT_CONTEXT_TYPE:
              return 'Context.Consumer';

            case REACT_PROVIDER_TYPE:
              return 'Context.Provider';

            case REACT_FORWARD_REF_TYPE:
              return getWrappedName(type, type.render, 'ForwardRef');

            case REACT_MEMO_TYPE:
              return getComponentName(type.type);

            case REACT_LAZY_TYPE:
              {
                var thenable = type;
                var resolvedThenable = refineResolvedLazyComponent(thenable);

                if (resolvedThenable) {
                  return getComponentName(resolvedThenable);
                }

                break;
              }
          }
        }

        return null;
      }

      var ReactDebugCurrentFrame = {};
      var currentlyValidatingElement = null;

      function setCurrentlyValidatingElement(element) {
        {
          currentlyValidatingElement = element;
        }
      }

      {
        ReactDebugCurrentFrame.getCurrentStack = null;

        ReactDebugCurrentFrame.getStackAddendum = function () {
          var stack = '';

          if (currentlyValidatingElement) {
            var name = getComponentName(currentlyValidatingElement.type);
            var owner = currentlyValidatingElement._owner;
            stack += describeComponentFrame(name, currentlyValidatingElement._source, owner && getComponentName(owner.type));
          }

          var impl = ReactDebugCurrentFrame.getCurrentStack;

          if (impl) {
            stack += impl() || '';
          }

          return stack;
        };
      }
      var IsSomeRendererActing = {
        current: false
      };
      var ReactSharedInternals = {
        ReactCurrentDispatcher: ReactCurrentDispatcher,
        ReactCurrentBatchConfig: ReactCurrentBatchConfig,
        ReactCurrentOwner: ReactCurrentOwner,
        IsSomeRendererActing: IsSomeRendererActing,
        assign: _assign
      };
      {
        _assign(ReactSharedInternals, {
          ReactDebugCurrentFrame: ReactDebugCurrentFrame,
          ReactComponentTreeHook: {}
        });
      }
      var warning = warningWithoutStack$1;
      {
        warning = function warning(condition, format) {
          if (condition) {
            return;
          }

          var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
          var stack = ReactDebugCurrentFrame.getStackAddendum();

          for (var _len = arguments.length, args = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
            args[_key - 2] = arguments[_key];
          }

          warningWithoutStack$1.apply(undefined, [false, format + '%s'].concat(args, [stack]));
        };
      }
      var warning$1 = warning;
      var hasOwnProperty = Object.prototype.hasOwnProperty;
      var RESERVED_PROPS = {
        key: true,
        ref: true,
        __self: true,
        __source: true
      };
      var specialPropKeyWarningShown = void 0;
      var specialPropRefWarningShown = void 0;

      function hasValidRef(config) {
        {
          if (hasOwnProperty.call(config, 'ref')) {
            var getter = Object.getOwnPropertyDescriptor(config, 'ref').get;

            if (getter && getter.isReactWarning) {
              return false;
            }
          }
        }
        return config.ref !== undefined;
      }

      function hasValidKey(config) {
        {
          if (hasOwnProperty.call(config, 'key')) {
            var getter = Object.getOwnPropertyDescriptor(config, 'key').get;

            if (getter && getter.isReactWarning) {
              return false;
            }
          }
        }
        return config.key !== undefined;
      }

      function defineKeyPropWarningGetter(props, displayName) {
        var warnAboutAccessingKey = function warnAboutAccessingKey() {
          if (!specialPropKeyWarningShown) {
            specialPropKeyWarningShown = true;
            warningWithoutStack$1(false, '%s: `key` is not a prop. Trying to access it will result ' + 'in `undefined` being returned. If you need to access the same ' + 'value within the child component, you should pass it as a different ' + 'prop. (https://fb.me/react-special-props)', displayName);
          }
        };

        warnAboutAccessingKey.isReactWarning = true;
        Object.defineProperty(props, 'key', {
          get: warnAboutAccessingKey,
          configurable: true
        });
      }

      function defineRefPropWarningGetter(props, displayName) {
        var warnAboutAccessingRef = function warnAboutAccessingRef() {
          if (!specialPropRefWarningShown) {
            specialPropRefWarningShown = true;
            warningWithoutStack$1(false, '%s: `ref` is not a prop. Trying to access it will result ' + 'in `undefined` being returned. If you need to access the same ' + 'value within the child component, you should pass it as a different ' + 'prop. (https://fb.me/react-special-props)', displayName);
          }
        };

        warnAboutAccessingRef.isReactWarning = true;
        Object.defineProperty(props, 'ref', {
          get: warnAboutAccessingRef,
          configurable: true
        });
      }

      var ReactElement = function ReactElement(type, key, ref, self, source, owner, props) {
        var element = {
          $$typeof: REACT_ELEMENT_TYPE,
          type: type,
          key: key,
          ref: ref,
          props: props,
          _owner: owner
        };
        {
          element._store = {};
          Object.defineProperty(element._store, 'validated', {
            configurable: false,
            enumerable: false,
            writable: true,
            value: false
          });
          Object.defineProperty(element, '_self', {
            configurable: false,
            enumerable: false,
            writable: false,
            value: self
          });
          Object.defineProperty(element, '_source', {
            configurable: false,
            enumerable: false,
            writable: false,
            value: source
          });

          if (Object.freeze) {
            Object.freeze(element.props);
            Object.freeze(element);
          }
        }
        return element;
      };

      function jsxDEV(type, config, maybeKey, source, self) {
        var propName = void 0;
        var props = {};
        var key = null;
        var ref = null;

        if (hasValidRef(config)) {
          ref = config.ref;
        }

        if (hasValidKey(config)) {
          key = '' + config.key;
        }

        for (propName in config) {
          if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
            props[propName] = config[propName];
          }
        }

        if (maybeKey !== undefined) {
          key = '' + maybeKey;
        }

        if (type && type.defaultProps) {
          var defaultProps = type.defaultProps;

          for (propName in defaultProps) {
            if (props[propName] === undefined) {
              props[propName] = defaultProps[propName];
            }
          }
        }

        if (key || ref) {
          var displayName = typeof type === 'function' ? type.displayName || type.name || 'Unknown' : type;

          if (key) {
            defineKeyPropWarningGetter(props, displayName);
          }

          if (ref) {
            defineRefPropWarningGetter(props, displayName);
          }
        }

        return ReactElement(type, key, ref, self, source, ReactCurrentOwner.current, props);
      }

      function createElement(type, config, children) {
        var propName = void 0;
        var props = {};
        var key = null;
        var ref = null;
        var self = null;
        var source = null;

        if (config != null) {
          if (hasValidRef(config)) {
            ref = config.ref;
          }

          if (hasValidKey(config)) {
            key = '' + config.key;
          }

          self = config.__self === undefined ? null : config.__self;
          source = config.__source === undefined ? null : config.__source;

          for (propName in config) {
            if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
              props[propName] = config[propName];
            }
          }
        }

        var childrenLength = arguments.length - 2;

        if (childrenLength === 1) {
          props.children = children;
        } else if (childrenLength > 1) {
          var childArray = Array(childrenLength);

          for (var i = 0; i < childrenLength; i++) {
            childArray[i] = arguments[i + 2];
          }

          {
            if (Object.freeze) {
              Object.freeze(childArray);
            }
          }
          props.children = childArray;
        }

        if (type && type.defaultProps) {
          var defaultProps = type.defaultProps;

          for (propName in defaultProps) {
            if (props[propName] === undefined) {
              props[propName] = defaultProps[propName];
            }
          }
        }

        {
          if (key || ref) {
            var displayName = typeof type === 'function' ? type.displayName || type.name || 'Unknown' : type;

            if (key) {
              defineKeyPropWarningGetter(props, displayName);
            }

            if (ref) {
              defineRefPropWarningGetter(props, displayName);
            }
          }
        }
        return ReactElement(type, key, ref, self, source, ReactCurrentOwner.current, props);
      }

      function cloneAndReplaceKey(oldElement, newKey) {
        var newElement = ReactElement(oldElement.type, newKey, oldElement.ref, oldElement._self, oldElement._source, oldElement._owner, oldElement.props);
        return newElement;
      }

      function cloneElement(element, config, children) {
        (function () {
          if (!!(element === null || element === undefined)) {
            {
              throw ReactError(Error('React.cloneElement(...): The argument must be a React element, but you passed ' + element + '.'));
            }
          }
        })();

        var propName = void 0;

        var props = _assign({}, element.props);

        var key = element.key;
        var ref = element.ref;
        var self = element._self;
        var source = element._source;
        var owner = element._owner;

        if (config != null) {
          if (hasValidRef(config)) {
            ref = config.ref;
            owner = ReactCurrentOwner.current;
          }

          if (hasValidKey(config)) {
            key = '' + config.key;
          }

          var defaultProps = void 0;

          if (element.type && element.type.defaultProps) {
            defaultProps = element.type.defaultProps;
          }

          for (propName in config) {
            if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
              if (config[propName] === undefined && defaultProps !== undefined) {
                props[propName] = defaultProps[propName];
              } else {
                props[propName] = config[propName];
              }
            }
          }
        }

        var childrenLength = arguments.length - 2;

        if (childrenLength === 1) {
          props.children = children;
        } else if (childrenLength > 1) {
          var childArray = Array(childrenLength);

          for (var i = 0; i < childrenLength; i++) {
            childArray[i] = arguments[i + 2];
          }

          props.children = childArray;
        }

        return ReactElement(element.type, key, ref, self, source, owner, props);
      }

      function isValidElement(object) {
        return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
      }

      var SEPARATOR = '.';
      var SUBSEPARATOR = ':';

      function escape(key) {
        var escapeRegex = /[=:]/g;
        var escaperLookup = {
          '=': '=0',
          ':': '=2'
        };
        var escapedString = ('' + key).replace(escapeRegex, function (match) {
          return escaperLookup[match];
        });
        return '$' + escapedString;
      }

      var didWarnAboutMaps = false;
      var userProvidedKeyEscapeRegex = /\/+/g;

      function escapeUserProvidedKey(text) {
        return ('' + text).replace(userProvidedKeyEscapeRegex, '$&/');
      }

      var POOL_SIZE = 10;
      var traverseContextPool = [];

      function getPooledTraverseContext(mapResult, keyPrefix, mapFunction, mapContext) {
        if (traverseContextPool.length) {
          var traverseContext = traverseContextPool.pop();
          traverseContext.result = mapResult;
          traverseContext.keyPrefix = keyPrefix;
          traverseContext.func = mapFunction;
          traverseContext.context = mapContext;
          traverseContext.count = 0;
          return traverseContext;
        } else {
          return {
            result: mapResult,
            keyPrefix: keyPrefix,
            func: mapFunction,
            context: mapContext,
            count: 0
          };
        }
      }

      function releaseTraverseContext(traverseContext) {
        traverseContext.result = null;
        traverseContext.keyPrefix = null;
        traverseContext.func = null;
        traverseContext.context = null;
        traverseContext.count = 0;

        if (traverseContextPool.length < POOL_SIZE) {
          traverseContextPool.push(traverseContext);
        }
      }

      function traverseAllChildrenImpl(children, nameSoFar, callback, traverseContext) {
        var type = typeof children;

        if (type === 'undefined' || type === 'boolean') {
          children = null;
        }

        var invokeCallback = false;

        if (children === null) {
          invokeCallback = true;
        } else {
          switch (type) {
            case 'string':
            case 'number':
              invokeCallback = true;
              break;

            case 'object':
              switch (children.$$typeof) {
                case REACT_ELEMENT_TYPE:
                case REACT_PORTAL_TYPE:
                  invokeCallback = true;
              }

          }
        }

        if (invokeCallback) {
          callback(traverseContext, children, nameSoFar === '' ? SEPARATOR + getComponentKey(children, 0) : nameSoFar);
          return 1;
        }

        var child = void 0;
        var nextName = void 0;
        var subtreeCount = 0;
        var nextNamePrefix = nameSoFar === '' ? SEPARATOR : nameSoFar + SUBSEPARATOR;

        if (Array.isArray(children)) {
          for (var i = 0; i < children.length; i++) {
            child = children[i];
            nextName = nextNamePrefix + getComponentKey(child, i);
            subtreeCount += traverseAllChildrenImpl(child, nextName, callback, traverseContext);
          }
        } else {
          var iteratorFn = getIteratorFn(children);

          if (typeof iteratorFn === 'function') {
            {
              if (iteratorFn === children.entries) {
                !didWarnAboutMaps ? warning$1(false, 'Using Maps as children is unsupported and will likely yield ' + 'unexpected results. Convert it to a sequence/iterable of keyed ' + 'ReactElements instead.') : void 0;
                didWarnAboutMaps = true;
              }
            }
            var iterator = iteratorFn.call(children);
            var step = void 0;
            var ii = 0;

            while (!(step = iterator.next()).done) {
              child = step.value;
              nextName = nextNamePrefix + getComponentKey(child, ii++);
              subtreeCount += traverseAllChildrenImpl(child, nextName, callback, traverseContext);
            }
          } else if (type === 'object') {
            var addendum = '';
            {
              addendum = ' If you meant to render a collection of children, use an array ' + 'instead.' + ReactDebugCurrentFrame.getStackAddendum();
            }
            var childrenString = '' + children;

            (function () {
              {
                {
                  throw ReactError(Error('Objects are not valid as a React child (found: ' + (childrenString === '[object Object]' ? 'object with keys {' + Object.keys(children).join(', ') + '}' : childrenString) + ').' + addendum));
                }
              }
            })();
          }
        }

        return subtreeCount;
      }

      function traverseAllChildren(children, callback, traverseContext) {
        if (children == null) {
          return 0;
        }

        return traverseAllChildrenImpl(children, '', callback, traverseContext);
      }

      function getComponentKey(component, index) {
        if (typeof component === 'object' && component !== null && component.key != null) {
          return escape(component.key);
        }

        return index.toString(36);
      }

      function forEachSingleChild(bookKeeping, child, name) {
        var func = bookKeeping.func,
            context = bookKeeping.context;
        func.call(context, child, bookKeeping.count++);
      }

      function forEachChildren(children, forEachFunc, forEachContext) {
        if (children == null) {
          return children;
        }

        var traverseContext = getPooledTraverseContext(null, null, forEachFunc, forEachContext);
        traverseAllChildren(children, forEachSingleChild, traverseContext);
        releaseTraverseContext(traverseContext);
      }

      function mapSingleChildIntoContext(bookKeeping, child, childKey) {
        var result = bookKeeping.result,
            keyPrefix = bookKeeping.keyPrefix,
            func = bookKeeping.func,
            context = bookKeeping.context;
        var mappedChild = func.call(context, child, bookKeeping.count++);

        if (Array.isArray(mappedChild)) {
          mapIntoWithKeyPrefixInternal(mappedChild, result, childKey, function (c) {
            return c;
          });
        } else if (mappedChild != null) {
          if (isValidElement(mappedChild)) {
            mappedChild = cloneAndReplaceKey(mappedChild, keyPrefix + (mappedChild.key && (!child || child.key !== mappedChild.key) ? escapeUserProvidedKey(mappedChild.key) + '/' : '') + childKey);
          }

          result.push(mappedChild);
        }
      }

      function mapIntoWithKeyPrefixInternal(children, array, prefix, func, context) {
        var escapedPrefix = '';

        if (prefix != null) {
          escapedPrefix = escapeUserProvidedKey(prefix) + '/';
        }

        var traverseContext = getPooledTraverseContext(array, escapedPrefix, func, context);
        traverseAllChildren(children, mapSingleChildIntoContext, traverseContext);
        releaseTraverseContext(traverseContext);
      }

      function mapChildren(children, func, context) {
        if (children == null) {
          return children;
        }

        var result = [];
        mapIntoWithKeyPrefixInternal(children, result, null, func, context);
        return result;
      }

      function countChildren(children) {
        return traverseAllChildren(children, function () {
          return null;
        }, null);
      }

      function toArray(children) {
        var result = [];
        mapIntoWithKeyPrefixInternal(children, result, null, function (child) {
          return child;
        });
        return result;
      }

      function onlyChild(children) {
        (function () {
          if (!isValidElement(children)) {
            {
              throw ReactError(Error('React.Children.only expected to receive a single React element child.'));
            }
          }
        })();

        return children;
      }

      function createContext(defaultValue, calculateChangedBits) {
        if (calculateChangedBits === undefined) {
          calculateChangedBits = null;
        } else {
          {
            !(calculateChangedBits === null || typeof calculateChangedBits === 'function') ? warningWithoutStack$1(false, 'createContext: Expected the optional second argument to be a ' + 'function. Instead received: %s', calculateChangedBits) : void 0;
          }
        }

        var context = {
          $$typeof: REACT_CONTEXT_TYPE,
          _calculateChangedBits: calculateChangedBits,
          _currentValue: defaultValue,
          _currentValue2: defaultValue,
          _threadCount: 0,
          Provider: null,
          Consumer: null
        };
        context.Provider = {
          $$typeof: REACT_PROVIDER_TYPE,
          _context: context
        };
        var hasWarnedAboutUsingNestedContextConsumers = false;
        var hasWarnedAboutUsingConsumerProvider = false;
        {
          var Consumer = {
            $$typeof: REACT_CONTEXT_TYPE,
            _context: context,
            _calculateChangedBits: context._calculateChangedBits
          };
          Object.defineProperties(Consumer, {
            Provider: {
              get: function get() {
                if (!hasWarnedAboutUsingConsumerProvider) {
                  hasWarnedAboutUsingConsumerProvider = true;
                  warning$1(false, 'Rendering <Context.Consumer.Provider> is not supported and will be removed in ' + 'a future major release. Did you mean to render <Context.Provider> instead?');
                }

                return context.Provider;
              },
              set: function set(_Provider) {
                context.Provider = _Provider;
              }
            },
            _currentValue: {
              get: function get() {
                return context._currentValue;
              },
              set: function set(_currentValue) {
                context._currentValue = _currentValue;
              }
            },
            _currentValue2: {
              get: function get() {
                return context._currentValue2;
              },
              set: function set(_currentValue2) {
                context._currentValue2 = _currentValue2;
              }
            },
            _threadCount: {
              get: function get() {
                return context._threadCount;
              },
              set: function set(_threadCount) {
                context._threadCount = _threadCount;
              }
            },
            Consumer: {
              get: function get() {
                if (!hasWarnedAboutUsingNestedContextConsumers) {
                  hasWarnedAboutUsingNestedContextConsumers = true;
                  warning$1(false, 'Rendering <Context.Consumer.Consumer> is not supported and will be removed in ' + 'a future major release. Did you mean to render <Context.Consumer> instead?');
                }

                return context.Consumer;
              }
            }
          });
          context.Consumer = Consumer;
        }
        {
          context._currentRenderer = null;
          context._currentRenderer2 = null;
        }
        return context;
      }

      function lazy(ctor) {
        var lazyType = {
          $$typeof: REACT_LAZY_TYPE,
          _ctor: ctor,
          _status: -1,
          _result: null
        };
        {
          var defaultProps = void 0;
          var propTypes = void 0;
          Object.defineProperties(lazyType, {
            defaultProps: {
              configurable: true,
              get: function get() {
                return defaultProps;
              },
              set: function set(newDefaultProps) {
                warning$1(false, 'React.lazy(...): It is not supported to assign `defaultProps` to ' + 'a lazy component import. Either specify them where the component ' + 'is defined, or create a wrapping component around it.');
                defaultProps = newDefaultProps;
                Object.defineProperty(lazyType, 'defaultProps', {
                  enumerable: true
                });
              }
            },
            propTypes: {
              configurable: true,
              get: function get() {
                return propTypes;
              },
              set: function set(newPropTypes) {
                warning$1(false, 'React.lazy(...): It is not supported to assign `propTypes` to ' + 'a lazy component import. Either specify them where the component ' + 'is defined, or create a wrapping component around it.');
                propTypes = newPropTypes;
                Object.defineProperty(lazyType, 'propTypes', {
                  enumerable: true
                });
              }
            }
          });
        }
        return lazyType;
      }

      function forwardRef(render) {
        {
          if (render != null && render.$$typeof === REACT_MEMO_TYPE) {
            warningWithoutStack$1(false, 'forwardRef requires a render function but received a `memo` ' + 'component. Instead of forwardRef(memo(...)), use ' + 'memo(forwardRef(...)).');
          } else if (typeof render !== 'function') {
            warningWithoutStack$1(false, 'forwardRef requires a render function but was given %s.', render === null ? 'null' : typeof render);
          } else {
            !(render.length === 0 || render.length === 2) ? warningWithoutStack$1(false, 'forwardRef render functions accept exactly two parameters: props and ref. %s', render.length === 1 ? 'Did you forget to use the ref parameter?' : 'Any additional parameter will be undefined.') : void 0;
          }

          if (render != null) {
            !(render.defaultProps == null && render.propTypes == null) ? warningWithoutStack$1(false, 'forwardRef render functions do not support propTypes or defaultProps. ' + 'Did you accidentally pass a React component?') : void 0;
          }
        }
        return {
          $$typeof: REACT_FORWARD_REF_TYPE,
          render: render
        };
      }

      function isValidElementType(type) {
        return typeof type === 'string' || typeof type === 'function' || type === REACT_FRAGMENT_TYPE || type === REACT_CONCURRENT_MODE_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || typeof type === 'object' && type !== null && (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_FUNDAMENTAL_TYPE || type.$$typeof === REACT_RESPONDER_TYPE);
      }

      function memo(type, compare) {
        {
          if (!isValidElementType(type)) {
            warningWithoutStack$1(false, 'memo: The first argument must be a component. Instead ' + 'received: %s', type === null ? 'null' : typeof type);
          }
        }
        return {
          $$typeof: REACT_MEMO_TYPE,
          type: type,
          compare: compare === undefined ? null : compare
        };
      }

      function resolveDispatcher() {
        var dispatcher = ReactCurrentDispatcher.current;

        (function () {
          if (!(dispatcher !== null)) {
            {
              throw ReactError(Error('Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of the following reasons:\n1. You might have mismatching versions of React and the renderer (such as React DOM)\n2. You might be breaking the Rules of Hooks\n3. You might have more than one copy of React in the same app\nSee https://fb.me/react-invalid-hook-call for tips about how to debug and fix this problem.'));
            }
          }
        })();

        return dispatcher;
      }

      function useContext(Context, unstable_observedBits) {
        var dispatcher = resolveDispatcher();
        {
          !(unstable_observedBits === undefined) ? warning$1(false, 'useContext() second argument is reserved for future ' + 'use in React. Passing it is not supported. ' + 'You passed: %s.%s', unstable_observedBits, typeof unstable_observedBits === 'number' && Array.isArray(arguments[2]) ? '\n\nDid you call array.map(useContext)? ' + 'Calling Hooks inside a loop is not supported. ' + 'Learn more at https://fb.me/rules-of-hooks' : '') : void 0;

          if (Context._context !== undefined) {
            var realContext = Context._context;

            if (realContext.Consumer === Context) {
              warning$1(false, 'Calling useContext(Context.Consumer) is not supported, may cause bugs, and will be ' + 'removed in a future major release. Did you mean to call useContext(Context) instead?');
            } else if (realContext.Provider === Context) {
              warning$1(false, 'Calling useContext(Context.Provider) is not supported. ' + 'Did you mean to call useContext(Context) instead?');
            }
          }
        }
        return dispatcher.useContext(Context, unstable_observedBits);
      }

      function useState(initialState) {
        var dispatcher = resolveDispatcher();
        return dispatcher.useState(initialState);
      }

      function useReducer(reducer, initialArg, init) {
        var dispatcher = resolveDispatcher();
        return dispatcher.useReducer(reducer, initialArg, init);
      }

      function useRef(initialValue) {
        var dispatcher = resolveDispatcher();
        return dispatcher.useRef(initialValue);
      }

      function useEffect(create, inputs) {
        var dispatcher = resolveDispatcher();
        return dispatcher.useEffect(create, inputs);
      }

      function useLayoutEffect(create, inputs) {
        var dispatcher = resolveDispatcher();
        return dispatcher.useLayoutEffect(create, inputs);
      }

      function useCallback(callback, inputs) {
        var dispatcher = resolveDispatcher();
        return dispatcher.useCallback(callback, inputs);
      }

      function useMemo(create, inputs) {
        var dispatcher = resolveDispatcher();
        return dispatcher.useMemo(create, inputs);
      }

      function useImperativeHandle(ref, create, inputs) {
        var dispatcher = resolveDispatcher();
        return dispatcher.useImperativeHandle(ref, create, inputs);
      }

      function useDebugValue(value, formatterFn) {
        {
          var dispatcher = resolveDispatcher();
          return dispatcher.useDebugValue(value, formatterFn);
        }
      }

      var emptyObject$1 = {};

      function useResponder(responder, listenerProps) {
        var dispatcher = resolveDispatcher();
        {
          if (responder == null || responder.$$typeof !== REACT_RESPONDER_TYPE) {
            warning$1(false, 'useResponder: invalid first argument. Expected an event responder, but instead got %s', responder);
            return;
          }
        }
        return dispatcher.useResponder(responder, listenerProps || emptyObject$1);
      }

      function withSuspenseConfig(scope, config) {
        var previousConfig = ReactCurrentBatchConfig.suspense;
        ReactCurrentBatchConfig.suspense = config === undefined ? null : config;

        try {
          scope();
        } finally {
          ReactCurrentBatchConfig.suspense = previousConfig;
        }
      }

      var propTypesMisspellWarningShown = void 0;
      {
        propTypesMisspellWarningShown = false;
      }

      function getDeclarationErrorAddendum() {
        if (ReactCurrentOwner.current) {
          var name = getComponentName(ReactCurrentOwner.current.type);

          if (name) {
            return '\n\nCheck the render method of `' + name + '`.';
          }
        }

        return '';
      }

      function getSourceInfoErrorAddendum(source) {
        if (source !== undefined) {
          var fileName = source.fileName.replace(/^.*[\\\/]/, '');
          var lineNumber = source.lineNumber;
          return '\n\nCheck your code at ' + fileName + ':' + lineNumber + '.';
        }

        return '';
      }

      function getSourceInfoErrorAddendumForProps(elementProps) {
        if (elementProps !== null && elementProps !== undefined) {
          return getSourceInfoErrorAddendum(elementProps.__source);
        }

        return '';
      }

      var ownerHasKeyUseWarning = {};

      function getCurrentComponentErrorInfo(parentType) {
        var info = getDeclarationErrorAddendum();

        if (!info) {
          var parentName = typeof parentType === 'string' ? parentType : parentType.displayName || parentType.name;

          if (parentName) {
            info = '\n\nCheck the top-level render call using <' + parentName + '>.';
          }
        }

        return info;
      }

      function validateExplicitKey(element, parentType) {
        if (!element._store || element._store.validated || element.key != null) {
          return;
        }

        element._store.validated = true;
        var currentComponentErrorInfo = getCurrentComponentErrorInfo(parentType);

        if (ownerHasKeyUseWarning[currentComponentErrorInfo]) {
          return;
        }

        ownerHasKeyUseWarning[currentComponentErrorInfo] = true;
        var childOwner = '';

        if (element && element._owner && element._owner !== ReactCurrentOwner.current) {
          childOwner = ' It was passed a child from ' + getComponentName(element._owner.type) + '.';
        }

        setCurrentlyValidatingElement(element);
        {
          warning$1(false, 'Each child in a list should have a unique "key" prop.' + '%s%s See https://fb.me/react-warning-keys for more information.', currentComponentErrorInfo, childOwner);
        }
        setCurrentlyValidatingElement(null);
      }

      function validateChildKeys(node, parentType) {
        if (typeof node !== 'object') {
          return;
        }

        if (Array.isArray(node)) {
          for (var i = 0; i < node.length; i++) {
            var child = node[i];

            if (isValidElement(child)) {
              validateExplicitKey(child, parentType);
            }
          }
        } else if (isValidElement(node)) {
          if (node._store) {
            node._store.validated = true;
          }
        } else if (node) {
          var iteratorFn = getIteratorFn(node);

          if (typeof iteratorFn === 'function') {
            if (iteratorFn !== node.entries) {
              var iterator = iteratorFn.call(node);
              var step = void 0;

              while (!(step = iterator.next()).done) {
                if (isValidElement(step.value)) {
                  validateExplicitKey(step.value, parentType);
                }
              }
            }
          }
        }
      }

      function validatePropTypes(element) {
        var type = element.type;

        if (type === null || type === undefined || typeof type === 'string') {
          return;
        }

        var name = getComponentName(type);
        var propTypes = void 0;

        if (typeof type === 'function') {
          propTypes = type.propTypes;
        } else if (typeof type === 'object' && (type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_MEMO_TYPE)) {
          propTypes = type.propTypes;
        } else {
          return;
        }

        if (propTypes) {
          setCurrentlyValidatingElement(element);
          checkPropTypes(propTypes, element.props, 'prop', name, ReactDebugCurrentFrame.getStackAddendum);
          setCurrentlyValidatingElement(null);
        } else if (type.PropTypes !== undefined && !propTypesMisspellWarningShown) {
          propTypesMisspellWarningShown = true;
          warningWithoutStack$1(false, 'Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?', name || 'Unknown');
        }

        if (typeof type.getDefaultProps === 'function') {
          !type.getDefaultProps.isReactClassApproved ? warningWithoutStack$1(false, 'getDefaultProps is only used on classic React.createClass ' + 'definitions. Use a static property named `defaultProps` instead.') : void 0;
        }
      }

      function validateFragmentProps(fragment) {
        setCurrentlyValidatingElement(fragment);
        var keys = Object.keys(fragment.props);

        for (var i = 0; i < keys.length; i++) {
          var key = keys[i];

          if (key !== 'children' && key !== 'key') {
            warning$1(false, 'Invalid prop `%s` supplied to `React.Fragment`. ' + 'React.Fragment can only have `key` and `children` props.', key);
            break;
          }
        }

        if (fragment.ref !== null) {
          warning$1(false, 'Invalid attribute `ref` supplied to `React.Fragment`.');
        }

        setCurrentlyValidatingElement(null);
      }

      function jsxWithValidation(type, props, key, isStaticChildren, source, self) {
        var validType = isValidElementType(type);

        if (!validType) {
          var info = '';

          if (type === undefined || typeof type === 'object' && type !== null && Object.keys(type).length === 0) {
            info += ' You likely forgot to export your component from the file ' + "it's defined in, or you might have mixed up default and named imports.";
          }

          var sourceInfo = getSourceInfoErrorAddendum(source);

          if (sourceInfo) {
            info += sourceInfo;
          } else {
            info += getDeclarationErrorAddendum();
          }

          var typeString = void 0;

          if (type === null) {
            typeString = 'null';
          } else if (Array.isArray(type)) {
            typeString = 'array';
          } else if (type !== undefined && type.$$typeof === REACT_ELEMENT_TYPE) {
            typeString = '<' + (getComponentName(type.type) || 'Unknown') + ' />';
            info = ' Did you accidentally export a JSX literal instead of a component?';
          } else {
            typeString = typeof type;
          }

          warning$1(false, 'React.jsx: type is invalid -- expected a string (for ' + 'built-in components) or a class/function (for composite ' + 'components) but got: %s.%s', typeString, info);
        }

        var element = jsxDEV(type, props, key, source, self);

        if (element == null) {
          return element;
        }

        if (validType) {
          var children = props.children;

          if (children !== undefined) {
            if (isStaticChildren) {
              for (var i = 0; i < children.length; i++) {
                validateChildKeys(children[i], type);
              }
            } else {
              validateChildKeys(children, type);
            }
          }
        }

        if (props.key !== undefined) {
          warning$1(false, 'React.jsx: Spreading a key to JSX is a deprecated pattern. ' + 'Explicitly pass a key after spreading props in your JSX call. ' + 'E.g. <ComponentName {...props} key={key} />');
        }

        if (type === REACT_FRAGMENT_TYPE) {
          validateFragmentProps(element);
        } else {
          validatePropTypes(element);
        }

        return element;
      }

      function jsxWithValidationStatic(type, props, key) {
        return jsxWithValidation(type, props, key, true);
      }

      function jsxWithValidationDynamic(type, props, key) {
        return jsxWithValidation(type, props, key, false);
      }

      function createElementWithValidation(type, props, children) {
        var validType = isValidElementType(type);

        if (!validType) {
          var info = '';

          if (type === undefined || typeof type === 'object' && type !== null && Object.keys(type).length === 0) {
            info += ' You likely forgot to export your component from the file ' + "it's defined in, or you might have mixed up default and named imports.";
          }

          var sourceInfo = getSourceInfoErrorAddendumForProps(props);

          if (sourceInfo) {
            info += sourceInfo;
          } else {
            info += getDeclarationErrorAddendum();
          }

          var typeString = void 0;

          if (type === null) {
            typeString = 'null';
          } else if (Array.isArray(type)) {
            typeString = 'array';
          } else if (type !== undefined && type.$$typeof === REACT_ELEMENT_TYPE) {
            typeString = '<' + (getComponentName(type.type) || 'Unknown') + ' />';
            info = ' Did you accidentally export a JSX literal instead of a component?';
          } else {
            typeString = typeof type;
          }

          warning$1(false, 'React.createElement: type is invalid -- expected a string (for ' + 'built-in components) or a class/function (for composite ' + 'components) but got: %s.%s', typeString, info);
        }

        var element = createElement.apply(this, arguments);

        if (element == null) {
          return element;
        }

        if (validType) {
          for (var i = 2; i < arguments.length; i++) {
            validateChildKeys(arguments[i], type);
          }
        }

        if (type === REACT_FRAGMENT_TYPE) {
          validateFragmentProps(element);
        } else {
          validatePropTypes(element);
        }

        return element;
      }

      function createFactoryWithValidation(type) {
        var validatedFactory = createElementWithValidation.bind(null, type);
        validatedFactory.type = type;
        {
          Object.defineProperty(validatedFactory, 'type', {
            enumerable: false,
            get: function get() {
              lowPriorityWarning$1(false, 'Factory.type is deprecated. Access the class directly ' + 'before passing it to createFactory.');
              Object.defineProperty(this, 'type', {
                value: type
              });
              return type;
            }
          });
        }
        return validatedFactory;
      }

      function cloneElementWithValidation(element, props, children) {
        var newElement = cloneElement.apply(this, arguments);

        for (var i = 2; i < arguments.length; i++) {
          validateChildKeys(arguments[i], newElement.type);
        }

        validatePropTypes(newElement);
        return newElement;
      }

      var hasBadMapPolyfill = void 0;
      {
        hasBadMapPolyfill = false;

        try {
          var frozenObject = Object.freeze({});
          var testMap = new Map([[frozenObject, null]]);
          var testSet = new Set([frozenObject]);
          testMap.set(0, 0);
          testSet.add(0);
        } catch (e) {
          hasBadMapPolyfill = true;
        }
      }

      function createFundamentalComponent(impl) {
        if (true && !hasBadMapPolyfill) {
          Object.freeze(impl);
        }

        var fundamantalComponent = {
          $$typeof: REACT_FUNDAMENTAL_TYPE,
          impl: impl
        };
        {
          Object.freeze(fundamantalComponent);
        }
        return fundamantalComponent;
      }

      function createEventResponder(displayName, responderConfig) {
        var getInitialState = responderConfig.getInitialState,
            onEvent = responderConfig.onEvent,
            onMount = responderConfig.onMount,
            onUnmount = responderConfig.onUnmount,
            onOwnershipChange = responderConfig.onOwnershipChange,
            onRootEvent = responderConfig.onRootEvent,
            rootEventTypes = responderConfig.rootEventTypes,
            targetEventTypes = responderConfig.targetEventTypes;
        var eventResponder = {
          $$typeof: REACT_RESPONDER_TYPE,
          displayName: displayName,
          getInitialState: getInitialState || null,
          onEvent: onEvent || null,
          onMount: onMount || null,
          onOwnershipChange: onOwnershipChange || null,
          onRootEvent: onRootEvent || null,
          onUnmount: onUnmount || null,
          rootEventTypes: rootEventTypes || null,
          targetEventTypes: targetEventTypes || null
        };

        if (true && !hasBadMapPolyfill) {
          Object.freeze(eventResponder);
        }

        return eventResponder;
      }

      var enableFlareAPI = false;
      var enableFundamentalAPI = false;
      var enableJSXTransformAPI = false;
      var React = {
        Children: {
          map: mapChildren,
          forEach: forEachChildren,
          count: countChildren,
          toArray: toArray,
          only: onlyChild
        },
        createRef: createRef,
        Component: Component,
        PureComponent: PureComponent,
        createContext: createContext,
        forwardRef: forwardRef,
        lazy: lazy,
        memo: memo,
        useCallback: useCallback,
        useContext: useContext,
        useEffect: useEffect,
        useImperativeHandle: useImperativeHandle,
        useDebugValue: useDebugValue,
        useLayoutEffect: useLayoutEffect,
        useMemo: useMemo,
        useReducer: useReducer,
        useRef: useRef,
        useState: useState,
        Fragment: REACT_FRAGMENT_TYPE,
        Profiler: REACT_PROFILER_TYPE,
        StrictMode: REACT_STRICT_MODE_TYPE,
        Suspense: REACT_SUSPENSE_TYPE,
        unstable_SuspenseList: REACT_SUSPENSE_LIST_TYPE,
        createElement: createElementWithValidation,
        cloneElement: cloneElementWithValidation,
        createFactory: createFactoryWithValidation,
        isValidElement: isValidElement,
        version: ReactVersion,
        unstable_withSuspenseConfig: withSuspenseConfig,
        __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED: ReactSharedInternals
      };

      if (enableFlareAPI) {
        React.unstable_useResponder = useResponder;
        React.unstable_createResponder = createEventResponder;
      }

      if (enableFundamentalAPI) {
        React.unstable_createFundamental = createFundamentalComponent;
      }

      if (enableJSXTransformAPI) {
        {
          React.jsxDEV = jsxWithValidation;
          React.jsx = jsxWithValidationDynamic;
          React.jsxs = jsxWithValidationStatic;
        }
      }

      var React$2 = Object.freeze({
        default: React
      });
      var React$3 = React$2 && React || React$2;
      var react = React$3.default || React$3;
      module.exports = react;
    })();
  }
},57,[56,58],"node_modules/react/cjs/react.development.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var printWarning = function printWarning() {};

  if (process.env.NODE_ENV !== 'production') {
    var ReactPropTypesSecret = _$$_REQUIRE(_dependencyMap[0], "./lib/ReactPropTypesSecret");

    var loggedTypeFailures = {};
    var has = Function.call.bind(Object.prototype.hasOwnProperty);

    printWarning = function printWarning(text) {
      var message = 'Warning: ' + text;

      if (typeof console !== 'undefined') {
        console.error(message);
      }

      try {
        throw new Error(message);
      } catch (x) {}
    };
  }

  function checkPropTypes(typeSpecs, values, location, componentName, getStack) {
    if (process.env.NODE_ENV !== 'production') {
      for (var typeSpecName in typeSpecs) {
        if (has(typeSpecs, typeSpecName)) {
          var error;

          try {
            if (typeof typeSpecs[typeSpecName] !== 'function') {
              var err = Error((componentName || 'React class') + ': ' + location + ' type `' + typeSpecName + '` is invalid; ' + 'it must be a function, usually from the `prop-types` package, but received `' + typeof typeSpecs[typeSpecName] + '`.');
              err.name = 'Invariant Violation';
              throw err;
            }

            error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret);
          } catch (ex) {
            error = ex;
          }

          if (error && !(error instanceof Error)) {
            printWarning((componentName || 'React class') + ': type specification of ' + location + ' `' + typeSpecName + '` is invalid; the type checker ' + 'function must return `null` or an `Error` but returned a ' + typeof error + '. ' + 'You may have forgotten to pass an argument to the type checker ' + 'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' + 'shape all require an argument).');
          }

          if (error instanceof Error && !(error.message in loggedTypeFailures)) {
            loggedTypeFailures[error.message] = true;
            var stack = getStack ? getStack() : '';
            printWarning('Failed ' + location + ' type: ' + error.message + (stack != null ? stack : ''));
          }
        }
      }
    }
  }

  checkPropTypes.resetWarningCache = function () {
    if (process.env.NODE_ENV !== 'production') {
      loggedTypeFailures = {};
    }
  };

  module.exports = checkPropTypes;
},58,[59],"node_modules/prop-types/checkPropTypes.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';
  module.exports = ReactPropTypesSecret;
},59,[],"node_modules/prop-types/lib/ReactPropTypesSecret.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");

  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

  var PixelRatio = _$$_REQUIRE(_dependencyMap[1], "../Utilities/PixelRatio");

  var ReactNativeStyleAttributes = _$$_REQUIRE(_dependencyMap[2], "../Components/View/ReactNativeStyleAttributes");

  var StyleSheetValidation = _$$_REQUIRE(_dependencyMap[3], "./StyleSheetValidation");

  var flatten = _$$_REQUIRE(_dependencyMap[4], "./flattenStyle");

  var hairlineWidth = PixelRatio.roundToNearestPixel(0.4);

  if (hairlineWidth === 0) {
    hairlineWidth = 1 / PixelRatio.get();
  }

  var absoluteFill = {
    position: 'absolute',
    left: 0,
    right: 0,
    top: 0,
    bottom: 0
  };

  if (__DEV__) {
    Object.freeze(absoluteFill);
  }

  module.exports = {
    hairlineWidth: hairlineWidth,
    absoluteFill: absoluteFill,
    absoluteFillObject: absoluteFill,
    compose: function compose(style1, style2) {
      if (style1 != null && style2 != null) {
        return [style1, style2];
      } else {
        return style1 != null ? style1 : style2;
      }
    },
    flatten: flatten,
    setStyleAttributePreprocessor: function setStyleAttributePreprocessor(property, process) {
      var value;

      if (ReactNativeStyleAttributes[property] === true) {
        value = {};
      } else if (typeof ReactNativeStyleAttributes[property] === 'object') {
        value = ReactNativeStyleAttributes[property];
      } else {
        console.error(property + " is not a valid style attribute");
        return;
      }

      if (__DEV__ && typeof value.process === 'function') {
        console.warn("Overwriting " + property + " style attribute preprocessor");
      }

      ReactNativeStyleAttributes[property] = _objectSpread({}, value, {
        process: process
      });
    },
    create: function create(obj) {
      if (__DEV__) {
        for (var _key in obj) {
          StyleSheetValidation.validateStyle(_key, obj);

          if (obj[_key]) {
            Object.freeze(obj[_key]);
          }
        }
      }

      return obj;
    }
  };
},60,[46,61,64,84,85],"node_modules/react-native/Libraries/StyleSheet/StyleSheet.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");

  var Dimensions = _$$_REQUIRE(_dependencyMap[2], "./Dimensions");

  var PixelRatio = function () {
    function PixelRatio() {
      _classCallCheck(this, PixelRatio);
    }

    _createClass(PixelRatio, null, [{
      key: "get",
      value: function get() {
        return Dimensions.get('window').scale;
      }
    }, {
      key: "getFontScale",
      value: function getFontScale() {
        return Dimensions.get('window').fontScale || PixelRatio.get();
      }
    }, {
      key: "getPixelSizeForLayoutSize",
      value: function getPixelSizeForLayoutSize(layoutSize) {
        return Math.round(layoutSize * PixelRatio.get());
      }
    }, {
      key: "roundToNearestPixel",
      value: function roundToNearestPixel(layoutSize) {
        var ratio = PixelRatio.get();
        return Math.round(layoutSize * ratio) / ratio;
      }
    }, {
      key: "startDetecting",
      value: function startDetecting() {}
    }]);

    return PixelRatio;
  }();

  module.exports = PixelRatio;
},61,[24,25,62],"node_modules/react-native/Libraries/Utilities/PixelRatio.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));

  var _EventEmitter = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../vendor/emitter/EventEmitter"));

  var _RCTDeviceEventEmitter = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "../EventEmitter/RCTDeviceEventEmitter"));

  var _NativeDeviceInfo = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "./NativeDeviceInfo"));

  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "invariant"));

  var eventEmitter = new _EventEmitter.default();
  var dimensionsInitialized = false;
  var dimensions;

  var Dimensions = function () {
    function Dimensions() {
      (0, _classCallCheck2.default)(this, Dimensions);
    }

    (0, _createClass2.default)(Dimensions, null, [{
      key: "get",
      value: function get(dim) {
        (0, _invariant.default)(dimensions[dim], 'No dimension set for key ' + dim);
        return dimensions[dim];
      }
    }, {
      key: "set",
      value: function set(dims) {
        var screen = dims.screen,
            window = dims.window;
        var windowPhysicalPixels = dims.windowPhysicalPixels;

        if (windowPhysicalPixels) {
          window = {
            width: windowPhysicalPixels.width / windowPhysicalPixels.scale,
            height: windowPhysicalPixels.height / windowPhysicalPixels.scale,
            scale: windowPhysicalPixels.scale,
            fontScale: windowPhysicalPixels.fontScale
          };
        }

        var screenPhysicalPixels = dims.screenPhysicalPixels;

        if (screenPhysicalPixels) {
          screen = {
            width: screenPhysicalPixels.width / screenPhysicalPixels.scale,
            height: screenPhysicalPixels.height / screenPhysicalPixels.scale,
            scale: screenPhysicalPixels.scale,
            fontScale: screenPhysicalPixels.fontScale
          };
        } else if (screen == null) {
          screen = window;
        }

        dimensions = {
          window: window,
          screen: screen
        };

        if (dimensionsInitialized) {
          eventEmitter.emit('change', dimensions);
        } else {
          dimensionsInitialized = true;
        }
      }
    }, {
      key: "addEventListener",
      value: function addEventListener(type, handler) {
        (0, _invariant.default)(type === 'change', 'Trying to subscribe to unknown event: "%s"', type);
        eventEmitter.addListener(type, handler);
      }
    }, {
      key: "removeEventListener",
      value: function removeEventListener(type, handler) {
        (0, _invariant.default)(type === 'change', 'Trying to remove listener for unknown event: "%s"', type);
        eventEmitter.removeListener(type, handler);
      }
    }]);
    return Dimensions;
  }();

  var initialDims = global.nativeExtensions && global.nativeExtensions.DeviceInfo && global.nativeExtensions.DeviceInfo.Dimensions;

  if (!initialDims) {
    _RCTDeviceEventEmitter.default.addListener('didUpdateDimensions', function (update) {
      Dimensions.set(update);
    });

    initialDims = _NativeDeviceInfo.default.getConstants().Dimensions;
  }

  Dimensions.set(initialDims);
  module.exports = Dimensions;
},62,[1,24,25,39,31,63,3],"node_modules/react-native/Libraries/Utilities/Dimensions.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireWildcard");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[1], "../TurboModule/TurboModuleRegistry"));

  var NativeModule = TurboModuleRegistry.getEnforcing('DeviceInfo');
  var NativeDeviceInfo = NativeModule;
  var _default = NativeDeviceInfo;
  exports.default = _default;
},63,[9,11],"node_modules/react-native/Libraries/Utilities/NativeDeviceInfo.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");

  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

  var DeprecatedImageStylePropTypes = _$$_REQUIRE(_dependencyMap[1], "../../DeprecatedPropTypes/DeprecatedImageStylePropTypes");

  var DeprecatedTextStylePropTypes = _$$_REQUIRE(_dependencyMap[2], "../../DeprecatedPropTypes/DeprecatedTextStylePropTypes");

  var DeprecatedViewStylePropTypes = _$$_REQUIRE(_dependencyMap[3], "../../DeprecatedPropTypes/DeprecatedViewStylePropTypes");

  var processColor = _$$_REQUIRE(_dependencyMap[4], "../../StyleSheet/processColor");

  var processTransform = _$$_REQUIRE(_dependencyMap[5], "../../StyleSheet/processTransform");

  var sizesDiffer = _$$_REQUIRE(_dependencyMap[6], "../../Utilities/differ/sizesDiffer");

  var ReactNativeStyleAttributes = {};

  for (var _i = 0, _Object$keys = Object.keys(_objectSpread({}, DeprecatedViewStylePropTypes, {}, DeprecatedTextStylePropTypes, {}, DeprecatedImageStylePropTypes)); _i < _Object$keys.length; _i++) {
    var attributeName = _Object$keys[_i];
    ReactNativeStyleAttributes[attributeName] = true;
  }

  ReactNativeStyleAttributes.transform = {
    process: processTransform
  };
  ReactNativeStyleAttributes.shadowOffset = {
    diff: sizesDiffer
  };
  var colorAttributes = {
    process: processColor
  };
  ReactNativeStyleAttributes.backgroundColor = colorAttributes;
  ReactNativeStyleAttributes.borderBottomColor = colorAttributes;
  ReactNativeStyleAttributes.borderColor = colorAttributes;
  ReactNativeStyleAttributes.borderLeftColor = colorAttributes;
  ReactNativeStyleAttributes.borderRightColor = colorAttributes;
  ReactNativeStyleAttributes.borderTopColor = colorAttributes;
  ReactNativeStyleAttributes.borderStartColor = colorAttributes;
  ReactNativeStyleAttributes.borderEndColor = colorAttributes;
  ReactNativeStyleAttributes.color = colorAttributes;
  ReactNativeStyleAttributes.shadowColor = colorAttributes;
  ReactNativeStyleAttributes.textDecorationColor = colorAttributes;
  ReactNativeStyleAttributes.tintColor = colorAttributes;
  ReactNativeStyleAttributes.textShadowColor = colorAttributes;
  ReactNativeStyleAttributes.overlayColor = colorAttributes;
  module.exports = ReactNativeStyleAttributes;
},64,[46,65,78,79,80,81,83],"node_modules/react-native/Libraries/Components/View/ReactNativeStyleAttributes.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");

  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

  var DeprecatedColorPropType = _$$_REQUIRE(_dependencyMap[1], "./DeprecatedColorPropType");

  var DeprecatedLayoutPropTypes = _$$_REQUIRE(_dependencyMap[2], "./DeprecatedLayoutPropTypes");

  var DeprecatedShadowPropTypesIOS = _$$_REQUIRE(_dependencyMap[3], "./DeprecatedShadowPropTypesIOS");

  var DeprecatedTransformPropTypes = _$$_REQUIRE(_dependencyMap[4], "./DeprecatedTransformPropTypes");

  var ReactPropTypes = _$$_REQUIRE(_dependencyMap[5], "prop-types");

  var ImageStylePropTypes = _objectSpread({}, DeprecatedLayoutPropTypes, {}, DeprecatedShadowPropTypesIOS, {}, DeprecatedTransformPropTypes, {
    resizeMode: ReactPropTypes.oneOf(['center', 'contain', 'cover', 'repeat', 'stretch']),
    backfaceVisibility: ReactPropTypes.oneOf(['visible', 'hidden']),
    backgroundColor: DeprecatedColorPropType,
    borderColor: DeprecatedColorPropType,
    borderWidth: ReactPropTypes.number,
    borderRadius: ReactPropTypes.number,
    overflow: ReactPropTypes.oneOf(['visible', 'hidden']),
    tintColor: DeprecatedColorPropType,
    opacity: ReactPropTypes.number,
    overlayColor: ReactPropTypes.string,
    borderTopLeftRadius: ReactPropTypes.number,
    borderTopRightRadius: ReactPropTypes.number,
    borderBottomLeftRadius: ReactPropTypes.number,
    borderBottomRightRadius: ReactPropTypes.number
  });

  module.exports = ImageStylePropTypes;
},65,[46,66,68,75,76,69],"node_modules/react-native/Libraries/DeprecatedPropTypes/DeprecatedImageStylePropTypes.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var normalizeColor = _$$_REQUIRE(_dependencyMap[0], "../Color/normalizeColor");

  var colorPropType = function colorPropType(isRequired, props, propName, componentName, location, propFullName) {
    var color = props[propName];

    if (color === undefined || color === null) {
      if (isRequired) {
        return new Error('Required ' + location + ' `' + (propFullName || propName) + '` was not specified in `' + componentName + '`.');
      }

      return;
    }

    if (typeof color === 'number') {
      return;
    }

    if (normalizeColor(color) === null) {
      return new Error('Invalid ' + location + ' `' + (propFullName || propName) + '` supplied to `' + componentName + '`: ' + color + '\n' + "Valid color formats are\n  - '#f0f' (#rgb)\n  - '#f0fc' (#rgba)\n  - '#ff00ff' (#rrggbb)\n  - '#ff00ff00' (#rrggbbaa)\n  - 'rgb(255, 255, 255)'\n  - 'rgba(255, 255, 255, 1.0)'\n  - 'hsl(360, 100%, 100%)'\n  - 'hsla(360, 100%, 100%, 1.0)'\n  - 'transparent'\n  - 'red'\n  - 0xff00ff00 (0xrrggbbaa)\n");
    }
  };

  var ColorPropType = colorPropType.bind(null, false);
  ColorPropType.isRequired = colorPropType.bind(null, true);
  module.exports = ColorPropType;
},66,[67],"node_modules/react-native/Libraries/DeprecatedPropTypes/DeprecatedColorPropType.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  function normalizeColor(color) {
    var matchers = getMatchers();
    var match;

    if (typeof color === 'number') {
      if (color >>> 0 === color && color >= 0 && color <= 0xffffffff) {
        return color;
      }

      return null;
    }

    if (match = matchers.hex6.exec(color)) {
      return parseInt(match[1] + 'ff', 16) >>> 0;
    }

    if (names.hasOwnProperty(color)) {
      return names[color];
    }

    if (match = matchers.rgb.exec(color)) {
      return (parse255(match[1]) << 24 | parse255(match[2]) << 16 | parse255(match[3]) << 8 | 0x000000ff) >>> 0;
    }

    if (match = matchers.rgba.exec(color)) {
      return (parse255(match[1]) << 24 | parse255(match[2]) << 16 | parse255(match[3]) << 8 | parse1(match[4])) >>> 0;
    }

    if (match = matchers.hex3.exec(color)) {
      return parseInt(match[1] + match[1] + match[2] + match[2] + match[3] + match[3] + 'ff', 16) >>> 0;
    }

    if (match = matchers.hex8.exec(color)) {
      return parseInt(match[1], 16) >>> 0;
    }

    if (match = matchers.hex4.exec(color)) {
      return parseInt(match[1] + match[1] + match[2] + match[2] + match[3] + match[3] + match[4] + match[4], 16) >>> 0;
    }

    if (match = matchers.hsl.exec(color)) {
      return (hslToRgb(parse360(match[1]), parsePercentage(match[2]), parsePercentage(match[3])) | 0x000000ff) >>> 0;
    }

    if (match = matchers.hsla.exec(color)) {
      return (hslToRgb(parse360(match[1]), parsePercentage(match[2]), parsePercentage(match[3])) | parse1(match[4])) >>> 0;
    }

    return null;
  }

  function hue2rgb(p, q, t) {
    if (t < 0) {
      t += 1;
    }

    if (t > 1) {
      t -= 1;
    }

    if (t < 1 / 6) {
      return p + (q - p) * 6 * t;
    }

    if (t < 1 / 2) {
      return q;
    }

    if (t < 2 / 3) {
      return p + (q - p) * (2 / 3 - t) * 6;
    }

    return p;
  }

  function hslToRgb(h, s, l) {
    var q = l < 0.5 ? l * (1 + s) : l + s - l * s;
    var p = 2 * l - q;
    var r = hue2rgb(p, q, h + 1 / 3);
    var g = hue2rgb(p, q, h);
    var b = hue2rgb(p, q, h - 1 / 3);
    return Math.round(r * 255) << 24 | Math.round(g * 255) << 16 | Math.round(b * 255) << 8;
  }

  var NUMBER = '[-+]?\\d*\\.?\\d+';
  var PERCENTAGE = NUMBER + '%';

  function call() {
    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
      args[_key] = arguments[_key];
    }

    return '\\(\\s*(' + args.join(')\\s*,\\s*(') + ')\\s*\\)';
  }

  var cachedMatchers;

  function getMatchers() {
    if (cachedMatchers === undefined) {
      cachedMatchers = {
        rgb: new RegExp('rgb' + call(NUMBER, NUMBER, NUMBER)),
        rgba: new RegExp('rgba' + call(NUMBER, NUMBER, NUMBER, NUMBER)),
        hsl: new RegExp('hsl' + call(NUMBER, PERCENTAGE, PERCENTAGE)),
        hsla: new RegExp('hsla' + call(NUMBER, PERCENTAGE, PERCENTAGE, NUMBER)),
        hex3: /^#([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,
        hex4: /^#([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,
        hex6: /^#([0-9a-fA-F]{6})$/,
        hex8: /^#([0-9a-fA-F]{8})$/
      };
    }

    return cachedMatchers;
  }

  function parse255(str) {
    var int = parseInt(str, 10);

    if (int < 0) {
      return 0;
    }

    if (int > 255) {
      return 255;
    }

    return int;
  }

  function parse360(str) {
    var int = parseFloat(str);
    return (int % 360 + 360) % 360 / 360;
  }

  function parse1(str) {
    var num = parseFloat(str);

    if (num < 0) {
      return 0;
    }

    if (num > 1) {
      return 255;
    }

    return Math.round(num * 255);
  }

  function parsePercentage(str) {
    var int = parseFloat(str);

    if (int < 0) {
      return 0;
    }

    if (int > 100) {
      return 1;
    }

    return int / 100;
  }

  var names = {
    transparent: 0x00000000,
    aliceblue: 0xf0f8ffff,
    antiquewhite: 0xfaebd7ff,
    aqua: 0x00ffffff,
    aquamarine: 0x7fffd4ff,
    azure: 0xf0ffffff,
    beige: 0xf5f5dcff,
    bisque: 0xffe4c4ff,
    black: 0x000000ff,
    blanchedalmond: 0xffebcdff,
    blue: 0x0000ffff,
    blueviolet: 0x8a2be2ff,
    brown: 0xa52a2aff,
    burlywood: 0xdeb887ff,
    burntsienna: 0xea7e5dff,
    cadetblue: 0x5f9ea0ff,
    chartreuse: 0x7fff00ff,
    chocolate: 0xd2691eff,
    coral: 0xff7f50ff,
    cornflowerblue: 0x6495edff,
    cornsilk: 0xfff8dcff,
    crimson: 0xdc143cff,
    cyan: 0x00ffffff,
    darkblue: 0x00008bff,
    darkcyan: 0x008b8bff,
    darkgoldenrod: 0xb8860bff,
    darkgray: 0xa9a9a9ff,
    darkgreen: 0x006400ff,
    darkgrey: 0xa9a9a9ff,
    darkkhaki: 0xbdb76bff,
    darkmagenta: 0x8b008bff,
    darkolivegreen: 0x556b2fff,
    darkorange: 0xff8c00ff,
    darkorchid: 0x9932ccff,
    darkred: 0x8b0000ff,
    darksalmon: 0xe9967aff,
    darkseagreen: 0x8fbc8fff,
    darkslateblue: 0x483d8bff,
    darkslategray: 0x2f4f4fff,
    darkslategrey: 0x2f4f4fff,
    darkturquoise: 0x00ced1ff,
    darkviolet: 0x9400d3ff,
    deeppink: 0xff1493ff,
    deepskyblue: 0x00bfffff,
    dimgray: 0x696969ff,
    dimgrey: 0x696969ff,
    dodgerblue: 0x1e90ffff,
    firebrick: 0xb22222ff,
    floralwhite: 0xfffaf0ff,
    forestgreen: 0x228b22ff,
    fuchsia: 0xff00ffff,
    gainsboro: 0xdcdcdcff,
    ghostwhite: 0xf8f8ffff,
    gold: 0xffd700ff,
    goldenrod: 0xdaa520ff,
    gray: 0x808080ff,
    green: 0x008000ff,
    greenyellow: 0xadff2fff,
    grey: 0x808080ff,
    honeydew: 0xf0fff0ff,
    hotpink: 0xff69b4ff,
    indianred: 0xcd5c5cff,
    indigo: 0x4b0082ff,
    ivory: 0xfffff0ff,
    khaki: 0xf0e68cff,
    lavender: 0xe6e6faff,
    lavenderblush: 0xfff0f5ff,
    lawngreen: 0x7cfc00ff,
    lemonchiffon: 0xfffacdff,
    lightblue: 0xadd8e6ff,
    lightcoral: 0xf08080ff,
    lightcyan: 0xe0ffffff,
    lightgoldenrodyellow: 0xfafad2ff,
    lightgray: 0xd3d3d3ff,
    lightgreen: 0x90ee90ff,
    lightgrey: 0xd3d3d3ff,
    lightpink: 0xffb6c1ff,
    lightsalmon: 0xffa07aff,
    lightseagreen: 0x20b2aaff,
    lightskyblue: 0x87cefaff,
    lightslategray: 0x778899ff,
    lightslategrey: 0x778899ff,
    lightsteelblue: 0xb0c4deff,
    lightyellow: 0xffffe0ff,
    lime: 0x00ff00ff,
    limegreen: 0x32cd32ff,
    linen: 0xfaf0e6ff,
    magenta: 0xff00ffff,
    maroon: 0x800000ff,
    mediumaquamarine: 0x66cdaaff,
    mediumblue: 0x0000cdff,
    mediumorchid: 0xba55d3ff,
    mediumpurple: 0x9370dbff,
    mediumseagreen: 0x3cb371ff,
    mediumslateblue: 0x7b68eeff,
    mediumspringgreen: 0x00fa9aff,
    mediumturquoise: 0x48d1ccff,
    mediumvioletred: 0xc71585ff,
    midnightblue: 0x191970ff,
    mintcream: 0xf5fffaff,
    mistyrose: 0xffe4e1ff,
    moccasin: 0xffe4b5ff,
    navajowhite: 0xffdeadff,
    navy: 0x000080ff,
    oldlace: 0xfdf5e6ff,
    olive: 0x808000ff,
    olivedrab: 0x6b8e23ff,
    orange: 0xffa500ff,
    orangered: 0xff4500ff,
    orchid: 0xda70d6ff,
    palegoldenrod: 0xeee8aaff,
    palegreen: 0x98fb98ff,
    paleturquoise: 0xafeeeeff,
    palevioletred: 0xdb7093ff,
    papayawhip: 0xffefd5ff,
    peachpuff: 0xffdab9ff,
    peru: 0xcd853fff,
    pink: 0xffc0cbff,
    plum: 0xdda0ddff,
    powderblue: 0xb0e0e6ff,
    purple: 0x800080ff,
    rebeccapurple: 0x663399ff,
    red: 0xff0000ff,
    rosybrown: 0xbc8f8fff,
    royalblue: 0x4169e1ff,
    saddlebrown: 0x8b4513ff,
    salmon: 0xfa8072ff,
    sandybrown: 0xf4a460ff,
    seagreen: 0x2e8b57ff,
    seashell: 0xfff5eeff,
    sienna: 0xa0522dff,
    silver: 0xc0c0c0ff,
    skyblue: 0x87ceebff,
    slateblue: 0x6a5acdff,
    slategray: 0x708090ff,
    slategrey: 0x708090ff,
    snow: 0xfffafaff,
    springgreen: 0x00ff7fff,
    steelblue: 0x4682b4ff,
    tan: 0xd2b48cff,
    teal: 0x008080ff,
    thistle: 0xd8bfd8ff,
    tomato: 0xff6347ff,
    turquoise: 0x40e0d0ff,
    violet: 0xee82eeff,
    wheat: 0xf5deb3ff,
    white: 0xffffffff,
    whitesmoke: 0xf5f5f5ff,
    yellow: 0xffff00ff,
    yellowgreen: 0x9acd32ff
  };
  module.exports = normalizeColor;
},67,[],"node_modules/react-native/Libraries/Color/normalizeColor.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var ReactPropTypes = _$$_REQUIRE(_dependencyMap[0], "prop-types");

  var LayoutPropTypes = {
    display: ReactPropTypes.oneOf(['none', 'flex']),
    width: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
    height: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
    start: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
    end: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
    top: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
    left: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
    right: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
    bottom: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
    minWidth: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
    maxWidth: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
    minHeight: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
    maxHeight: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
    margin: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
    marginVertical: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
    marginHorizontal: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
    marginTop: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
    marginBottom: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
    marginLeft: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
    marginRight: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
    marginStart: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
    marginEnd: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
    padding: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
    paddingVertical: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
    paddingHorizontal: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
    paddingTop: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
    paddingBottom: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
    paddingLeft: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
    paddingRight: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
    paddingStart: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
    paddingEnd: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
    borderWidth: ReactPropTypes.number,
    borderTopWidth: ReactPropTypes.number,
    borderStartWidth: ReactPropTypes.number,
    borderEndWidth: ReactPropTypes.number,
    borderRightWidth: ReactPropTypes.number,
    borderBottomWidth: ReactPropTypes.number,
    borderLeftWidth: ReactPropTypes.number,
    position: ReactPropTypes.oneOf(['absolute', 'relative']),
    flexDirection: ReactPropTypes.oneOf(['row', 'row-reverse', 'column', 'column-reverse']),
    flexWrap: ReactPropTypes.oneOf(['wrap', 'nowrap', 'wrap-reverse']),
    justifyContent: ReactPropTypes.oneOf(['flex-start', 'flex-end', 'center', 'space-between', 'space-around', 'space-evenly']),
    alignItems: ReactPropTypes.oneOf(['flex-start', 'flex-end', 'center', 'stretch', 'baseline']),
    alignSelf: ReactPropTypes.oneOf(['auto', 'flex-start', 'flex-end', 'center', 'stretch', 'baseline']),
    alignContent: ReactPropTypes.oneOf(['flex-start', 'flex-end', 'center', 'stretch', 'space-between', 'space-around']),
    overflow: ReactPropTypes.oneOf(['visible', 'hidden', 'scroll']),
    flex: ReactPropTypes.number,
    flexGrow: ReactPropTypes.number,
    flexShrink: ReactPropTypes.number,
    flexBasis: ReactPropTypes.oneOfType([ReactPropTypes.number, ReactPropTypes.string]),
    aspectRatio: ReactPropTypes.number,
    zIndex: ReactPropTypes.number,
    direction: ReactPropTypes.oneOf(['inherit', 'ltr', 'rtl'])
  };
  module.exports = LayoutPropTypes;
},68,[69],"node_modules/react-native/Libraries/DeprecatedPropTypes/DeprecatedLayoutPropTypes.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  if (process.env.NODE_ENV !== 'production') {
    var ReactIs = _$$_REQUIRE(_dependencyMap[0], "react-is");

    var throwOnDirectAccess = true;
    module.exports = _$$_REQUIRE(_dependencyMap[1], "./factoryWithTypeCheckers")(ReactIs.isElement, throwOnDirectAccess);
  } else {
    module.exports = _$$_REQUIRE(_dependencyMap[2], "./factoryWithThrowingShims")();
  }
},69,[70,73,74],"node_modules/prop-types/index.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  if (process.env.NODE_ENV === 'production') {
    module.exports = _$$_REQUIRE(_dependencyMap[0], "./cjs/react-is.production.min.js");
  } else {
    module.exports = _$$_REQUIRE(_dependencyMap[1], "./cjs/react-is.development.js");
  }
},70,[71,72],"node_modules/react-is/index.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  /** @license React v16.12.0
   * react-is.production.min.js
   *
   * 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.
   */
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: !0
  });
  var b = "function" === typeof Symbol && (typeof Symbol === "function" ? Symbol.for : "@@for"),
      c = b ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.element") : 60103,
      d = b ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.portal") : 60106,
      e = b ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.fragment") : 60107,
      f = b ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.strict_mode") : 60108,
      g = b ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.profiler") : 60114,
      h = b ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.provider") : 60109,
      k = b ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.context") : 60110,
      l = b ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.async_mode") : 60111,
      m = b ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.concurrent_mode") : 60111,
      n = b ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.forward_ref") : 60112,
      p = b ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.suspense") : 60113,
      q = b ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.suspense_list") : 60120,
      r = b ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.memo") : 60115,
      t = b ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.lazy") : 60116,
      v = b ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.fundamental") : 60117,
      w = b ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.responder") : 60118,
      x = b ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.scope") : 60119;

  function y(a) {
    if ("object" === typeof a && null !== a) {
      var u = a.$$typeof;

      switch (u) {
        case c:
          switch (a = a.type, a) {
            case l:
            case m:
            case e:
            case g:
            case f:
            case p:
              return a;

            default:
              switch (a = a && a.$$typeof, a) {
                case k:
                case n:
                case t:
                case r:
                case h:
                  return a;

                default:
                  return u;
              }

          }

        case d:
          return u;
      }
    }
  }

  function z(a) {
    return y(a) === m;
  }

  exports.typeOf = y;
  exports.AsyncMode = l;
  exports.ConcurrentMode = m;
  exports.ContextConsumer = k;
  exports.ContextProvider = h;
  exports.Element = c;
  exports.ForwardRef = n;
  exports.Fragment = e;
  exports.Lazy = t;
  exports.Memo = r;
  exports.Portal = d;
  exports.Profiler = g;
  exports.StrictMode = f;
  exports.Suspense = p;

  exports.isValidElementType = function (a) {
    return "string" === typeof a || "function" === typeof a || a === e || a === m || a === g || a === f || a === p || a === q || "object" === typeof a && null !== a && (a.$$typeof === t || a.$$typeof === r || a.$$typeof === h || a.$$typeof === k || a.$$typeof === n || a.$$typeof === v || a.$$typeof === w || a.$$typeof === x);
  };

  exports.isAsyncMode = function (a) {
    return z(a) || y(a) === l;
  };

  exports.isConcurrentMode = z;

  exports.isContextConsumer = function (a) {
    return y(a) === k;
  };

  exports.isContextProvider = function (a) {
    return y(a) === h;
  };

  exports.isElement = function (a) {
    return "object" === typeof a && null !== a && a.$$typeof === c;
  };

  exports.isForwardRef = function (a) {
    return y(a) === n;
  };

  exports.isFragment = function (a) {
    return y(a) === e;
  };

  exports.isLazy = function (a) {
    return y(a) === t;
  };

  exports.isMemo = function (a) {
    return y(a) === r;
  };

  exports.isPortal = function (a) {
    return y(a) === d;
  };

  exports.isProfiler = function (a) {
    return y(a) === g;
  };

  exports.isStrictMode = function (a) {
    return y(a) === f;
  };

  exports.isSuspense = function (a) {
    return y(a) === p;
  };
},71,[],"node_modules/react-is/cjs/react-is.production.min.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  /** @license React v16.12.0
   * react-is.development.js
   *
   * 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.
   */
  'use strict';

  if (process.env.NODE_ENV !== "production") {
    (function () {
      'use strict';

      Object.defineProperty(exports, '__esModule', {
        value: true
      });
      var hasSymbol = typeof Symbol === 'function' && (typeof Symbol === "function" ? Symbol.for : "@@for");
      var REACT_ELEMENT_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.element') : 0xeac7;
      var REACT_PORTAL_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.portal') : 0xeaca;
      var REACT_FRAGMENT_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.fragment') : 0xeacb;
      var REACT_STRICT_MODE_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.strict_mode') : 0xeacc;
      var REACT_PROFILER_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.profiler') : 0xead2;
      var REACT_PROVIDER_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.provider') : 0xeacd;
      var REACT_CONTEXT_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.context') : 0xeace;
      var REACT_ASYNC_MODE_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.async_mode') : 0xeacf;
      var REACT_CONCURRENT_MODE_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.concurrent_mode') : 0xeacf;
      var REACT_FORWARD_REF_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.forward_ref') : 0xead0;
      var REACT_SUSPENSE_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.suspense') : 0xead1;
      var REACT_SUSPENSE_LIST_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.suspense_list') : 0xead8;
      var REACT_MEMO_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.memo') : 0xead3;
      var REACT_LAZY_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.lazy') : 0xead4;
      var REACT_FUNDAMENTAL_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.fundamental') : 0xead5;
      var REACT_RESPONDER_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.responder') : 0xead6;
      var REACT_SCOPE_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.scope') : 0xead7;

      function isValidElementType(type) {
        return typeof type === 'string' || typeof type === 'function' || type === REACT_FRAGMENT_TYPE || type === REACT_CONCURRENT_MODE_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || typeof type === 'object' && type !== null && (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_FUNDAMENTAL_TYPE || type.$$typeof === REACT_RESPONDER_TYPE || type.$$typeof === REACT_SCOPE_TYPE);
      }

      var lowPriorityWarningWithoutStack = function lowPriorityWarningWithoutStack() {};

      {
        var printWarning = function printWarning(format) {
          for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
            args[_key - 1] = arguments[_key];
          }

          var argIndex = 0;
          var message = 'Warning: ' + format.replace(/%s/g, function () {
            return args[argIndex++];
          });

          if (typeof console !== 'undefined') {
            console.warn(message);
          }

          try {
            throw new Error(message);
          } catch (x) {}
        };

        lowPriorityWarningWithoutStack = function lowPriorityWarningWithoutStack(condition, format) {
          if (format === undefined) {
            throw new Error('`lowPriorityWarningWithoutStack(condition, format, ...args)` requires a warning ' + 'message argument');
          }

          if (!condition) {
            for (var _len2 = arguments.length, args = new Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
              args[_key2 - 2] = arguments[_key2];
            }

            printWarning.apply(void 0, [format].concat(args));
          }
        };
      }
      var lowPriorityWarningWithoutStack$1 = lowPriorityWarningWithoutStack;

      function typeOf(object) {
        if (typeof object === 'object' && object !== null) {
          var $$typeof = object.$$typeof;

          switch ($$typeof) {
            case REACT_ELEMENT_TYPE:
              var type = object.type;

              switch (type) {
                case REACT_ASYNC_MODE_TYPE:
                case REACT_CONCURRENT_MODE_TYPE:
                case REACT_FRAGMENT_TYPE:
                case REACT_PROFILER_TYPE:
                case REACT_STRICT_MODE_TYPE:
                case REACT_SUSPENSE_TYPE:
                  return type;

                default:
                  var $$typeofType = type && type.$$typeof;

                  switch ($$typeofType) {
                    case REACT_CONTEXT_TYPE:
                    case REACT_FORWARD_REF_TYPE:
                    case REACT_LAZY_TYPE:
                    case REACT_MEMO_TYPE:
                    case REACT_PROVIDER_TYPE:
                      return $$typeofType;

                    default:
                      return $$typeof;
                  }

              }

            case REACT_PORTAL_TYPE:
              return $$typeof;
          }
        }

        return undefined;
      }

      var AsyncMode = REACT_ASYNC_MODE_TYPE;
      var ConcurrentMode = REACT_CONCURRENT_MODE_TYPE;
      var ContextConsumer = REACT_CONTEXT_TYPE;
      var ContextProvider = REACT_PROVIDER_TYPE;
      var Element = REACT_ELEMENT_TYPE;
      var ForwardRef = REACT_FORWARD_REF_TYPE;
      var Fragment = REACT_FRAGMENT_TYPE;
      var Lazy = REACT_LAZY_TYPE;
      var Memo = REACT_MEMO_TYPE;
      var Portal = REACT_PORTAL_TYPE;
      var Profiler = REACT_PROFILER_TYPE;
      var StrictMode = REACT_STRICT_MODE_TYPE;
      var Suspense = REACT_SUSPENSE_TYPE;
      var hasWarnedAboutDeprecatedIsAsyncMode = false;

      function isAsyncMode(object) {
        {
          if (!hasWarnedAboutDeprecatedIsAsyncMode) {
            hasWarnedAboutDeprecatedIsAsyncMode = true;
            lowPriorityWarningWithoutStack$1(false, 'The ReactIs.isAsyncMode() alias has been deprecated, ' + 'and will be removed in React 17+. Update your code to use ' + 'ReactIs.isConcurrentMode() instead. It has the exact same API.');
          }
        }
        return isConcurrentMode(object) || typeOf(object) === REACT_ASYNC_MODE_TYPE;
      }

      function isConcurrentMode(object) {
        return typeOf(object) === REACT_CONCURRENT_MODE_TYPE;
      }

      function isContextConsumer(object) {
        return typeOf(object) === REACT_CONTEXT_TYPE;
      }

      function isContextProvider(object) {
        return typeOf(object) === REACT_PROVIDER_TYPE;
      }

      function isElement(object) {
        return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
      }

      function isForwardRef(object) {
        return typeOf(object) === REACT_FORWARD_REF_TYPE;
      }

      function isFragment(object) {
        return typeOf(object) === REACT_FRAGMENT_TYPE;
      }

      function isLazy(object) {
        return typeOf(object) === REACT_LAZY_TYPE;
      }

      function isMemo(object) {
        return typeOf(object) === REACT_MEMO_TYPE;
      }

      function isPortal(object) {
        return typeOf(object) === REACT_PORTAL_TYPE;
      }

      function isProfiler(object) {
        return typeOf(object) === REACT_PROFILER_TYPE;
      }

      function isStrictMode(object) {
        return typeOf(object) === REACT_STRICT_MODE_TYPE;
      }

      function isSuspense(object) {
        return typeOf(object) === REACT_SUSPENSE_TYPE;
      }

      exports.typeOf = typeOf;
      exports.AsyncMode = AsyncMode;
      exports.ConcurrentMode = ConcurrentMode;
      exports.ContextConsumer = ContextConsumer;
      exports.ContextProvider = ContextProvider;
      exports.Element = Element;
      exports.ForwardRef = ForwardRef;
      exports.Fragment = Fragment;
      exports.Lazy = Lazy;
      exports.Memo = Memo;
      exports.Portal = Portal;
      exports.Profiler = Profiler;
      exports.StrictMode = StrictMode;
      exports.Suspense = Suspense;
      exports.isValidElementType = isValidElementType;
      exports.isAsyncMode = isAsyncMode;
      exports.isConcurrentMode = isConcurrentMode;
      exports.isContextConsumer = isContextConsumer;
      exports.isContextProvider = isContextProvider;
      exports.isElement = isElement;
      exports.isForwardRef = isForwardRef;
      exports.isFragment = isFragment;
      exports.isLazy = isLazy;
      exports.isMemo = isMemo;
      exports.isPortal = isPortal;
      exports.isProfiler = isProfiler;
      exports.isStrictMode = isStrictMode;
      exports.isSuspense = isSuspense;
    })();
  }
},72,[],"node_modules/react-is/cjs/react-is.development.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var ReactIs = _$$_REQUIRE(_dependencyMap[0], "react-is");

  var assign = _$$_REQUIRE(_dependencyMap[1], "object-assign");

  var ReactPropTypesSecret = _$$_REQUIRE(_dependencyMap[2], "./lib/ReactPropTypesSecret");

  var checkPropTypes = _$$_REQUIRE(_dependencyMap[3], "./checkPropTypes");

  var has = Function.call.bind(Object.prototype.hasOwnProperty);

  var printWarning = function printWarning() {};

  if (process.env.NODE_ENV !== 'production') {
    printWarning = function printWarning(text) {
      var message = 'Warning: ' + text;

      if (typeof console !== 'undefined') {
        console.error(message);
      }

      try {
        throw new Error(message);
      } catch (x) {}
    };
  }

  function emptyFunctionThatReturnsNull() {
    return null;
  }

  module.exports = function (isValidElement, throwOnDirectAccess) {
    var ITERATOR_SYMBOL = typeof Symbol === 'function' && (typeof Symbol === "function" ? Symbol.iterator : "@@iterator");
    var FAUX_ITERATOR_SYMBOL = '@@iterator';

    function getIteratorFn(maybeIterable) {
      var iteratorFn = maybeIterable && (ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]);

      if (typeof iteratorFn === 'function') {
        return iteratorFn;
      }
    }

    var ANONYMOUS = '<<anonymous>>';
    var ReactPropTypes = {
      array: createPrimitiveTypeChecker('array'),
      bool: createPrimitiveTypeChecker('boolean'),
      func: createPrimitiveTypeChecker('function'),
      number: createPrimitiveTypeChecker('number'),
      object: createPrimitiveTypeChecker('object'),
      string: createPrimitiveTypeChecker('string'),
      symbol: createPrimitiveTypeChecker('symbol'),
      any: createAnyTypeChecker(),
      arrayOf: createArrayOfTypeChecker,
      element: createElementTypeChecker(),
      elementType: createElementTypeTypeChecker(),
      instanceOf: createInstanceTypeChecker,
      node: createNodeChecker(),
      objectOf: createObjectOfTypeChecker,
      oneOf: createEnumTypeChecker,
      oneOfType: createUnionTypeChecker,
      shape: createShapeTypeChecker,
      exact: createStrictShapeTypeChecker
    };

    function is(x, y) {
      if (x === y) {
        return x !== 0 || 1 / x === 1 / y;
      } else {
        return x !== x && y !== y;
      }
    }

    function PropTypeError(message) {
      this.message = message;
      this.stack = '';
    }

    PropTypeError.prototype = Error.prototype;

    function createChainableTypeChecker(validate) {
      if (process.env.NODE_ENV !== 'production') {
        var manualPropTypeCallCache = {};
        var manualPropTypeWarningCount = 0;
      }

      function checkType(isRequired, props, propName, componentName, location, propFullName, secret) {
        componentName = componentName || ANONYMOUS;
        propFullName = propFullName || propName;

        if (secret !== ReactPropTypesSecret) {
          if (throwOnDirectAccess) {
            var err = new Error('Calling PropTypes validators directly is not supported by the `prop-types` package. ' + 'Use `PropTypes.checkPropTypes()` to call them. ' + 'Read more at http://fb.me/use-check-prop-types');
            err.name = 'Invariant Violation';
            throw err;
          } else if (process.env.NODE_ENV !== 'production' && typeof console !== 'undefined') {
            var cacheKey = componentName + ':' + propName;

            if (!manualPropTypeCallCache[cacheKey] && manualPropTypeWarningCount < 3) {
              printWarning('You are manually calling a React.PropTypes validation ' + 'function for the `' + propFullName + '` prop on `' + componentName + '`. This is deprecated ' + 'and will throw in the standalone `prop-types` package. ' + 'You may be seeing this warning due to a third-party PropTypes ' + 'library. See https://fb.me/react-warning-dont-call-proptypes ' + 'for details.');
              manualPropTypeCallCache[cacheKey] = true;
              manualPropTypeWarningCount++;
            }
          }
        }

        if (props[propName] == null) {
          if (isRequired) {
            if (props[propName] === null) {
              return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required ' + ('in `' + componentName + '`, but its value is `null`.'));
            }

            return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required in ' + ('`' + componentName + '`, but its value is `undefined`.'));
          }

          return null;
        } else {
          return validate(props, propName, componentName, location, propFullName);
        }
      }

      var chainedCheckType = checkType.bind(null, false);
      chainedCheckType.isRequired = checkType.bind(null, true);
      return chainedCheckType;
    }

    function createPrimitiveTypeChecker(expectedType) {
      function validate(props, propName, componentName, location, propFullName, secret) {
        var propValue = props[propName];
        var propType = getPropType(propValue);

        if (propType !== expectedType) {
          var preciseType = getPreciseType(propValue);
          return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + preciseType + '` supplied to `' + componentName + '`, expected ') + ('`' + expectedType + '`.'));
        }

        return null;
      }

      return createChainableTypeChecker(validate);
    }

    function createAnyTypeChecker() {
      return createChainableTypeChecker(emptyFunctionThatReturnsNull);
    }

    function createArrayOfTypeChecker(typeChecker) {
      function validate(props, propName, componentName, location, propFullName) {
        if (typeof typeChecker !== 'function') {
          return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside arrayOf.');
        }

        var propValue = props[propName];

        if (!Array.isArray(propValue)) {
          var propType = getPropType(propValue);
          return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an array.'));
        }

        for (var i = 0; i < propValue.length; i++) {
          var error = typeChecker(propValue, i, componentName, location, propFullName + '[' + i + ']', ReactPropTypesSecret);

          if (error instanceof Error) {
            return error;
          }
        }

        return null;
      }

      return createChainableTypeChecker(validate);
    }

    function createElementTypeChecker() {
      function validate(props, propName, componentName, location, propFullName) {
        var propValue = props[propName];

        if (!isValidElement(propValue)) {
          var propType = getPropType(propValue);
          return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected a single ReactElement.'));
        }

        return null;
      }

      return createChainableTypeChecker(validate);
    }

    function createElementTypeTypeChecker() {
      function validate(props, propName, componentName, location, propFullName) {
        var propValue = props[propName];

        if (!ReactIs.isValidElementType(propValue)) {
          var propType = getPropType(propValue);
          return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected a single ReactElement type.'));
        }

        return null;
      }

      return createChainableTypeChecker(validate);
    }

    function createInstanceTypeChecker(expectedClass) {
      function validate(props, propName, componentName, location, propFullName) {
        if (!(props[propName] instanceof expectedClass)) {
          var expectedClassName = expectedClass.name || ANONYMOUS;
          var actualClassName = getClassName(props[propName]);
          return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + actualClassName + '` supplied to `' + componentName + '`, expected ') + ('instance of `' + expectedClassName + '`.'));
        }

        return null;
      }

      return createChainableTypeChecker(validate);
    }

    function createEnumTypeChecker(expectedValues) {
      if (!Array.isArray(expectedValues)) {
        if (process.env.NODE_ENV !== 'production') {
          if (arguments.length > 1) {
            printWarning('Invalid arguments supplied to oneOf, expected an array, got ' + arguments.length + ' arguments. ' + 'A common mistake is to write oneOf(x, y, z) instead of oneOf([x, y, z]).');
          } else {
            printWarning('Invalid argument supplied to oneOf, expected an array.');
          }
        }

        return emptyFunctionThatReturnsNull;
      }

      function validate(props, propName, componentName, location, propFullName) {
        var propValue = props[propName];

        for (var i = 0; i < expectedValues.length; i++) {
          if (is(propValue, expectedValues[i])) {
            return null;
          }
        }

        var valuesString = JSON.stringify(expectedValues, function replacer(key, value) {
          var type = getPreciseType(value);

          if (type === 'symbol') {
            return String(value);
          }

          return value;
        });
        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of value `' + String(propValue) + '` ' + ('supplied to `' + componentName + '`, expected one of ' + valuesString + '.'));
      }

      return createChainableTypeChecker(validate);
    }

    function createObjectOfTypeChecker(typeChecker) {
      function validate(props, propName, componentName, location, propFullName) {
        if (typeof typeChecker !== 'function') {
          return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside objectOf.');
        }

        var propValue = props[propName];
        var propType = getPropType(propValue);

        if (propType !== 'object') {
          return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an object.'));
        }

        for (var key in propValue) {
          if (has(propValue, key)) {
            var error = typeChecker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);

            if (error instanceof Error) {
              return error;
            }
          }
        }

        return null;
      }

      return createChainableTypeChecker(validate);
    }

    function createUnionTypeChecker(arrayOfTypeCheckers) {
      if (!Array.isArray(arrayOfTypeCheckers)) {
        process.env.NODE_ENV !== 'production' ? printWarning('Invalid argument supplied to oneOfType, expected an instance of array.') : void 0;
        return emptyFunctionThatReturnsNull;
      }

      for (var i = 0; i < arrayOfTypeCheckers.length; i++) {
        var checker = arrayOfTypeCheckers[i];

        if (typeof checker !== 'function') {
          printWarning('Invalid argument supplied to oneOfType. Expected an array of check functions, but ' + 'received ' + getPostfixForTypeWarning(checker) + ' at index ' + i + '.');
          return emptyFunctionThatReturnsNull;
        }
      }

      function validate(props, propName, componentName, location, propFullName) {
        for (var i = 0; i < arrayOfTypeCheckers.length; i++) {
          var checker = arrayOfTypeCheckers[i];

          if (checker(props, propName, componentName, location, propFullName, ReactPropTypesSecret) == null) {
            return null;
          }
        }

        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`.'));
      }

      return createChainableTypeChecker(validate);
    }

    function createNodeChecker() {
      function validate(props, propName, componentName, location, propFullName) {
        if (!isNode(props[propName])) {
          return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`, expected a ReactNode.'));
        }

        return null;
      }

      return createChainableTypeChecker(validate);
    }

    function createShapeTypeChecker(shapeTypes) {
      function validate(props, propName, componentName, location, propFullName) {
        var propValue = props[propName];
        var propType = getPropType(propValue);

        if (propType !== 'object') {
          return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.'));
        }

        for (var key in shapeTypes) {
          var checker = shapeTypes[key];

          if (!checker) {
            continue;
          }

          var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);

          if (error) {
            return error;
          }
        }

        return null;
      }

      return createChainableTypeChecker(validate);
    }

    function createStrictShapeTypeChecker(shapeTypes) {
      function validate(props, propName, componentName, location, propFullName) {
        var propValue = props[propName];
        var propType = getPropType(propValue);

        if (propType !== 'object') {
          return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.'));
        }

        var allKeys = assign({}, props[propName], shapeTypes);

        for (var key in allKeys) {
          var checker = shapeTypes[key];

          if (!checker) {
            return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` key `' + key + '` supplied to `' + componentName + '`.' + '\nBad object: ' + JSON.stringify(props[propName], null, '  ') + '\nValid keys: ' + JSON.stringify(Object.keys(shapeTypes), null, '  '));
          }

          var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);

          if (error) {
            return error;
          }
        }

        return null;
      }

      return createChainableTypeChecker(validate);
    }

    function isNode(propValue) {
      switch (typeof propValue) {
        case 'number':
        case 'string':
        case 'undefined':
          return true;

        case 'boolean':
          return !propValue;

        case 'object':
          if (Array.isArray(propValue)) {
            return propValue.every(isNode);
          }

          if (propValue === null || isValidElement(propValue)) {
            return true;
          }

          var iteratorFn = getIteratorFn(propValue);

          if (iteratorFn) {
            var iterator = iteratorFn.call(propValue);
            var step;

            if (iteratorFn !== propValue.entries) {
              while (!(step = iterator.next()).done) {
                if (!isNode(step.value)) {
                  return false;
                }
              }
            } else {
              while (!(step = iterator.next()).done) {
                var entry = step.value;

                if (entry) {
                  if (!isNode(entry[1])) {
                    return false;
                  }
                }
              }
            }
          } else {
            return false;
          }

          return true;

        default:
          return false;
      }
    }

    function isSymbol(propType, propValue) {
      if (propType === 'symbol') {
        return true;
      }

      if (!propValue) {
        return false;
      }

      if (propValue['@@toStringTag'] === 'Symbol') {
        return true;
      }

      if (typeof Symbol === 'function' && propValue instanceof Symbol) {
        return true;
      }

      return false;
    }

    function getPropType(propValue) {
      var propType = typeof propValue;

      if (Array.isArray(propValue)) {
        return 'array';
      }

      if (propValue instanceof RegExp) {
        return 'object';
      }

      if (isSymbol(propType, propValue)) {
        return 'symbol';
      }

      return propType;
    }

    function getPreciseType(propValue) {
      if (typeof propValue === 'undefined' || propValue === null) {
        return '' + propValue;
      }

      var propType = getPropType(propValue);

      if (propType === 'object') {
        if (propValue instanceof Date) {
          return 'date';
        } else if (propValue instanceof RegExp) {
          return 'regexp';
        }
      }

      return propType;
    }

    function getPostfixForTypeWarning(value) {
      var type = getPreciseType(value);

      switch (type) {
        case 'array':
        case 'object':
          return 'an ' + type;

        case 'boolean':
        case 'date':
        case 'regexp':
          return 'a ' + type;

        default:
          return type;
      }
    }

    function getClassName(propValue) {
      if (!propValue.constructor || !propValue.constructor.name) {
        return ANONYMOUS;
      }

      return propValue.constructor.name;
    }

    ReactPropTypes.checkPropTypes = checkPropTypes;
    ReactPropTypes.resetWarningCache = checkPropTypes.resetWarningCache;
    ReactPropTypes.PropTypes = ReactPropTypes;
    return ReactPropTypes;
  };
},73,[70,56,59,58],"node_modules/prop-types/factoryWithTypeCheckers.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var ReactPropTypesSecret = _$$_REQUIRE(_dependencyMap[0], "./lib/ReactPropTypesSecret");

  function emptyFunction() {}

  function emptyFunctionWithReset() {}

  emptyFunctionWithReset.resetWarningCache = emptyFunction;

  module.exports = function () {
    function shim(props, propName, componentName, location, propFullName, secret) {
      if (secret === ReactPropTypesSecret) {
        return;
      }

      var err = new Error('Calling PropTypes validators directly is not supported by the `prop-types` package. ' + 'Use PropTypes.checkPropTypes() to call them. ' + 'Read more at http://fb.me/use-check-prop-types');
      err.name = 'Invariant Violation';
      throw err;
    }

    ;
    shim.isRequired = shim;

    function getShim() {
      return shim;
    }

    ;
    var ReactPropTypes = {
      array: shim,
      bool: shim,
      func: shim,
      number: shim,
      object: shim,
      string: shim,
      symbol: shim,
      any: shim,
      arrayOf: getShim,
      element: shim,
      elementType: shim,
      instanceOf: getShim,
      node: shim,
      objectOf: getShim,
      oneOf: getShim,
      oneOfType: getShim,
      shape: getShim,
      exact: getShim,
      checkPropTypes: emptyFunctionWithReset,
      resetWarningCache: emptyFunction
    };
    ReactPropTypes.PropTypes = ReactPropTypes;
    return ReactPropTypes;
  };
},74,[59],"node_modules/prop-types/factoryWithThrowingShims.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var DeprecatedColorPropType = _$$_REQUIRE(_dependencyMap[0], "./DeprecatedColorPropType");

  var ReactPropTypes = _$$_REQUIRE(_dependencyMap[1], "prop-types");

  var DeprecatedShadowPropTypesIOS = {
    shadowColor: DeprecatedColorPropType,
    shadowOffset: ReactPropTypes.shape({
      width: ReactPropTypes.number,
      height: ReactPropTypes.number
    }),
    shadowOpacity: ReactPropTypes.number,
    shadowRadius: ReactPropTypes.number
  };
  module.exports = DeprecatedShadowPropTypesIOS;
},75,[66,69],"node_modules/react-native/Libraries/DeprecatedPropTypes/DeprecatedShadowPropTypesIOS.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var ReactPropTypes = _$$_REQUIRE(_dependencyMap[0], "prop-types");

  var deprecatedPropType = _$$_REQUIRE(_dependencyMap[1], "../Utilities/deprecatedPropType");

  var TransformMatrixPropType = function TransformMatrixPropType(props, propName, componentName) {
    if (props[propName]) {
      return new Error('The transformMatrix style property is deprecated. ' + 'Use `transform: [{ matrix: ... }]` instead.');
    }
  };

  var DecomposedMatrixPropType = function DecomposedMatrixPropType(props, propName, componentName) {
    if (props[propName]) {
      return new Error('The decomposedMatrix style property is deprecated. ' + 'Use `transform: [...]` instead.');
    }
  };

  var DeprecatedTransformPropTypes = {
    transform: ReactPropTypes.arrayOf(ReactPropTypes.oneOfType([ReactPropTypes.shape({
      perspective: ReactPropTypes.number
    }), ReactPropTypes.shape({
      rotate: ReactPropTypes.string
    }), ReactPropTypes.shape({
      rotateX: ReactPropTypes.string
    }), ReactPropTypes.shape({
      rotateY: ReactPropTypes.string
    }), ReactPropTypes.shape({
      rotateZ: ReactPropTypes.string
    }), ReactPropTypes.shape({
      scale: ReactPropTypes.number
    }), ReactPropTypes.shape({
      scaleX: ReactPropTypes.number
    }), ReactPropTypes.shape({
      scaleY: ReactPropTypes.number
    }), ReactPropTypes.shape({
      translateX: ReactPropTypes.number
    }), ReactPropTypes.shape({
      translateY: ReactPropTypes.number
    }), ReactPropTypes.shape({
      skewX: ReactPropTypes.string
    }), ReactPropTypes.shape({
      skewY: ReactPropTypes.string
    })])),
    transformMatrix: TransformMatrixPropType,
    decomposedMatrix: DecomposedMatrixPropType,
    scaleX: deprecatedPropType(ReactPropTypes.number, 'Use the transform prop instead.'),
    scaleY: deprecatedPropType(ReactPropTypes.number, 'Use the transform prop instead.'),
    rotation: deprecatedPropType(ReactPropTypes.number, 'Use the transform prop instead.'),
    translateX: deprecatedPropType(ReactPropTypes.number, 'Use the transform prop instead.'),
    translateY: deprecatedPropType(ReactPropTypes.number, 'Use the transform prop instead.')
  };
  module.exports = DeprecatedTransformPropTypes;
},76,[69,77],"node_modules/react-native/Libraries/DeprecatedPropTypes/DeprecatedTransformPropTypes.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var UIManager = _$$_REQUIRE(_dependencyMap[0], "../ReactNative/UIManager");

  function deprecatedPropType(propType, explanation) {
    return function validate(props, propName, componentName) {
      if (!UIManager.getViewManagerConfig(componentName) && props[propName] !== undefined) {
        console.warn("`" + propName + "` supplied to `" + componentName + "` has been deprecated. " + explanation);
      }

      for (var _len = arguments.length, rest = new Array(_len > 3 ? _len - 3 : 0), _key = 3; _key < _len; _key++) {
        rest[_key - 3] = arguments[_key];
      }

      return propType.apply(void 0, [props, propName, componentName].concat(rest));
    };
  }

  module.exports = deprecatedPropType;
},77,[43],"node_modules/react-native/Libraries/Utilities/deprecatedPropType.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");

  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

  var DeprecatedColorPropType = _$$_REQUIRE(_dependencyMap[1], "./DeprecatedColorPropType");

  var DeprecatedViewStylePropTypes = _$$_REQUIRE(_dependencyMap[2], "./DeprecatedViewStylePropTypes");

  var ReactPropTypes = _$$_REQUIRE(_dependencyMap[3], "prop-types");

  var DeprecatedTextStylePropTypes = _objectSpread({}, DeprecatedViewStylePropTypes, {
    color: DeprecatedColorPropType,
    fontFamily: ReactPropTypes.string,
    fontSize: ReactPropTypes.number,
    fontStyle: ReactPropTypes.oneOf(['normal', 'italic']),
    fontWeight: ReactPropTypes.oneOf(['normal', 'bold', '100', '200', '300', '400', '500', '600', '700', '800', '900']),
    fontVariant: ReactPropTypes.arrayOf(ReactPropTypes.oneOf(['small-caps', 'oldstyle-nums', 'lining-nums', 'tabular-nums', 'proportional-nums'])),
    textShadowOffset: ReactPropTypes.shape({
      width: ReactPropTypes.number,
      height: ReactPropTypes.number
    }),
    textShadowRadius: ReactPropTypes.number,
    textShadowColor: DeprecatedColorPropType,
    letterSpacing: ReactPropTypes.number,
    lineHeight: ReactPropTypes.number,
    textAlign: ReactPropTypes.oneOf(['auto', 'left', 'right', 'center', 'justify']),
    textAlignVertical: ReactPropTypes.oneOf(['auto', 'top', 'bottom', 'center']),
    includeFontPadding: ReactPropTypes.bool,
    textDecorationLine: ReactPropTypes.oneOf(['none', 'underline', 'line-through', 'underline line-through']),
    textDecorationStyle: ReactPropTypes.oneOf(['solid', 'double', 'dotted', 'dashed']),
    textDecorationColor: DeprecatedColorPropType,
    textTransform: ReactPropTypes.oneOf(['none', 'capitalize', 'uppercase', 'lowercase']),
    writingDirection: ReactPropTypes.oneOf(['auto', 'ltr', 'rtl'])
  });

  module.exports = DeprecatedTextStylePropTypes;
},78,[46,66,79,69],"node_modules/react-native/Libraries/DeprecatedPropTypes/DeprecatedTextStylePropTypes.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");

  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

  var DeprecatedColorPropType = _$$_REQUIRE(_dependencyMap[1], "./DeprecatedColorPropType");

  var DeprecatedLayoutPropTypes = _$$_REQUIRE(_dependencyMap[2], "./DeprecatedLayoutPropTypes");

  var DeprecatedShadowPropTypesIOS = _$$_REQUIRE(_dependencyMap[3], "./DeprecatedShadowPropTypesIOS");

  var DeprecatedTransformPropTypes = _$$_REQUIRE(_dependencyMap[4], "./DeprecatedTransformPropTypes");

  var ReactPropTypes = _$$_REQUIRE(_dependencyMap[5], "prop-types");

  var DeprecatedViewStylePropTypes = _objectSpread({}, DeprecatedLayoutPropTypes, {}, DeprecatedShadowPropTypesIOS, {}, DeprecatedTransformPropTypes, {
    backfaceVisibility: ReactPropTypes.oneOf(['visible', 'hidden']),
    backgroundColor: DeprecatedColorPropType,
    borderColor: DeprecatedColorPropType,
    borderTopColor: DeprecatedColorPropType,
    borderRightColor: DeprecatedColorPropType,
    borderBottomColor: DeprecatedColorPropType,
    borderLeftColor: DeprecatedColorPropType,
    borderStartColor: DeprecatedColorPropType,
    borderEndColor: DeprecatedColorPropType,
    borderRadius: ReactPropTypes.number,
    borderTopLeftRadius: ReactPropTypes.number,
    borderTopRightRadius: ReactPropTypes.number,
    borderTopStartRadius: ReactPropTypes.number,
    borderTopEndRadius: ReactPropTypes.number,
    borderBottomLeftRadius: ReactPropTypes.number,
    borderBottomRightRadius: ReactPropTypes.number,
    borderBottomStartRadius: ReactPropTypes.number,
    borderBottomEndRadius: ReactPropTypes.number,
    borderStyle: ReactPropTypes.oneOf(['solid', 'dotted', 'dashed']),
    borderWidth: ReactPropTypes.number,
    borderTopWidth: ReactPropTypes.number,
    borderRightWidth: ReactPropTypes.number,
    borderBottomWidth: ReactPropTypes.number,
    borderLeftWidth: ReactPropTypes.number,
    opacity: ReactPropTypes.number,
    elevation: ReactPropTypes.number
  });

  module.exports = DeprecatedViewStylePropTypes;
},79,[46,66,68,75,76,69],"node_modules/react-native/Libraries/DeprecatedPropTypes/DeprecatedViewStylePropTypes.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var Platform = _$$_REQUIRE(_dependencyMap[0], "../Utilities/Platform");

  var normalizeColor = _$$_REQUIRE(_dependencyMap[1], "../Color/normalizeColor");

  function processColor(color) {
    if (color === undefined || color === null) {
      return color;
    }

    var int32Color = normalizeColor(color);

    if (int32Color === null || int32Color === undefined) {
      return undefined;
    }

    int32Color = (int32Color << 24 | int32Color >>> 8) >>> 0;

    if ("android" === 'android') {
      int32Color = int32Color | 0x0;
    }

    return int32Color;
  }

  module.exports = processColor;
},80,[48,67],"node_modules/react-native/Libraries/StyleSheet/processColor.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var MatrixMath = _$$_REQUIRE(_dependencyMap[0], "../Utilities/MatrixMath");

  var Platform = _$$_REQUIRE(_dependencyMap[1], "../Utilities/Platform");

  var invariant = _$$_REQUIRE(_dependencyMap[2], "invariant");

  var stringifySafe = _$$_REQUIRE(_dependencyMap[3], "../Utilities/stringifySafe");

  function processTransform(transform) {
    if (__DEV__) {
      _validateTransforms(transform);
    }

    if ("android" === 'android' || "android" === 'ios') {
      return transform;
    }

    var result = MatrixMath.createIdentityMatrix();
    transform.forEach(function (transformation) {
      var key = Object.keys(transformation)[0];
      var value = transformation[key];

      switch (key) {
        case 'matrix':
          MatrixMath.multiplyInto(result, result, value);
          break;

        case 'perspective':
          _multiplyTransform(result, MatrixMath.reusePerspectiveCommand, [value]);

          break;

        case 'rotateX':
          _multiplyTransform(result, MatrixMath.reuseRotateXCommand, [_convertToRadians(value)]);

          break;

        case 'rotateY':
          _multiplyTransform(result, MatrixMath.reuseRotateYCommand, [_convertToRadians(value)]);

          break;

        case 'rotate':
        case 'rotateZ':
          _multiplyTransform(result, MatrixMath.reuseRotateZCommand, [_convertToRadians(value)]);

          break;

        case 'scale':
          _multiplyTransform(result, MatrixMath.reuseScaleCommand, [value]);

          break;

        case 'scaleX':
          _multiplyTransform(result, MatrixMath.reuseScaleXCommand, [value]);

          break;

        case 'scaleY':
          _multiplyTransform(result, MatrixMath.reuseScaleYCommand, [value]);

          break;

        case 'translate':
          _multiplyTransform(result, MatrixMath.reuseTranslate3dCommand, [value[0], value[1], value[2] || 0]);

          break;

        case 'translateX':
          _multiplyTransform(result, MatrixMath.reuseTranslate2dCommand, [value, 0]);

          break;

        case 'translateY':
          _multiplyTransform(result, MatrixMath.reuseTranslate2dCommand, [0, value]);

          break;

        case 'skewX':
          _multiplyTransform(result, MatrixMath.reuseSkewXCommand, [_convertToRadians(value)]);

          break;

        case 'skewY':
          _multiplyTransform(result, MatrixMath.reuseSkewYCommand, [_convertToRadians(value)]);

          break;

        default:
          throw new Error('Invalid transform name: ' + key);
      }
    });
    return result;
  }

  function _multiplyTransform(result, matrixMathFunction, args) {
    var matrixToApply = MatrixMath.createIdentityMatrix();
    var argsWithIdentity = [matrixToApply].concat(args);
    matrixMathFunction.apply(this, argsWithIdentity);
    MatrixMath.multiplyInto(result, result, matrixToApply);
  }

  function _convertToRadians(value) {
    var floatValue = parseFloat(value);
    return value.indexOf('rad') > -1 ? floatValue : floatValue * Math.PI / 180;
  }

  function _validateTransforms(transform) {
    transform.forEach(function (transformation) {
      var keys = Object.keys(transformation);
      invariant(keys.length === 1, 'You must specify exactly one property per transform object. Passed properties: %s', stringifySafe(transformation));
      var key = keys[0];
      var value = transformation[key];

      _validateTransform(key, value, transformation);
    });
  }

  function _validateTransform(key, value, transformation) {
    invariant(!value.getValue, 'You passed an Animated.Value to a normal component. ' + 'You need to wrap that component in an Animated. For example, ' + 'replace <View /> by <Animated.View />.');
    var multivalueTransforms = ['matrix', 'translate'];

    if (multivalueTransforms.indexOf(key) !== -1) {
      invariant(Array.isArray(value), 'Transform with key of %s must have an array as the value: %s', key, stringifySafe(transformation));
    }

    switch (key) {
      case 'matrix':
        invariant(value.length === 9 || value.length === 16, 'Matrix transform must have a length of 9 (2d) or 16 (3d). ' + 'Provided matrix has a length of %s: %s', value.length, stringifySafe(transformation));
        break;

      case 'translate':
        invariant(value.length === 2 || value.length === 3, 'Transform with key translate must be an array of length 2 or 3, found %s: %s', value.length, stringifySafe(transformation));
        break;

      case 'rotateX':
      case 'rotateY':
      case 'rotateZ':
      case 'rotate':
      case 'skewX':
      case 'skewY':
        invariant(typeof value === 'string', 'Transform with key of "%s" must be a string: %s', key, stringifySafe(transformation));
        invariant(value.indexOf('deg') > -1 || value.indexOf('rad') > -1, 'Rotate transform must be expressed in degrees (deg) or radians ' + '(rad): %s', stringifySafe(transformation));
        break;

      case 'perspective':
        invariant(typeof value === 'number', 'Transform with key of "%s" must be a number: %s', key, stringifySafe(transformation));
        invariant(value !== 0, 'Transform with key of "%s" cannot be zero: %s', key, stringifySafe(transformation));
        break;

      case 'translateX':
      case 'translateY':
      case 'scale':
      case 'scaleX':
      case 'scaleY':
        invariant(typeof value === 'number', 'Transform with key of "%s" must be a number: %s', key, stringifySafe(transformation));
        break;

      default:
        invariant(false, 'Invalid transform %s: %s', key, stringifySafe(transformation));
    }
  }

  module.exports = processTransform;
},81,[82,48,3,29],"node_modules/react-native/Libraries/StyleSheet/processTransform.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _slicedToArray = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/slicedToArray");

  var invariant = _$$_REQUIRE(_dependencyMap[1], "invariant");

  var MatrixMath = {
    createIdentityMatrix: function createIdentityMatrix() {
      return [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
    },
    createCopy: function createCopy(m) {
      return [m[0], m[1], m[2], m[3], m[4], m[5], m[6], m[7], m[8], m[9], m[10], m[11], m[12], m[13], m[14], m[15]];
    },
    createOrthographic: function createOrthographic(left, right, bottom, top, near, far) {
      var a = 2 / (right - left);
      var b = 2 / (top - bottom);
      var c = -2 / (far - near);
      var tx = -(right + left) / (right - left);
      var ty = -(top + bottom) / (top - bottom);
      var tz = -(far + near) / (far - near);
      return [a, 0, 0, 0, 0, b, 0, 0, 0, 0, c, 0, tx, ty, tz, 1];
    },
    createFrustum: function createFrustum(left, right, bottom, top, near, far) {
      var r_width = 1 / (right - left);
      var r_height = 1 / (top - bottom);
      var r_depth = 1 / (near - far);
      var x = 2 * (near * r_width);
      var y = 2 * (near * r_height);
      var A = (right + left) * r_width;
      var B = (top + bottom) * r_height;
      var C = (far + near) * r_depth;
      var D = 2 * (far * near * r_depth);
      return [x, 0, 0, 0, 0, y, 0, 0, A, B, C, -1, 0, 0, D, 0];
    },
    createPerspective: function createPerspective(fovInRadians, aspect, near, far) {
      var h = 1 / Math.tan(fovInRadians / 2);
      var r_depth = 1 / (near - far);
      var C = (far + near) * r_depth;
      var D = 2 * (far * near * r_depth);
      return [h / aspect, 0, 0, 0, 0, h, 0, 0, 0, 0, C, -1, 0, 0, D, 0];
    },
    createTranslate2d: function createTranslate2d(x, y) {
      var mat = MatrixMath.createIdentityMatrix();
      MatrixMath.reuseTranslate2dCommand(mat, x, y);
      return mat;
    },
    reuseTranslate2dCommand: function reuseTranslate2dCommand(matrixCommand, x, y) {
      matrixCommand[12] = x;
      matrixCommand[13] = y;
    },
    reuseTranslate3dCommand: function reuseTranslate3dCommand(matrixCommand, x, y, z) {
      matrixCommand[12] = x;
      matrixCommand[13] = y;
      matrixCommand[14] = z;
    },
    createScale: function createScale(factor) {
      var mat = MatrixMath.createIdentityMatrix();
      MatrixMath.reuseScaleCommand(mat, factor);
      return mat;
    },
    reuseScaleCommand: function reuseScaleCommand(matrixCommand, factor) {
      matrixCommand[0] = factor;
      matrixCommand[5] = factor;
    },
    reuseScale3dCommand: function reuseScale3dCommand(matrixCommand, x, y, z) {
      matrixCommand[0] = x;
      matrixCommand[5] = y;
      matrixCommand[10] = z;
    },
    reusePerspectiveCommand: function reusePerspectiveCommand(matrixCommand, p) {
      matrixCommand[11] = -1 / p;
    },
    reuseScaleXCommand: function reuseScaleXCommand(matrixCommand, factor) {
      matrixCommand[0] = factor;
    },
    reuseScaleYCommand: function reuseScaleYCommand(matrixCommand, factor) {
      matrixCommand[5] = factor;
    },
    reuseScaleZCommand: function reuseScaleZCommand(matrixCommand, factor) {
      matrixCommand[10] = factor;
    },
    reuseRotateXCommand: function reuseRotateXCommand(matrixCommand, radians) {
      matrixCommand[5] = Math.cos(radians);
      matrixCommand[6] = Math.sin(radians);
      matrixCommand[9] = -Math.sin(radians);
      matrixCommand[10] = Math.cos(radians);
    },
    reuseRotateYCommand: function reuseRotateYCommand(matrixCommand, amount) {
      matrixCommand[0] = Math.cos(amount);
      matrixCommand[2] = -Math.sin(amount);
      matrixCommand[8] = Math.sin(amount);
      matrixCommand[10] = Math.cos(amount);
    },
    reuseRotateZCommand: function reuseRotateZCommand(matrixCommand, radians) {
      matrixCommand[0] = Math.cos(radians);
      matrixCommand[1] = Math.sin(radians);
      matrixCommand[4] = -Math.sin(radians);
      matrixCommand[5] = Math.cos(radians);
    },
    createRotateZ: function createRotateZ(radians) {
      var mat = MatrixMath.createIdentityMatrix();
      MatrixMath.reuseRotateZCommand(mat, radians);
      return mat;
    },
    reuseSkewXCommand: function reuseSkewXCommand(matrixCommand, radians) {
      matrixCommand[4] = Math.tan(radians);
    },
    reuseSkewYCommand: function reuseSkewYCommand(matrixCommand, radians) {
      matrixCommand[1] = Math.tan(radians);
    },
    multiplyInto: function multiplyInto(out, a, b) {
      var a00 = a[0],
          a01 = a[1],
          a02 = a[2],
          a03 = a[3],
          a10 = a[4],
          a11 = a[5],
          a12 = a[6],
          a13 = a[7],
          a20 = a[8],
          a21 = a[9],
          a22 = a[10],
          a23 = a[11],
          a30 = a[12],
          a31 = a[13],
          a32 = a[14],
          a33 = a[15];
      var b0 = b[0],
          b1 = b[1],
          b2 = b[2],
          b3 = b[3];
      out[0] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
      out[1] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
      out[2] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
      out[3] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
      b0 = b[4];
      b1 = b[5];
      b2 = b[6];
      b3 = b[7];
      out[4] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
      out[5] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
      out[6] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
      out[7] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
      b0 = b[8];
      b1 = b[9];
      b2 = b[10];
      b3 = b[11];
      out[8] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
      out[9] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
      out[10] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
      out[11] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
      b0 = b[12];
      b1 = b[13];
      b2 = b[14];
      b3 = b[15];
      out[12] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
      out[13] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
      out[14] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
      out[15] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
    },
    determinant: function determinant(matrix) {
      var _matrix = _slicedToArray(matrix, 16),
          m00 = _matrix[0],
          m01 = _matrix[1],
          m02 = _matrix[2],
          m03 = _matrix[3],
          m10 = _matrix[4],
          m11 = _matrix[5],
          m12 = _matrix[6],
          m13 = _matrix[7],
          m20 = _matrix[8],
          m21 = _matrix[9],
          m22 = _matrix[10],
          m23 = _matrix[11],
          m30 = _matrix[12],
          m31 = _matrix[13],
          m32 = _matrix[14],
          m33 = _matrix[15];

      return m03 * m12 * m21 * m30 - m02 * m13 * m21 * m30 - m03 * m11 * m22 * m30 + m01 * m13 * m22 * m30 + m02 * m11 * m23 * m30 - m01 * m12 * m23 * m30 - m03 * m12 * m20 * m31 + m02 * m13 * m20 * m31 + m03 * m10 * m22 * m31 - m00 * m13 * m22 * m31 - m02 * m10 * m23 * m31 + m00 * m12 * m23 * m31 + m03 * m11 * m20 * m32 - m01 * m13 * m20 * m32 - m03 * m10 * m21 * m32 + m00 * m13 * m21 * m32 + m01 * m10 * m23 * m32 - m00 * m11 * m23 * m32 - m02 * m11 * m20 * m33 + m01 * m12 * m20 * m33 + m02 * m10 * m21 * m33 - m00 * m12 * m21 * m33 - m01 * m10 * m22 * m33 + m00 * m11 * m22 * m33;
    },
    inverse: function inverse(matrix) {
      var det = MatrixMath.determinant(matrix);

      if (!det) {
        return matrix;
      }

      var _matrix2 = _slicedToArray(matrix, 16),
          m00 = _matrix2[0],
          m01 = _matrix2[1],
          m02 = _matrix2[2],
          m03 = _matrix2[3],
          m10 = _matrix2[4],
          m11 = _matrix2[5],
          m12 = _matrix2[6],
          m13 = _matrix2[7],
          m20 = _matrix2[8],
          m21 = _matrix2[9],
          m22 = _matrix2[10],
          m23 = _matrix2[11],
          m30 = _matrix2[12],
          m31 = _matrix2[13],
          m32 = _matrix2[14],
          m33 = _matrix2[15];

      return [(m12 * m23 * m31 - m13 * m22 * m31 + m13 * m21 * m32 - m11 * m23 * m32 - m12 * m21 * m33 + m11 * m22 * m33) / det, (m03 * m22 * m31 - m02 * m23 * m31 - m03 * m21 * m32 + m01 * m23 * m32 + m02 * m21 * m33 - m01 * m22 * m33) / det, (m02 * m13 * m31 - m03 * m12 * m31 + m03 * m11 * m32 - m01 * m13 * m32 - m02 * m11 * m33 + m01 * m12 * m33) / det, (m03 * m12 * m21 - m02 * m13 * m21 - m03 * m11 * m22 + m01 * m13 * m22 + m02 * m11 * m23 - m01 * m12 * m23) / det, (m13 * m22 * m30 - m12 * m23 * m30 - m13 * m20 * m32 + m10 * m23 * m32 + m12 * m20 * m33 - m10 * m22 * m33) / det, (m02 * m23 * m30 - m03 * m22 * m30 + m03 * m20 * m32 - m00 * m23 * m32 - m02 * m20 * m33 + m00 * m22 * m33) / det, (m03 * m12 * m30 - m02 * m13 * m30 - m03 * m10 * m32 + m00 * m13 * m32 + m02 * m10 * m33 - m00 * m12 * m33) / det, (m02 * m13 * m20 - m03 * m12 * m20 + m03 * m10 * m22 - m00 * m13 * m22 - m02 * m10 * m23 + m00 * m12 * m23) / det, (m11 * m23 * m30 - m13 * m21 * m30 + m13 * m20 * m31 - m10 * m23 * m31 - m11 * m20 * m33 + m10 * m21 * m33) / det, (m03 * m21 * m30 - m01 * m23 * m30 - m03 * m20 * m31 + m00 * m23 * m31 + m01 * m20 * m33 - m00 * m21 * m33) / det, (m01 * m13 * m30 - m03 * m11 * m30 + m03 * m10 * m31 - m00 * m13 * m31 - m01 * m10 * m33 + m00 * m11 * m33) / det, (m03 * m11 * m20 - m01 * m13 * m20 - m03 * m10 * m21 + m00 * m13 * m21 + m01 * m10 * m23 - m00 * m11 * m23) / det, (m12 * m21 * m30 - m11 * m22 * m30 - m12 * m20 * m31 + m10 * m22 * m31 + m11 * m20 * m32 - m10 * m21 * m32) / det, (m01 * m22 * m30 - m02 * m21 * m30 + m02 * m20 * m31 - m00 * m22 * m31 - m01 * m20 * m32 + m00 * m21 * m32) / det, (m02 * m11 * m30 - m01 * m12 * m30 - m02 * m10 * m31 + m00 * m12 * m31 + m01 * m10 * m32 - m00 * m11 * m32) / det, (m01 * m12 * m20 - m02 * m11 * m20 + m02 * m10 * m21 - m00 * m12 * m21 - m01 * m10 * m22 + m00 * m11 * m22) / det];
    },
    transpose: function transpose(m) {
      return [m[0], m[4], m[8], m[12], m[1], m[5], m[9], m[13], m[2], m[6], m[10], m[14], m[3], m[7], m[11], m[15]];
    },
    multiplyVectorByMatrix: function multiplyVectorByMatrix(v, m) {
      var _v = _slicedToArray(v, 4),
          vx = _v[0],
          vy = _v[1],
          vz = _v[2],
          vw = _v[3];

      return [vx * m[0] + vy * m[4] + vz * m[8] + vw * m[12], vx * m[1] + vy * m[5] + vz * m[9] + vw * m[13], vx * m[2] + vy * m[6] + vz * m[10] + vw * m[14], vx * m[3] + vy * m[7] + vz * m[11] + vw * m[15]];
    },
    v3Length: function v3Length(a) {
      return Math.sqrt(a[0] * a[0] + a[1] * a[1] + a[2] * a[2]);
    },
    v3Normalize: function v3Normalize(vector, v3Length) {
      var im = 1 / (v3Length || MatrixMath.v3Length(vector));
      return [vector[0] * im, vector[1] * im, vector[2] * im];
    },
    v3Dot: function v3Dot(a, b) {
      return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
    },
    v3Combine: function v3Combine(a, b, aScale, bScale) {
      return [aScale * a[0] + bScale * b[0], aScale * a[1] + bScale * b[1], aScale * a[2] + bScale * b[2]];
    },
    v3Cross: function v3Cross(a, b) {
      return [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
    },
    quaternionToDegreesXYZ: function quaternionToDegreesXYZ(q, matrix, row) {
      var _q = _slicedToArray(q, 4),
          qx = _q[0],
          qy = _q[1],
          qz = _q[2],
          qw = _q[3];

      var qw2 = qw * qw;
      var qx2 = qx * qx;
      var qy2 = qy * qy;
      var qz2 = qz * qz;
      var test = qx * qy + qz * qw;
      var unit = qw2 + qx2 + qy2 + qz2;
      var conv = 180 / Math.PI;

      if (test > 0.49999 * unit) {
        return [0, 2 * Math.atan2(qx, qw) * conv, 90];
      }

      if (test < -0.49999 * unit) {
        return [0, -2 * Math.atan2(qx, qw) * conv, -90];
      }

      return [MatrixMath.roundTo3Places(Math.atan2(2 * qx * qw - 2 * qy * qz, 1 - 2 * qx2 - 2 * qz2) * conv), MatrixMath.roundTo3Places(Math.atan2(2 * qy * qw - 2 * qx * qz, 1 - 2 * qy2 - 2 * qz2) * conv), MatrixMath.roundTo3Places(Math.asin(2 * qx * qy + 2 * qz * qw) * conv)];
    },
    roundTo3Places: function roundTo3Places(n) {
      var arr = n.toString().split('e');
      return Math.round(arr[0] + 'e' + (arr[1] ? +arr[1] - 3 : 3)) * 0.001;
    },
    decomposeMatrix: function decomposeMatrix(transformMatrix) {
      invariant(transformMatrix.length === 16, 'Matrix decomposition needs a list of 3d matrix values, received %s', transformMatrix);
      var perspective = [];
      var quaternion = [];
      var scale = [];
      var skew = [];
      var translation = [];

      if (!transformMatrix[15]) {
        return;
      }

      var matrix = [];
      var perspectiveMatrix = [];

      for (var i = 0; i < 4; i++) {
        matrix.push([]);

        for (var j = 0; j < 4; j++) {
          var value = transformMatrix[i * 4 + j] / transformMatrix[15];
          matrix[i].push(value);
          perspectiveMatrix.push(j === 3 ? 0 : value);
        }
      }

      perspectiveMatrix[15] = 1;

      if (!MatrixMath.determinant(perspectiveMatrix)) {
        return;
      }

      if (matrix[0][3] !== 0 || matrix[1][3] !== 0 || matrix[2][3] !== 0) {
        var rightHandSide = [matrix[0][3], matrix[1][3], matrix[2][3], matrix[3][3]];
        var inversePerspectiveMatrix = MatrixMath.inverse(perspectiveMatrix);
        var transposedInversePerspectiveMatrix = MatrixMath.transpose(inversePerspectiveMatrix);
        perspective = MatrixMath.multiplyVectorByMatrix(rightHandSide, transposedInversePerspectiveMatrix);
      } else {
        perspective[0] = perspective[1] = perspective[2] = 0;
        perspective[3] = 1;
      }

      for (var _i = 0; _i < 3; _i++) {
        translation[_i] = matrix[3][_i];
      }

      var row = [];

      for (var _i2 = 0; _i2 < 3; _i2++) {
        row[_i2] = [matrix[_i2][0], matrix[_i2][1], matrix[_i2][2]];
      }

      scale[0] = MatrixMath.v3Length(row[0]);
      row[0] = MatrixMath.v3Normalize(row[0], scale[0]);
      skew[0] = MatrixMath.v3Dot(row[0], row[1]);
      row[1] = MatrixMath.v3Combine(row[1], row[0], 1.0, -skew[0]);
      skew[0] = MatrixMath.v3Dot(row[0], row[1]);
      row[1] = MatrixMath.v3Combine(row[1], row[0], 1.0, -skew[0]);
      scale[1] = MatrixMath.v3Length(row[1]);
      row[1] = MatrixMath.v3Normalize(row[1], scale[1]);
      skew[0] /= scale[1];
      skew[1] = MatrixMath.v3Dot(row[0], row[2]);
      row[2] = MatrixMath.v3Combine(row[2], row[0], 1.0, -skew[1]);
      skew[2] = MatrixMath.v3Dot(row[1], row[2]);
      row[2] = MatrixMath.v3Combine(row[2], row[1], 1.0, -skew[2]);
      scale[2] = MatrixMath.v3Length(row[2]);
      row[2] = MatrixMath.v3Normalize(row[2], scale[2]);
      skew[1] /= scale[2];
      skew[2] /= scale[2];
      var pdum3 = MatrixMath.v3Cross(row[1], row[2]);

      if (MatrixMath.v3Dot(row[0], pdum3) < 0) {
        for (var _i3 = 0; _i3 < 3; _i3++) {
          scale[_i3] *= -1;
          row[_i3][0] *= -1;
          row[_i3][1] *= -1;
          row[_i3][2] *= -1;
        }
      }

      quaternion[0] = 0.5 * Math.sqrt(Math.max(1 + row[0][0] - row[1][1] - row[2][2], 0));
      quaternion[1] = 0.5 * Math.sqrt(Math.max(1 - row[0][0] + row[1][1] - row[2][2], 0));
      quaternion[2] = 0.5 * Math.sqrt(Math.max(1 - row[0][0] - row[1][1] + row[2][2], 0));
      quaternion[3] = 0.5 * Math.sqrt(Math.max(1 + row[0][0] + row[1][1] + row[2][2], 0));

      if (row[2][1] > row[1][2]) {
        quaternion[0] = -quaternion[0];
      }

      if (row[0][2] > row[2][0]) {
        quaternion[1] = -quaternion[1];
      }

      if (row[1][0] > row[0][1]) {
        quaternion[2] = -quaternion[2];
      }

      var rotationDegrees;

      if (quaternion[0] < 0.001 && quaternion[0] >= 0 && quaternion[1] < 0.001 && quaternion[1] >= 0) {
        rotationDegrees = [0, 0, MatrixMath.roundTo3Places(Math.atan2(row[0][1], row[0][0]) * 180 / Math.PI)];
      } else {
        rotationDegrees = MatrixMath.quaternionToDegreesXYZ(quaternion, matrix, row);
      }

      return {
        rotationDegrees: rotationDegrees,
        perspective: perspective,
        quaternion: quaternion,
        scale: scale,
        skew: skew,
        translation: translation,
        rotate: rotationDegrees[2],
        rotateX: rotationDegrees[0],
        rotateY: rotationDegrees[1],
        scaleX: scale[0],
        scaleY: scale[1],
        translateX: translation[0],
        translateY: translation[1]
      };
    }
  };
  module.exports = MatrixMath;
},82,[14,3],"node_modules/react-native/Libraries/Utilities/MatrixMath.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var dummySize = {
    width: undefined,
    height: undefined
  };

  var sizesDiffer = function sizesDiffer(one, two) {
    one = one || dummySize;
    two = two || dummySize;
    return one !== two && (one.width !== two.width || one.height !== two.height);
  };

  module.exports = sizesDiffer;
},83,[],"node_modules/react-native/Libraries/Utilities/differ/sizesDiffer.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");

  var DeprecatedImageStylePropTypes = _$$_REQUIRE(_dependencyMap[2], "../DeprecatedPropTypes/DeprecatedImageStylePropTypes");

  var DeprecatedTextStylePropTypes = _$$_REQUIRE(_dependencyMap[3], "../DeprecatedPropTypes/DeprecatedTextStylePropTypes");

  var DeprecatedViewStylePropTypes = _$$_REQUIRE(_dependencyMap[4], "../DeprecatedPropTypes/DeprecatedViewStylePropTypes");

  var invariant = _$$_REQUIRE(_dependencyMap[5], "invariant");

  var ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';

  var StyleSheetValidation = function () {
    function StyleSheetValidation() {
      _classCallCheck(this, StyleSheetValidation);
    }

    _createClass(StyleSheetValidation, null, [{
      key: "validateStyleProp",
      value: function validateStyleProp(prop, style, caller) {
        if (!__DEV__ || global.__RCTProfileIsProfiling) {
          return;
        }

        if (allStylePropTypes[prop] === undefined) {
          var message1 = '"' + prop + '" is not a valid style property.';
          var message2 = '\nValid style props: ' + JSON.stringify(Object.keys(allStylePropTypes).sort(), null, '  ');
          styleError(message1, style, caller, message2);
        }

        var error = allStylePropTypes[prop](style, prop, caller, 'prop', null, ReactPropTypesSecret);

        if (error) {
          styleError(error.message, style, caller);
        }
      }
    }, {
      key: "validateStyle",
      value: function validateStyle(name, styles) {
        if (!__DEV__ || global.__RCTProfileIsProfiling) {
          return;
        }

        for (var prop in styles[name]) {
          StyleSheetValidation.validateStyleProp(prop, styles[name], 'StyleSheet ' + name);
        }
      }
    }, {
      key: "addValidStylePropTypes",
      value: function addValidStylePropTypes(stylePropTypes) {
        if (!__DEV__ || global.__RCTProfileIsProfiling) {
          return;
        }

        for (var key in stylePropTypes) {
          allStylePropTypes[key] = stylePropTypes[key];
        }
      }
    }]);

    return StyleSheetValidation;
  }();

  var styleError = function styleError(message1, style, caller, message2) {
    invariant(false, message1 + '\n' + (caller || '<<unknown>>') + ': ' + JSON.stringify(style, null, '  ') + (message2 || ''));
  };

  var allStylePropTypes = {};

  if (__DEV__ && !global.__RCTProfileIsProfiling) {
    StyleSheetValidation.addValidStylePropTypes(DeprecatedImageStylePropTypes);
    StyleSheetValidation.addValidStylePropTypes(DeprecatedTextStylePropTypes);
    StyleSheetValidation.addValidStylePropTypes(DeprecatedViewStylePropTypes);
  }

  module.exports = StyleSheetValidation;
},84,[24,25,65,78,79,3],"node_modules/react-native/Libraries/StyleSheet/StyleSheetValidation.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  function flattenStyle(style) {
    if (style === null || typeof style !== 'object') {
      return undefined;
    }

    if (!Array.isArray(style)) {
      return style;
    }

    var result = {};

    for (var i = 0, styleLength = style.length; i < styleLength; ++i) {
      var computedStyle = flattenStyle(style[i]);

      if (computedStyle) {
        for (var key in computedStyle) {
          result[key] = computedStyle[key];
        }
      }
    }

    return result;
  }

  module.exports = flattenStyle;
},85,[],"node_modules/react-native/Libraries/StyleSheet/flattenStyle.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  module.exports = _$$_REQUIRE(_dependencyMap[0], "./ViewNativeComponent").default;
},86,[87],"node_modules/react-native/Libraries/Components/View/View.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = exports.__INTERNAL_VIEW_CONFIG = void 0;

  var Platform = _$$_REQUIRE(_dependencyMap[0], "../../Utilities/Platform");

  var ReactNative = _$$_REQUIRE(_dependencyMap[1], "../../Renderer/shims/ReactNative");

  var ReactNativeViewViewConfigAndroid = _$$_REQUIRE(_dependencyMap[2], "./ReactNativeViewViewConfigAndroid");

  var registerGeneratedViewConfig = _$$_REQUIRE(_dependencyMap[3], "../../Utilities/registerGeneratedViewConfig");

  var requireNativeComponent = _$$_REQUIRE(_dependencyMap[4], "../../ReactNative/requireNativeComponent");

  var NativeViewComponent;
  var viewConfig;

  if (__DEV__) {
    if ("android" === 'android') {
      viewConfig = ReactNativeViewViewConfigAndroid;
      registerGeneratedViewConfig('RCTView', ReactNativeViewViewConfigAndroid);
    } else {
      viewConfig = {};
      registerGeneratedViewConfig('RCTView', {
        uiViewClassName: 'RCTView'
      });
    }

    NativeViewComponent = 'RCTView';
  } else {
    NativeViewComponent = requireNativeComponent('RCTView');
  }

  var __INTERNAL_VIEW_CONFIG = viewConfig;
  exports.__INTERNAL_VIEW_CONFIG = __INTERNAL_VIEW_CONFIG;
  var _default = NativeViewComponent;
  exports.default = _default;
},87,[48,88,205,206,218],"node_modules/react-native/Libraries/Components/View/ViewNativeComponent.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var ReactNative;

  if (__DEV__) {
    ReactNative = _$$_REQUIRE(_dependencyMap[0], "../implementations/ReactNativeRenderer-dev");
  } else {
    ReactNative = _$$_REQUIRE(_dependencyMap[1], "../implementations/ReactNativeRenderer-prod");
  }

  module.exports = ReactNative;
},88,[89,204],"node_modules/react-native/Libraries/Renderer/shims/ReactNative.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");

  if (__DEV__) {
    (function () {
      "use strict";

      _$$_REQUIRE(_dependencyMap[1], "react-native/Libraries/ReactPrivate/ReactNativePrivateInitializeCore");

      var ReactNativePrivateInterface = _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface");

      var React = _$$_REQUIRE(_dependencyMap[3], "react");

      var checkPropTypes = _$$_REQUIRE(_dependencyMap[4], "prop-types/checkPropTypes");

      var Scheduler = _$$_REQUIRE(_dependencyMap[5], "scheduler");

      var tracing = _$$_REQUIRE(_dependencyMap[6], "scheduler/tracing");

      function ReactError(error) {
        error.name = "Invariant Violation";
        return error;
      }

      var eventPluginOrder = null;
      var namesToPlugins = {};

      function recomputePluginOrdering() {
        if (!eventPluginOrder) {
          return;
        }

        for (var pluginName in namesToPlugins) {
          var pluginModule = namesToPlugins[pluginName];
          var pluginIndex = eventPluginOrder.indexOf(pluginName);

          (function () {
            if (!(pluginIndex > -1)) {
              throw ReactError(Error("EventPluginRegistry: Cannot inject event plugins that do not exist in the plugin ordering, `" + pluginName + "`."));
            }
          })();

          if (plugins[pluginIndex]) {
            continue;
          }

          (function () {
            if (!pluginModule.extractEvents) {
              throw ReactError(Error("EventPluginRegistry: Event plugins must implement an `extractEvents` method, but `" + pluginName + "` does not."));
            }
          })();

          plugins[pluginIndex] = pluginModule;
          var publishedEvents = pluginModule.eventTypes;

          for (var eventName in publishedEvents) {
            (function () {
              if (!publishEventForPlugin(publishedEvents[eventName], pluginModule, eventName)) {
                throw ReactError(Error("EventPluginRegistry: Failed to publish event `" + eventName + "` for plugin `" + pluginName + "`."));
              }
            })();
          }
        }
      }

      function publishEventForPlugin(dispatchConfig, pluginModule, eventName) {
        (function () {
          if (!!eventNameDispatchConfigs.hasOwnProperty(eventName)) {
            throw ReactError(Error("EventPluginHub: More than one plugin attempted to publish the same event name, `" + eventName + "`."));
          }
        })();

        eventNameDispatchConfigs[eventName] = dispatchConfig;
        var phasedRegistrationNames = dispatchConfig.phasedRegistrationNames;

        if (phasedRegistrationNames) {
          for (var phaseName in phasedRegistrationNames) {
            if (phasedRegistrationNames.hasOwnProperty(phaseName)) {
              var phasedRegistrationName = phasedRegistrationNames[phaseName];
              publishRegistrationName(phasedRegistrationName, pluginModule, eventName);
            }
          }

          return true;
        } else if (dispatchConfig.registrationName) {
          publishRegistrationName(dispatchConfig.registrationName, pluginModule, eventName);
          return true;
        }

        return false;
      }

      function publishRegistrationName(registrationName, pluginModule, eventName) {
        (function () {
          if (!!registrationNameModules[registrationName]) {
            throw ReactError(Error("EventPluginHub: More than one plugin attempted to publish the same registration name, `" + registrationName + "`."));
          }
        })();

        registrationNameModules[registrationName] = pluginModule;
        registrationNameDependencies[registrationName] = pluginModule.eventTypes[eventName].dependencies;
        {
          var lowerCasedName = registrationName.toLowerCase();
        }
      }

      var plugins = [];
      var eventNameDispatchConfigs = {};
      var registrationNameModules = {};
      var registrationNameDependencies = {};

      function injectEventPluginOrder(injectedEventPluginOrder) {
        (function () {
          if (!!eventPluginOrder) {
            throw ReactError(Error("EventPluginRegistry: Cannot inject event plugin ordering more than once. You are likely trying to load more than one copy of React."));
          }
        })();

        eventPluginOrder = Array.prototype.slice.call(injectedEventPluginOrder);
        recomputePluginOrdering();
      }

      function injectEventPluginsByName(injectedNamesToPlugins) {
        var isOrderingDirty = false;

        for (var pluginName in injectedNamesToPlugins) {
          if (!injectedNamesToPlugins.hasOwnProperty(pluginName)) {
            continue;
          }

          var pluginModule = injectedNamesToPlugins[pluginName];

          if (!namesToPlugins.hasOwnProperty(pluginName) || namesToPlugins[pluginName] !== pluginModule) {
            (function () {
              if (!!namesToPlugins[pluginName]) {
                throw ReactError(Error("EventPluginRegistry: Cannot inject two different event plugins using the same name, `" + pluginName + "`."));
              }
            })();

            namesToPlugins[pluginName] = pluginModule;
            isOrderingDirty = true;
          }
        }

        if (isOrderingDirty) {
          recomputePluginOrdering();
        }
      }

      var invokeGuardedCallbackImpl = function invokeGuardedCallbackImpl(name, func, context, a, b, c, d, e, f) {
        var funcArgs = Array.prototype.slice.call(arguments, 3);

        try {
          func.apply(context, funcArgs);
        } catch (error) {
          this.onError(error);
        }
      };

      {
        if (typeof window !== "undefined" && typeof window.dispatchEvent === "function" && typeof document !== "undefined" && typeof document.createEvent === "function") {
          var fakeNode = document.createElement("react");

          var invokeGuardedCallbackDev = function invokeGuardedCallbackDev(name, func, context, a, b, c, d, e, f) {
            (function () {
              if (!(typeof document !== "undefined")) {
                throw ReactError(Error("The `document` global was defined when React was initialized, but is not defined anymore. This can happen in a test environment if a component schedules an update from an asynchronous callback, but the test has already finished running. To solve this, you can either unmount the component at the end of your test (and ensure that any asynchronous operations get canceled in `componentWillUnmount`), or you can change the test itself to be asynchronous."));
              }
            })();

            var evt = document.createEvent("Event");
            var didError = true;
            var windowEvent = window.event;
            var windowEventDescriptor = Object.getOwnPropertyDescriptor(window, "event");
            var funcArgs = Array.prototype.slice.call(arguments, 3);

            function callCallback() {
              fakeNode.removeEventListener(evtType, callCallback, false);

              if (typeof window.event !== "undefined" && window.hasOwnProperty("event")) {
                window.event = windowEvent;
              }

              func.apply(context, funcArgs);
              didError = false;
            }

            var error = void 0;
            var didSetError = false;
            var isCrossOriginError = false;

            function handleWindowError(event) {
              error = event.error;
              didSetError = true;

              if (error === null && event.colno === 0 && event.lineno === 0) {
                isCrossOriginError = true;
              }

              if (event.defaultPrevented) {
                if (error != null && typeof error === "object") {
                  try {
                    error._suppressLogging = true;
                  } catch (inner) {}
                }
              }
            }

            var evtType = "react-" + (name ? name : "invokeguardedcallback");
            window.addEventListener("error", handleWindowError);
            fakeNode.addEventListener(evtType, callCallback, false);
            evt.initEvent(evtType, false, false);
            fakeNode.dispatchEvent(evt);

            if (windowEventDescriptor) {
              Object.defineProperty(window, "event", windowEventDescriptor);
            }

            if (didError) {
              if (!didSetError) {
                error = new Error("An error was thrown inside one of your components, but React " + "doesn't know what it was. This is likely due to browser " + 'flakiness. React does its best to preserve the "Pause on ' + 'exceptions" behavior of the DevTools, which requires some ' + "DEV-mode only tricks. It's possible that these don't work in " + "your browser. Try triggering the error in production mode, " + "or switching to a modern browser. If you suspect that this is " + "actually an issue with React, please file an issue.");
              } else if (isCrossOriginError) {
                error = new Error("A cross-origin error was thrown. React doesn't have access to " + "the actual error object in development. " + "See https://fb.me/react-crossorigin-error for more information.");
              }

              this.onError(error);
            }

            window.removeEventListener("error", handleWindowError);
          };

          invokeGuardedCallbackImpl = invokeGuardedCallbackDev;
        }
      }
      var invokeGuardedCallbackImpl$1 = invokeGuardedCallbackImpl;
      var hasError = false;
      var caughtError = null;
      var hasRethrowError = false;
      var rethrowError = null;
      var reporter = {
        onError: function onError(error) {
          hasError = true;
          caughtError = error;
        }
      };

      function invokeGuardedCallback(name, func, context, a, b, c, d, e, f) {
        hasError = false;
        caughtError = null;
        invokeGuardedCallbackImpl$1.apply(reporter, arguments);
      }

      function invokeGuardedCallbackAndCatchFirstError(name, func, context, a, b, c, d, e, f) {
        invokeGuardedCallback.apply(this, arguments);

        if (hasError) {
          var error = clearCaughtError();

          if (!hasRethrowError) {
            hasRethrowError = true;
            rethrowError = error;
          }
        }
      }

      function rethrowCaughtError() {
        if (hasRethrowError) {
          var error = rethrowError;
          hasRethrowError = false;
          rethrowError = null;
          throw error;
        }
      }

      function hasCaughtError() {
        return hasError;
      }

      function clearCaughtError() {
        if (hasError) {
          var error = caughtError;
          hasError = false;
          caughtError = null;
          return error;
        } else {
          (function () {
            {
              throw ReactError(Error("clearCaughtError was called but no error was captured. This error is likely caused by a bug in React. Please file an issue."));
            }
          })();
        }
      }

      var warningWithoutStack = function warningWithoutStack() {};

      {
        warningWithoutStack = function warningWithoutStack(condition, format) {
          for (var _len = arguments.length, args = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
            args[_key - 2] = arguments[_key];
          }

          if (format === undefined) {
            throw new Error("`warningWithoutStack(condition, format, ...args)` requires a warning " + "message argument");
          }

          if (args.length > 8) {
            throw new Error("warningWithoutStack() currently supports at most 8 arguments.");
          }

          if (condition) {
            return;
          }

          if (typeof console !== "undefined") {
            var argsWithFormat = args.map(function (item) {
              return "" + item;
            });
            argsWithFormat.unshift("Warning: " + format);
            Function.prototype.apply.call(console.error, console, argsWithFormat);
          }

          try {
            var argIndex = 0;
            var message = "Warning: " + format.replace(/%s/g, function () {
              return args[argIndex++];
            });
            throw new Error(message);
          } catch (x) {}
        };
      }
      var warningWithoutStack$1 = warningWithoutStack;
      var getFiberCurrentPropsFromNode = null;
      var getInstanceFromNode = null;
      var getNodeFromInstance = null;

      function setComponentTree(getFiberCurrentPropsFromNodeImpl, getInstanceFromNodeImpl, getNodeFromInstanceImpl) {
        getFiberCurrentPropsFromNode = getFiberCurrentPropsFromNodeImpl;
        getInstanceFromNode = getInstanceFromNodeImpl;
        getNodeFromInstance = getNodeFromInstanceImpl;
        {
          !(getNodeFromInstance && getInstanceFromNode) ? warningWithoutStack$1(false, "EventPluginUtils.setComponentTree(...): Injected " + "module is missing getNodeFromInstance or getInstanceFromNode.") : void 0;
        }
      }

      var validateEventDispatches = void 0;
      {
        validateEventDispatches = function validateEventDispatches(event) {
          var dispatchListeners = event._dispatchListeners;
          var dispatchInstances = event._dispatchInstances;
          var listenersIsArr = Array.isArray(dispatchListeners);
          var listenersLen = listenersIsArr ? dispatchListeners.length : dispatchListeners ? 1 : 0;
          var instancesIsArr = Array.isArray(dispatchInstances);
          var instancesLen = instancesIsArr ? dispatchInstances.length : dispatchInstances ? 1 : 0;
          !(instancesIsArr === listenersIsArr && instancesLen === listenersLen) ? warningWithoutStack$1(false, "EventPluginUtils: Invalid `event`.") : void 0;
        };
      }

      function executeDispatch(event, listener, inst) {
        var type = event.type || "unknown-event";
        event.currentTarget = getNodeFromInstance(inst);
        invokeGuardedCallbackAndCatchFirstError(type, listener, undefined, event);
        event.currentTarget = null;
      }

      function executeDispatchesInOrder(event) {
        var dispatchListeners = event._dispatchListeners;
        var dispatchInstances = event._dispatchInstances;
        {
          validateEventDispatches(event);
        }

        if (Array.isArray(dispatchListeners)) {
          for (var i = 0; i < dispatchListeners.length; i++) {
            if (event.isPropagationStopped()) {
              break;
            }

            executeDispatch(event, dispatchListeners[i], dispatchInstances[i]);
          }
        } else if (dispatchListeners) {
          executeDispatch(event, dispatchListeners, dispatchInstances);
        }

        event._dispatchListeners = null;
        event._dispatchInstances = null;
      }

      function executeDispatchesInOrderStopAtTrueImpl(event) {
        var dispatchListeners = event._dispatchListeners;
        var dispatchInstances = event._dispatchInstances;
        {
          validateEventDispatches(event);
        }

        if (Array.isArray(dispatchListeners)) {
          for (var i = 0; i < dispatchListeners.length; i++) {
            if (event.isPropagationStopped()) {
              break;
            }

            if (dispatchListeners[i](event, dispatchInstances[i])) {
              return dispatchInstances[i];
            }
          }
        } else if (dispatchListeners) {
          if (dispatchListeners(event, dispatchInstances)) {
            return dispatchInstances;
          }
        }

        return null;
      }

      function executeDispatchesInOrderStopAtTrue(event) {
        var ret = executeDispatchesInOrderStopAtTrueImpl(event);
        event._dispatchInstances = null;
        event._dispatchListeners = null;
        return ret;
      }

      function executeDirectDispatch(event) {
        {
          validateEventDispatches(event);
        }
        var dispatchListener = event._dispatchListeners;
        var dispatchInstance = event._dispatchInstances;

        (function () {
          if (!!Array.isArray(dispatchListener)) {
            throw ReactError(Error("executeDirectDispatch(...): Invalid `event`."));
          }
        })();

        event.currentTarget = dispatchListener ? getNodeFromInstance(dispatchInstance) : null;
        var res = dispatchListener ? dispatchListener(event) : null;
        event.currentTarget = null;
        event._dispatchListeners = null;
        event._dispatchInstances = null;
        return res;
      }

      function hasDispatches(event) {
        return !!event._dispatchListeners;
      }

      function accumulateInto(current, next) {
        (function () {
          if (!(next != null)) {
            throw ReactError(Error("accumulateInto(...): Accumulated items must not be null or undefined."));
          }
        })();

        if (current == null) {
          return next;
        }

        if (Array.isArray(current)) {
          if (Array.isArray(next)) {
            current.push.apply(current, next);
            return current;
          }

          current.push(next);
          return current;
        }

        if (Array.isArray(next)) {
          return [current].concat(next);
        }

        return [current, next];
      }

      function forEachAccumulated(arr, cb, scope) {
        if (Array.isArray(arr)) {
          arr.forEach(cb, scope);
        } else if (arr) {
          cb.call(scope, arr);
        }
      }

      var eventQueue = null;

      var executeDispatchesAndRelease = function executeDispatchesAndRelease(event) {
        if (event) {
          executeDispatchesInOrder(event);

          if (!event.isPersistent()) {
            event.constructor.release(event);
          }
        }
      };

      var executeDispatchesAndReleaseTopLevel = function executeDispatchesAndReleaseTopLevel(e) {
        return executeDispatchesAndRelease(e);
      };

      function runEventsInBatch(events) {
        if (events !== null) {
          eventQueue = accumulateInto(eventQueue, events);
        }

        var processingEventQueue = eventQueue;
        eventQueue = null;

        if (!processingEventQueue) {
          return;
        }

        forEachAccumulated(processingEventQueue, executeDispatchesAndReleaseTopLevel);

        (function () {
          if (!!eventQueue) {
            throw ReactError(Error("processEventQueue(): Additional events were enqueued while processing an event queue. Support for this has not yet been implemented."));
          }
        })();

        rethrowCaughtError();
      }

      function isInteractive(tag) {
        return tag === "button" || tag === "input" || tag === "select" || tag === "textarea";
      }

      function shouldPreventMouseEvent(name, type, props) {
        switch (name) {
          case "onClick":
          case "onClickCapture":
          case "onDoubleClick":
          case "onDoubleClickCapture":
          case "onMouseDown":
          case "onMouseDownCapture":
          case "onMouseMove":
          case "onMouseMoveCapture":
          case "onMouseUp":
          case "onMouseUpCapture":
            return !!(props.disabled && isInteractive(type));

          default:
            return false;
        }
      }

      var injection = {
        injectEventPluginOrder: injectEventPluginOrder,
        injectEventPluginsByName: injectEventPluginsByName
      };

      function getListener(inst, registrationName) {
        var listener = void 0;
        var stateNode = inst.stateNode;

        if (!stateNode) {
          return null;
        }

        var props = getFiberCurrentPropsFromNode(stateNode);

        if (!props) {
          return null;
        }

        listener = props[registrationName];

        if (shouldPreventMouseEvent(registrationName, inst.type, props)) {
          return null;
        }

        (function () {
          if (!(!listener || typeof listener === "function")) {
            throw ReactError(Error("Expected `" + registrationName + "` listener to be a function, instead got a value of `" + typeof listener + "` type."));
          }
        })();

        return listener;
      }

      function extractPluginEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
        var events = null;

        for (var i = 0; i < plugins.length; i++) {
          var possiblePlugin = plugins[i];

          if (possiblePlugin) {
            var extractedEvents = possiblePlugin.extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget);

            if (extractedEvents) {
              events = accumulateInto(events, extractedEvents);
            }
          }
        }

        return events;
      }

      function runExtractedPluginEventsInBatch(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
        var events = extractPluginEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget);
        runEventsInBatch(events);
      }

      var FunctionComponent = 0;
      var ClassComponent = 1;
      var IndeterminateComponent = 2;
      var HostRoot = 3;
      var HostPortal = 4;
      var HostComponent = 5;
      var HostText = 6;
      var Fragment = 7;
      var Mode = 8;
      var ContextConsumer = 9;
      var ContextProvider = 10;
      var ForwardRef = 11;
      var Profiler = 12;
      var SuspenseComponent = 13;
      var MemoComponent = 14;
      var SimpleMemoComponent = 15;
      var LazyComponent = 16;
      var IncompleteClassComponent = 17;
      var DehydratedSuspenseComponent = 18;
      var SuspenseListComponent = 19;
      var FundamentalComponent = 20;

      function getParent(inst) {
        do {
          inst = inst.return;
        } while (inst && inst.tag !== HostComponent);

        if (inst) {
          return inst;
        }

        return null;
      }

      function getLowestCommonAncestor(instA, instB) {
        var depthA = 0;

        for (var tempA = instA; tempA; tempA = getParent(tempA)) {
          depthA++;
        }

        var depthB = 0;

        for (var tempB = instB; tempB; tempB = getParent(tempB)) {
          depthB++;
        }

        while (depthA - depthB > 0) {
          instA = getParent(instA);
          depthA--;
        }

        while (depthB - depthA > 0) {
          instB = getParent(instB);
          depthB--;
        }

        var depth = depthA;

        while (depth--) {
          if (instA === instB || instA === instB.alternate) {
            return instA;
          }

          instA = getParent(instA);
          instB = getParent(instB);
        }

        return null;
      }

      function isAncestor(instA, instB) {
        while (instB) {
          if (instA === instB || instA === instB.alternate) {
            return true;
          }

          instB = getParent(instB);
        }

        return false;
      }

      function getParentInstance(inst) {
        return getParent(inst);
      }

      function traverseTwoPhase(inst, fn, arg) {
        var path = [];

        while (inst) {
          path.push(inst);
          inst = getParent(inst);
        }

        var i = void 0;

        for (i = path.length; i-- > 0;) {
          fn(path[i], "captured", arg);
        }

        for (i = 0; i < path.length; i++) {
          fn(path[i], "bubbled", arg);
        }
      }

      function listenerAtPhase(inst, event, propagationPhase) {
        var registrationName = event.dispatchConfig.phasedRegistrationNames[propagationPhase];
        return getListener(inst, registrationName);
      }

      function accumulateDirectionalDispatches(inst, phase, event) {
        {
          !inst ? warningWithoutStack$1(false, "Dispatching inst must not be null") : void 0;
        }
        var listener = listenerAtPhase(inst, event, phase);

        if (listener) {
          event._dispatchListeners = accumulateInto(event._dispatchListeners, listener);
          event._dispatchInstances = accumulateInto(event._dispatchInstances, inst);
        }
      }

      function accumulateTwoPhaseDispatchesSingle(event) {
        if (event && event.dispatchConfig.phasedRegistrationNames) {
          traverseTwoPhase(event._targetInst, accumulateDirectionalDispatches, event);
        }
      }

      function accumulateTwoPhaseDispatchesSingleSkipTarget(event) {
        if (event && event.dispatchConfig.phasedRegistrationNames) {
          var targetInst = event._targetInst;
          var parentInst = targetInst ? getParentInstance(targetInst) : null;
          traverseTwoPhase(parentInst, accumulateDirectionalDispatches, event);
        }
      }

      function accumulateDispatches(inst, ignoredDirection, event) {
        if (inst && event && event.dispatchConfig.registrationName) {
          var registrationName = event.dispatchConfig.registrationName;
          var listener = getListener(inst, registrationName);

          if (listener) {
            event._dispatchListeners = accumulateInto(event._dispatchListeners, listener);
            event._dispatchInstances = accumulateInto(event._dispatchInstances, inst);
          }
        }
      }

      function accumulateDirectDispatchesSingle(event) {
        if (event && event.dispatchConfig.registrationName) {
          accumulateDispatches(event._targetInst, null, event);
        }
      }

      function accumulateTwoPhaseDispatches(events) {
        forEachAccumulated(events, accumulateTwoPhaseDispatchesSingle);
      }

      function accumulateTwoPhaseDispatchesSkipTarget(events) {
        forEachAccumulated(events, accumulateTwoPhaseDispatchesSingleSkipTarget);
      }

      function accumulateDirectDispatches(events) {
        forEachAccumulated(events, accumulateDirectDispatchesSingle);
      }

      var EVENT_POOL_SIZE = 10;
      var EventInterface = {
        type: null,
        target: null,
        currentTarget: function currentTarget() {
          return null;
        },
        eventPhase: null,
        bubbles: null,
        cancelable: null,
        timeStamp: function timeStamp(event) {
          return event.timeStamp || Date.now();
        },
        defaultPrevented: null,
        isTrusted: null
      };

      function functionThatReturnsTrue() {
        return true;
      }

      function functionThatReturnsFalse() {
        return false;
      }

      function SyntheticEvent(dispatchConfig, targetInst, nativeEvent, nativeEventTarget) {
        {
          delete this.nativeEvent;
          delete this.preventDefault;
          delete this.stopPropagation;
          delete this.isDefaultPrevented;
          delete this.isPropagationStopped;
        }
        this.dispatchConfig = dispatchConfig;
        this._targetInst = targetInst;
        this.nativeEvent = nativeEvent;
        var Interface = this.constructor.Interface;

        for (var propName in Interface) {
          if (!Interface.hasOwnProperty(propName)) {
            continue;
          }

          {
            delete this[propName];
          }
          var normalize = Interface[propName];

          if (normalize) {
            this[propName] = normalize(nativeEvent);
          } else {
            if (propName === "target") {
              this.target = nativeEventTarget;
            } else {
              this[propName] = nativeEvent[propName];
            }
          }
        }

        var defaultPrevented = nativeEvent.defaultPrevented != null ? nativeEvent.defaultPrevented : nativeEvent.returnValue === false;

        if (defaultPrevented) {
          this.isDefaultPrevented = functionThatReturnsTrue;
        } else {
          this.isDefaultPrevented = functionThatReturnsFalse;
        }

        this.isPropagationStopped = functionThatReturnsFalse;
        return this;
      }

      _extends(SyntheticEvent.prototype, {
        preventDefault: function preventDefault() {
          this.defaultPrevented = true;
          var event = this.nativeEvent;

          if (!event) {
            return;
          }

          if (event.preventDefault) {
            event.preventDefault();
          } else if (typeof event.returnValue !== "unknown") {
            event.returnValue = false;
          }

          this.isDefaultPrevented = functionThatReturnsTrue;
        },
        stopPropagation: function stopPropagation() {
          var event = this.nativeEvent;

          if (!event) {
            return;
          }

          if (event.stopPropagation) {
            event.stopPropagation();
          } else if (typeof event.cancelBubble !== "unknown") {
            event.cancelBubble = true;
          }

          this.isPropagationStopped = functionThatReturnsTrue;
        },
        persist: function persist() {
          this.isPersistent = functionThatReturnsTrue;
        },
        isPersistent: functionThatReturnsFalse,
        destructor: function destructor() {
          var Interface = this.constructor.Interface;

          for (var propName in Interface) {
            {
              Object.defineProperty(this, propName, getPooledWarningPropertyDefinition(propName, Interface[propName]));
            }
          }

          this.dispatchConfig = null;
          this._targetInst = null;
          this.nativeEvent = null;
          this.isDefaultPrevented = functionThatReturnsFalse;
          this.isPropagationStopped = functionThatReturnsFalse;
          this._dispatchListeners = null;
          this._dispatchInstances = null;
          {
            Object.defineProperty(this, "nativeEvent", getPooledWarningPropertyDefinition("nativeEvent", null));
            Object.defineProperty(this, "isDefaultPrevented", getPooledWarningPropertyDefinition("isDefaultPrevented", functionThatReturnsFalse));
            Object.defineProperty(this, "isPropagationStopped", getPooledWarningPropertyDefinition("isPropagationStopped", functionThatReturnsFalse));
            Object.defineProperty(this, "preventDefault", getPooledWarningPropertyDefinition("preventDefault", function () {}));
            Object.defineProperty(this, "stopPropagation", getPooledWarningPropertyDefinition("stopPropagation", function () {}));
          }
        }
      });

      SyntheticEvent.Interface = EventInterface;

      SyntheticEvent.extend = function (Interface) {
        var Super = this;

        var E = function E() {};

        E.prototype = Super.prototype;
        var prototype = new E();

        function Class() {
          return Super.apply(this, arguments);
        }

        _extends(prototype, Class.prototype);

        Class.prototype = prototype;
        Class.prototype.constructor = Class;
        Class.Interface = _extends({}, Super.Interface, Interface);
        Class.extend = Super.extend;
        addEventPoolingTo(Class);
        return Class;
      };

      addEventPoolingTo(SyntheticEvent);

      function getPooledWarningPropertyDefinition(propName, getVal) {
        var isFunction = typeof getVal === "function";
        return {
          configurable: true,
          set: set,
          get: get
        };

        function set(val) {
          var action = isFunction ? "setting the method" : "setting the property";
          warn(action, "This is effectively a no-op");
          return val;
        }

        function get() {
          var action = isFunction ? "accessing the method" : "accessing the property";
          var result = isFunction ? "This is a no-op function" : "This is set to null";
          warn(action, result);
          return getVal;
        }

        function warn(action, result) {
          var warningCondition = false;
          !warningCondition ? warningWithoutStack$1(false, "This synthetic event is reused for performance reasons. If you're seeing this, " + "you're %s `%s` on a released/nullified synthetic event. %s. " + "If you must keep the original synthetic event around, use event.persist(). " + "See https://fb.me/react-event-pooling for more information.", action, propName, result) : void 0;
        }
      }

      function getPooledEvent(dispatchConfig, targetInst, nativeEvent, nativeInst) {
        var EventConstructor = this;

        if (EventConstructor.eventPool.length) {
          var instance = EventConstructor.eventPool.pop();
          EventConstructor.call(instance, dispatchConfig, targetInst, nativeEvent, nativeInst);
          return instance;
        }

        return new EventConstructor(dispatchConfig, targetInst, nativeEvent, nativeInst);
      }

      function releasePooledEvent(event) {
        var EventConstructor = this;

        (function () {
          if (!(event instanceof EventConstructor)) {
            throw ReactError(Error("Trying to release an event instance into a pool of a different type."));
          }
        })();

        event.destructor();

        if (EventConstructor.eventPool.length < EVENT_POOL_SIZE) {
          EventConstructor.eventPool.push(event);
        }
      }

      function addEventPoolingTo(EventConstructor) {
        EventConstructor.eventPool = [];
        EventConstructor.getPooled = getPooledEvent;
        EventConstructor.release = releasePooledEvent;
      }

      var ResponderSyntheticEvent = SyntheticEvent.extend({
        touchHistory: function touchHistory(nativeEvent) {
          return null;
        }
      });
      var TOP_TOUCH_START = "topTouchStart";
      var TOP_TOUCH_MOVE = "topTouchMove";
      var TOP_TOUCH_END = "topTouchEnd";
      var TOP_TOUCH_CANCEL = "topTouchCancel";
      var TOP_SCROLL = "topScroll";
      var TOP_SELECTION_CHANGE = "topSelectionChange";

      function isStartish(topLevelType) {
        return topLevelType === TOP_TOUCH_START;
      }

      function isMoveish(topLevelType) {
        return topLevelType === TOP_TOUCH_MOVE;
      }

      function isEndish(topLevelType) {
        return topLevelType === TOP_TOUCH_END || topLevelType === TOP_TOUCH_CANCEL;
      }

      var startDependencies = [TOP_TOUCH_START];
      var moveDependencies = [TOP_TOUCH_MOVE];
      var endDependencies = [TOP_TOUCH_CANCEL, TOP_TOUCH_END];
      var MAX_TOUCH_BANK = 20;
      var touchBank = [];
      var touchHistory = {
        touchBank: touchBank,
        numberActiveTouches: 0,
        indexOfSingleActiveTouch: -1,
        mostRecentTimeStamp: 0
      };

      function timestampForTouch(touch) {
        return touch.timeStamp || touch.timestamp;
      }

      function createTouchRecord(touch) {
        return {
          touchActive: true,
          startPageX: touch.pageX,
          startPageY: touch.pageY,
          startTimeStamp: timestampForTouch(touch),
          currentPageX: touch.pageX,
          currentPageY: touch.pageY,
          currentTimeStamp: timestampForTouch(touch),
          previousPageX: touch.pageX,
          previousPageY: touch.pageY,
          previousTimeStamp: timestampForTouch(touch)
        };
      }

      function resetTouchRecord(touchRecord, touch) {
        touchRecord.touchActive = true;
        touchRecord.startPageX = touch.pageX;
        touchRecord.startPageY = touch.pageY;
        touchRecord.startTimeStamp = timestampForTouch(touch);
        touchRecord.currentPageX = touch.pageX;
        touchRecord.currentPageY = touch.pageY;
        touchRecord.currentTimeStamp = timestampForTouch(touch);
        touchRecord.previousPageX = touch.pageX;
        touchRecord.previousPageY = touch.pageY;
        touchRecord.previousTimeStamp = timestampForTouch(touch);
      }

      function getTouchIdentifier(_ref) {
        var identifier = _ref.identifier;

        (function () {
          if (!(identifier != null)) {
            throw ReactError(Error("Touch object is missing identifier."));
          }
        })();

        {
          !(identifier <= MAX_TOUCH_BANK) ? warningWithoutStack$1(false, "Touch identifier %s is greater than maximum supported %s which causes " + "performance issues backfilling array locations for all of the indices.", identifier, MAX_TOUCH_BANK) : void 0;
        }
        return identifier;
      }

      function recordTouchStart(touch) {
        var identifier = getTouchIdentifier(touch);
        var touchRecord = touchBank[identifier];

        if (touchRecord) {
          resetTouchRecord(touchRecord, touch);
        } else {
          touchBank[identifier] = createTouchRecord(touch);
        }

        touchHistory.mostRecentTimeStamp = timestampForTouch(touch);
      }

      function recordTouchMove(touch) {
        var touchRecord = touchBank[getTouchIdentifier(touch)];

        if (touchRecord) {
          touchRecord.touchActive = true;
          touchRecord.previousPageX = touchRecord.currentPageX;
          touchRecord.previousPageY = touchRecord.currentPageY;
          touchRecord.previousTimeStamp = touchRecord.currentTimeStamp;
          touchRecord.currentPageX = touch.pageX;
          touchRecord.currentPageY = touch.pageY;
          touchRecord.currentTimeStamp = timestampForTouch(touch);
          touchHistory.mostRecentTimeStamp = timestampForTouch(touch);
        } else {
          console.warn("Cannot record touch move without a touch start.\n" + "Touch Move: %s\n", "Touch Bank: %s", printTouch(touch), printTouchBank());
        }
      }

      function recordTouchEnd(touch) {
        var touchRecord = touchBank[getTouchIdentifier(touch)];

        if (touchRecord) {
          touchRecord.touchActive = false;
          touchRecord.previousPageX = touchRecord.currentPageX;
          touchRecord.previousPageY = touchRecord.currentPageY;
          touchRecord.previousTimeStamp = touchRecord.currentTimeStamp;
          touchRecord.currentPageX = touch.pageX;
          touchRecord.currentPageY = touch.pageY;
          touchRecord.currentTimeStamp = timestampForTouch(touch);
          touchHistory.mostRecentTimeStamp = timestampForTouch(touch);
        } else {
          console.warn("Cannot record touch end without a touch start.\n" + "Touch End: %s\n", "Touch Bank: %s", printTouch(touch), printTouchBank());
        }
      }

      function printTouch(touch) {
        return JSON.stringify({
          identifier: touch.identifier,
          pageX: touch.pageX,
          pageY: touch.pageY,
          timestamp: timestampForTouch(touch)
        });
      }

      function printTouchBank() {
        var printed = JSON.stringify(touchBank.slice(0, MAX_TOUCH_BANK));

        if (touchBank.length > MAX_TOUCH_BANK) {
          printed += " (original size: " + touchBank.length + ")";
        }

        return printed;
      }

      var ResponderTouchHistoryStore = {
        recordTouchTrack: function recordTouchTrack(topLevelType, nativeEvent) {
          if (isMoveish(topLevelType)) {
            nativeEvent.changedTouches.forEach(recordTouchMove);
          } else if (isStartish(topLevelType)) {
            nativeEvent.changedTouches.forEach(recordTouchStart);
            touchHistory.numberActiveTouches = nativeEvent.touches.length;

            if (touchHistory.numberActiveTouches === 1) {
              touchHistory.indexOfSingleActiveTouch = nativeEvent.touches[0].identifier;
            }
          } else if (isEndish(topLevelType)) {
            nativeEvent.changedTouches.forEach(recordTouchEnd);
            touchHistory.numberActiveTouches = nativeEvent.touches.length;

            if (touchHistory.numberActiveTouches === 1) {
              for (var i = 0; i < touchBank.length; i++) {
                var touchTrackToCheck = touchBank[i];

                if (touchTrackToCheck != null && touchTrackToCheck.touchActive) {
                  touchHistory.indexOfSingleActiveTouch = i;
                  break;
                }
              }

              {
                var activeRecord = touchBank[touchHistory.indexOfSingleActiveTouch];
                !(activeRecord != null && activeRecord.touchActive) ? warningWithoutStack$1(false, "Cannot find single active touch.") : void 0;
              }
            }
          }
        },
        touchHistory: touchHistory
      };

      function accumulate(current, next) {
        (function () {
          if (!(next != null)) {
            throw ReactError(Error("accumulate(...): Accumulated items must not be null or undefined."));
          }
        })();

        if (current == null) {
          return next;
        }

        if (Array.isArray(current)) {
          return current.concat(next);
        }

        if (Array.isArray(next)) {
          return [current].concat(next);
        }

        return [current, next];
      }

      var responderInst = null;
      var trackedTouchCount = 0;

      var changeResponder = function changeResponder(nextResponderInst, blockHostResponder) {
        var oldResponderInst = responderInst;
        responderInst = nextResponderInst;

        if (ResponderEventPlugin.GlobalResponderHandler !== null) {
          ResponderEventPlugin.GlobalResponderHandler.onChange(oldResponderInst, nextResponderInst, blockHostResponder);
        }
      };

      var eventTypes = {
        startShouldSetResponder: {
          phasedRegistrationNames: {
            bubbled: "onStartShouldSetResponder",
            captured: "onStartShouldSetResponderCapture"
          },
          dependencies: startDependencies
        },
        scrollShouldSetResponder: {
          phasedRegistrationNames: {
            bubbled: "onScrollShouldSetResponder",
            captured: "onScrollShouldSetResponderCapture"
          },
          dependencies: [TOP_SCROLL]
        },
        selectionChangeShouldSetResponder: {
          phasedRegistrationNames: {
            bubbled: "onSelectionChangeShouldSetResponder",
            captured: "onSelectionChangeShouldSetResponderCapture"
          },
          dependencies: [TOP_SELECTION_CHANGE]
        },
        moveShouldSetResponder: {
          phasedRegistrationNames: {
            bubbled: "onMoveShouldSetResponder",
            captured: "onMoveShouldSetResponderCapture"
          },
          dependencies: moveDependencies
        },
        responderStart: {
          registrationName: "onResponderStart",
          dependencies: startDependencies
        },
        responderMove: {
          registrationName: "onResponderMove",
          dependencies: moveDependencies
        },
        responderEnd: {
          registrationName: "onResponderEnd",
          dependencies: endDependencies
        },
        responderRelease: {
          registrationName: "onResponderRelease",
          dependencies: endDependencies
        },
        responderTerminationRequest: {
          registrationName: "onResponderTerminationRequest",
          dependencies: []
        },
        responderGrant: {
          registrationName: "onResponderGrant",
          dependencies: []
        },
        responderReject: {
          registrationName: "onResponderReject",
          dependencies: []
        },
        responderTerminate: {
          registrationName: "onResponderTerminate",
          dependencies: []
        }
      };

      function setResponderAndExtractTransfer(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
        var shouldSetEventType = isStartish(topLevelType) ? eventTypes.startShouldSetResponder : isMoveish(topLevelType) ? eventTypes.moveShouldSetResponder : topLevelType === TOP_SELECTION_CHANGE ? eventTypes.selectionChangeShouldSetResponder : eventTypes.scrollShouldSetResponder;
        var bubbleShouldSetFrom = !responderInst ? targetInst : getLowestCommonAncestor(responderInst, targetInst);
        var skipOverBubbleShouldSetFrom = bubbleShouldSetFrom === responderInst;
        var shouldSetEvent = ResponderSyntheticEvent.getPooled(shouldSetEventType, bubbleShouldSetFrom, nativeEvent, nativeEventTarget);
        shouldSetEvent.touchHistory = ResponderTouchHistoryStore.touchHistory;

        if (skipOverBubbleShouldSetFrom) {
          accumulateTwoPhaseDispatchesSkipTarget(shouldSetEvent);
        } else {
          accumulateTwoPhaseDispatches(shouldSetEvent);
        }

        var wantsResponderInst = executeDispatchesInOrderStopAtTrue(shouldSetEvent);

        if (!shouldSetEvent.isPersistent()) {
          shouldSetEvent.constructor.release(shouldSetEvent);
        }

        if (!wantsResponderInst || wantsResponderInst === responderInst) {
          return null;
        }

        var extracted = void 0;
        var grantEvent = ResponderSyntheticEvent.getPooled(eventTypes.responderGrant, wantsResponderInst, nativeEvent, nativeEventTarget);
        grantEvent.touchHistory = ResponderTouchHistoryStore.touchHistory;
        accumulateDirectDispatches(grantEvent);
        var blockHostResponder = executeDirectDispatch(grantEvent) === true;

        if (responderInst) {
          var terminationRequestEvent = ResponderSyntheticEvent.getPooled(eventTypes.responderTerminationRequest, responderInst, nativeEvent, nativeEventTarget);
          terminationRequestEvent.touchHistory = ResponderTouchHistoryStore.touchHistory;
          accumulateDirectDispatches(terminationRequestEvent);
          var shouldSwitch = !hasDispatches(terminationRequestEvent) || executeDirectDispatch(terminationRequestEvent);

          if (!terminationRequestEvent.isPersistent()) {
            terminationRequestEvent.constructor.release(terminationRequestEvent);
          }

          if (shouldSwitch) {
            var terminateEvent = ResponderSyntheticEvent.getPooled(eventTypes.responderTerminate, responderInst, nativeEvent, nativeEventTarget);
            terminateEvent.touchHistory = ResponderTouchHistoryStore.touchHistory;
            accumulateDirectDispatches(terminateEvent);
            extracted = accumulate(extracted, [grantEvent, terminateEvent]);
            changeResponder(wantsResponderInst, blockHostResponder);
          } else {
            var rejectEvent = ResponderSyntheticEvent.getPooled(eventTypes.responderReject, wantsResponderInst, nativeEvent, nativeEventTarget);
            rejectEvent.touchHistory = ResponderTouchHistoryStore.touchHistory;
            accumulateDirectDispatches(rejectEvent);
            extracted = accumulate(extracted, rejectEvent);
          }
        } else {
          extracted = accumulate(extracted, grantEvent);
          changeResponder(wantsResponderInst, blockHostResponder);
        }

        return extracted;
      }

      function canTriggerTransfer(topLevelType, topLevelInst, nativeEvent) {
        return topLevelInst && (topLevelType === TOP_SCROLL && !nativeEvent.responderIgnoreScroll || trackedTouchCount > 0 && topLevelType === TOP_SELECTION_CHANGE || isStartish(topLevelType) || isMoveish(topLevelType));
      }

      function noResponderTouches(nativeEvent) {
        var touches = nativeEvent.touches;

        if (!touches || touches.length === 0) {
          return true;
        }

        for (var i = 0; i < touches.length; i++) {
          var activeTouch = touches[i];
          var target = activeTouch.target;

          if (target !== null && target !== undefined && target !== 0) {
            var targetInst = getInstanceFromNode(target);

            if (isAncestor(responderInst, targetInst)) {
              return false;
            }
          }
        }

        return true;
      }

      var ResponderEventPlugin = {
        _getResponder: function _getResponder() {
          return responderInst;
        },
        eventTypes: eventTypes,
        extractEvents: function extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
          if (isStartish(topLevelType)) {
            trackedTouchCount += 1;
          } else if (isEndish(topLevelType)) {
            if (trackedTouchCount >= 0) {
              trackedTouchCount -= 1;
            } else {
              console.error("Ended a touch event which was not counted in `trackedTouchCount`.");
              return null;
            }
          }

          ResponderTouchHistoryStore.recordTouchTrack(topLevelType, nativeEvent);
          var extracted = canTriggerTransfer(topLevelType, targetInst, nativeEvent) ? setResponderAndExtractTransfer(topLevelType, targetInst, nativeEvent, nativeEventTarget) : null;
          var isResponderTouchStart = responderInst && isStartish(topLevelType);
          var isResponderTouchMove = responderInst && isMoveish(topLevelType);
          var isResponderTouchEnd = responderInst && isEndish(topLevelType);
          var incrementalTouch = isResponderTouchStart ? eventTypes.responderStart : isResponderTouchMove ? eventTypes.responderMove : isResponderTouchEnd ? eventTypes.responderEnd : null;

          if (incrementalTouch) {
            var gesture = ResponderSyntheticEvent.getPooled(incrementalTouch, responderInst, nativeEvent, nativeEventTarget);
            gesture.touchHistory = ResponderTouchHistoryStore.touchHistory;
            accumulateDirectDispatches(gesture);
            extracted = accumulate(extracted, gesture);
          }

          var isResponderTerminate = responderInst && topLevelType === TOP_TOUCH_CANCEL;
          var isResponderRelease = responderInst && !isResponderTerminate && isEndish(topLevelType) && noResponderTouches(nativeEvent);
          var finalTouch = isResponderTerminate ? eventTypes.responderTerminate : isResponderRelease ? eventTypes.responderRelease : null;

          if (finalTouch) {
            var finalEvent = ResponderSyntheticEvent.getPooled(finalTouch, responderInst, nativeEvent, nativeEventTarget);
            finalEvent.touchHistory = ResponderTouchHistoryStore.touchHistory;
            accumulateDirectDispatches(finalEvent);
            extracted = accumulate(extracted, finalEvent);
            changeResponder(null);
          }

          return extracted;
        },
        GlobalResponderHandler: null,
        injection: {
          injectGlobalResponderHandler: function injectGlobalResponderHandler(GlobalResponderHandler) {
            ResponderEventPlugin.GlobalResponderHandler = GlobalResponderHandler;
          }
        }
      };
      var customBubblingEventTypes = ReactNativePrivateInterface.ReactNativeViewConfigRegistry.customBubblingEventTypes;
      var customDirectEventTypes = ReactNativePrivateInterface.ReactNativeViewConfigRegistry.customDirectEventTypes;
      var ReactNativeBridgeEventPlugin = {
        eventTypes: {},
        extractEvents: function extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
          if (targetInst == null) {
            return null;
          }

          var bubbleDispatchConfig = customBubblingEventTypes[topLevelType];
          var directDispatchConfig = customDirectEventTypes[topLevelType];

          (function () {
            if (!(bubbleDispatchConfig || directDispatchConfig)) {
              throw ReactError(Error('Unsupported top level event type "' + topLevelType + '" dispatched'));
            }
          })();

          var event = SyntheticEvent.getPooled(bubbleDispatchConfig || directDispatchConfig, targetInst, nativeEvent, nativeEventTarget);

          if (bubbleDispatchConfig) {
            accumulateTwoPhaseDispatches(event);
          } else if (directDispatchConfig) {
            accumulateDirectDispatches(event);
          } else {
            return null;
          }

          return event;
        }
      };
      var ReactNativeEventPluginOrder = ["ResponderEventPlugin", "ReactNativeBridgeEventPlugin"];
      injection.injectEventPluginOrder(ReactNativeEventPluginOrder);
      injection.injectEventPluginsByName({
        ResponderEventPlugin: ResponderEventPlugin,
        ReactNativeBridgeEventPlugin: ReactNativeBridgeEventPlugin
      });
      var instanceCache = new Map();
      var instanceProps = new Map();

      function precacheFiberNode(hostInst, tag) {
        instanceCache.set(tag, hostInst);
      }

      function uncacheFiberNode(tag) {
        instanceCache.delete(tag);
        instanceProps.delete(tag);
      }

      function getInstanceFromTag(tag) {
        return instanceCache.get(tag) || null;
      }

      function getTagFromInstance(inst) {
        var tag = inst.stateNode._nativeTag;

        if (tag === undefined) {
          tag = inst.stateNode.canonical._nativeTag;
        }

        (function () {
          if (!tag) {
            throw ReactError(Error("All native instances should have a tag."));
          }
        })();

        return tag;
      }

      function getFiberCurrentPropsFromNode$1(stateNode) {
        return instanceProps.get(stateNode._nativeTag) || null;
      }

      function updateFiberProps(tag, props) {
        instanceProps.set(tag, props);
      }

      var restoreImpl = null;
      var restoreTarget = null;
      var restoreQueue = null;

      function restoreStateOfTarget(target) {
        var internalInstance = getInstanceFromNode(target);

        if (!internalInstance) {
          return;
        }

        (function () {
          if (!(typeof restoreImpl === "function")) {
            throw ReactError(Error("setRestoreImplementation() needs to be called to handle a target for controlled events. This error is likely caused by a bug in React. Please file an issue."));
          }
        })();

        var props = getFiberCurrentPropsFromNode(internalInstance.stateNode);
        restoreImpl(internalInstance.stateNode, internalInstance.type, props);
      }

      function needsStateRestore() {
        return restoreTarget !== null || restoreQueue !== null;
      }

      function restoreStateIfNeeded() {
        if (!restoreTarget) {
          return;
        }

        var target = restoreTarget;
        var queuedTargets = restoreQueue;
        restoreTarget = null;
        restoreQueue = null;
        restoreStateOfTarget(target);

        if (queuedTargets) {
          for (var i = 0; i < queuedTargets.length; i++) {
            restoreStateOfTarget(queuedTargets[i]);
          }
        }
      }

      var debugRenderPhaseSideEffects = false;
      var debugRenderPhaseSideEffectsForStrictMode = false;
      var enableUserTimingAPI = true;
      var replayFailedUnitOfWorkWithInvokeGuardedCallback = true;
      var warnAboutDeprecatedLifecycles = true;
      var enableProfilerTimer = true;
      var enableSchedulerTracing = true;
      var enableSuspenseServerRenderer = false;
      var warnAboutDeprecatedSetNativeProps = false;
      var enableFlareAPI = false;
      var enableFundamentalAPI = false;
      var warnAboutUnmockedScheduler = false;
      var revertPassiveEffectsChange = false;
      var flushSuspenseFallbacksInTests = true;
      var enableSuspenseCallback = false;
      var warnAboutDefaultPropsOnFunctionComponents = false;
      var warnAboutStringRefs = false;
      var disableLegacyContext = false;
      var disableSchedulerTimeoutBasedOnReactExpirationTime = false;

      var batchedUpdatesImpl = function batchedUpdatesImpl(fn, bookkeeping) {
        return fn(bookkeeping);
      };

      var flushDiscreteUpdatesImpl = function flushDiscreteUpdatesImpl() {};

      var isInsideEventHandler = false;

      function finishEventHandler() {
        var controlledComponentsHavePendingUpdates = needsStateRestore();

        if (controlledComponentsHavePendingUpdates) {
          flushDiscreteUpdatesImpl();
          restoreStateIfNeeded();
        }
      }

      function batchedUpdates(fn, bookkeeping) {
        if (isInsideEventHandler) {
          return fn(bookkeeping);
        }

        isInsideEventHandler = true;

        try {
          return batchedUpdatesImpl(fn, bookkeeping);
        } finally {
          isInsideEventHandler = false;
          finishEventHandler();
        }
      }

      function setBatchingImplementation(_batchedUpdatesImpl, _discreteUpdatesImpl, _flushDiscreteUpdatesImpl, _batchedEventUpdatesImpl) {
        batchedUpdatesImpl = _batchedUpdatesImpl;
        flushDiscreteUpdatesImpl = _flushDiscreteUpdatesImpl;
      }

      var EMPTY_NATIVE_EVENT = {};

      var touchSubsequence = function touchSubsequence(touches, indices) {
        var ret = [];

        for (var i = 0; i < indices.length; i++) {
          ret.push(touches[indices[i]]);
        }

        return ret;
      };

      var removeTouchesAtIndices = function removeTouchesAtIndices(touches, indices) {
        var rippedOut = [];
        var temp = touches;

        for (var i = 0; i < indices.length; i++) {
          var index = indices[i];
          rippedOut.push(touches[index]);
          temp[index] = null;
        }

        var fillAt = 0;

        for (var j = 0; j < temp.length; j++) {
          var cur = temp[j];

          if (cur !== null) {
            temp[fillAt++] = cur;
          }
        }

        temp.length = fillAt;
        return rippedOut;
      };

      function _receiveRootNodeIDEvent(rootNodeID, topLevelType, nativeEventParam) {
        var nativeEvent = nativeEventParam || EMPTY_NATIVE_EVENT;
        var inst = getInstanceFromTag(rootNodeID);
        batchedUpdates(function () {
          runExtractedPluginEventsInBatch(topLevelType, inst, nativeEvent, nativeEvent.target);
        });
      }

      function receiveEvent(rootNodeID, topLevelType, nativeEventParam) {
        _receiveRootNodeIDEvent(rootNodeID, topLevelType, nativeEventParam);
      }

      function receiveTouches(eventTopLevelType, touches, changedIndices) {
        var changedTouches = eventTopLevelType === "topTouchEnd" || eventTopLevelType === "topTouchCancel" ? removeTouchesAtIndices(touches, changedIndices) : touchSubsequence(touches, changedIndices);

        for (var jj = 0; jj < changedTouches.length; jj++) {
          var touch = changedTouches[jj];
          touch.changedTouches = changedTouches;
          touch.touches = touches;
          var nativeEvent = touch;
          var rootNodeID = null;
          var target = nativeEvent.target;

          if (target !== null && target !== undefined) {
            if (target < 1) {
              {
                warningWithoutStack$1(false, "A view is reporting that a touch occurred on tag zero.");
              }
            } else {
              rootNodeID = target;
            }
          }

          _receiveRootNodeIDEvent(rootNodeID, eventTopLevelType, nativeEvent);
        }
      }

      var ReactNativeGlobalResponderHandler = {
        onChange: function onChange(from, to, blockNativeResponder) {
          if (to !== null) {
            var tag = to.stateNode._nativeTag;
            ReactNativePrivateInterface.UIManager.setJSResponder(tag, blockNativeResponder);
          } else {
            ReactNativePrivateInterface.UIManager.clearJSResponder();
          }
        }
      };
      ReactNativePrivateInterface.RCTEventEmitter.register({
        receiveEvent: receiveEvent,
        receiveTouches: receiveTouches
      });
      setComponentTree(getFiberCurrentPropsFromNode$1, getInstanceFromTag, getTagFromInstance);
      ResponderEventPlugin.injection.injectGlobalResponderHandler(ReactNativeGlobalResponderHandler);

      function get(key) {
        return key._reactInternalFiber;
      }

      function set(key, value) {
        key._reactInternalFiber = value;
      }

      var ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;

      if (!ReactSharedInternals.hasOwnProperty("ReactCurrentDispatcher")) {
        ReactSharedInternals.ReactCurrentDispatcher = {
          current: null
        };
      }

      if (!ReactSharedInternals.hasOwnProperty("ReactCurrentBatchConfig")) {
        ReactSharedInternals.ReactCurrentBatchConfig = {
          suspense: null
        };
      }

      var hasSymbol = typeof Symbol === "function" && (typeof Symbol === "function" ? Symbol.for : "@@for");
      var REACT_ELEMENT_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.element") : 0xeac7;
      var REACT_PORTAL_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.portal") : 0xeaca;
      var REACT_FRAGMENT_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.fragment") : 0xeacb;
      var REACT_STRICT_MODE_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.strict_mode") : 0xeacc;
      var REACT_PROFILER_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.profiler") : 0xead2;
      var REACT_PROVIDER_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.provider") : 0xeacd;
      var REACT_CONTEXT_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.context") : 0xeace;
      var REACT_CONCURRENT_MODE_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.concurrent_mode") : 0xeacf;
      var REACT_FORWARD_REF_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.forward_ref") : 0xead0;
      var REACT_SUSPENSE_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.suspense") : 0xead1;
      var REACT_SUSPENSE_LIST_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.suspense_list") : 0xead8;
      var REACT_MEMO_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.memo") : 0xead3;
      var REACT_LAZY_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.lazy") : 0xead4;
      var REACT_FUNDAMENTAL_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.fundamental") : 0xead5;
      var REACT_RESPONDER_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.responder") : 0xead6;
      var MAYBE_ITERATOR_SYMBOL = typeof Symbol === "function" && (typeof Symbol === "function" ? Symbol.iterator : "@@iterator");
      var FAUX_ITERATOR_SYMBOL = "@@iterator";

      function getIteratorFn(maybeIterable) {
        if (maybeIterable === null || typeof maybeIterable !== "object") {
          return null;
        }

        var maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];

        if (typeof maybeIterator === "function") {
          return maybeIterator;
        }

        return null;
      }

      var Pending = 0;
      var Resolved = 1;
      var Rejected = 2;

      function refineResolvedLazyComponent(lazyComponent) {
        return lazyComponent._status === Resolved ? lazyComponent._result : null;
      }

      function getWrappedName(outerType, innerType, wrapperName) {
        var functionName = innerType.displayName || innerType.name || "";
        return outerType.displayName || (functionName !== "" ? wrapperName + "(" + functionName + ")" : wrapperName);
      }

      function getComponentName(type) {
        if (type == null) {
          return null;
        }

        {
          if (typeof type.tag === "number") {
            warningWithoutStack$1(false, "Received an unexpected object in getComponentName(). " + "This is likely a bug in React. Please file an issue.");
          }
        }

        if (typeof type === "function") {
          return type.displayName || type.name || null;
        }

        if (typeof type === "string") {
          return type;
        }

        switch (type) {
          case REACT_FRAGMENT_TYPE:
            return "Fragment";

          case REACT_PORTAL_TYPE:
            return "Portal";

          case REACT_PROFILER_TYPE:
            return "Profiler";

          case REACT_STRICT_MODE_TYPE:
            return "StrictMode";

          case REACT_SUSPENSE_TYPE:
            return "Suspense";

          case REACT_SUSPENSE_LIST_TYPE:
            return "SuspenseList";
        }

        if (typeof type === "object") {
          switch (type.$$typeof) {
            case REACT_CONTEXT_TYPE:
              return "Context.Consumer";

            case REACT_PROVIDER_TYPE:
              return "Context.Provider";

            case REACT_FORWARD_REF_TYPE:
              return getWrappedName(type, type.render, "ForwardRef");

            case REACT_MEMO_TYPE:
              return getComponentName(type.type);

            case REACT_LAZY_TYPE:
              {
                var thenable = type;
                var resolvedThenable = refineResolvedLazyComponent(thenable);

                if (resolvedThenable) {
                  return getComponentName(resolvedThenable);
                }

                break;
              }
          }
        }

        return null;
      }

      var NoEffect = 0;
      var PerformedWork = 1;
      var Placement = 2;
      var Update = 4;
      var PlacementAndUpdate = 6;
      var Deletion = 8;
      var ContentReset = 16;
      var Callback = 32;
      var DidCapture = 64;
      var Ref = 128;
      var Snapshot = 256;
      var Passive = 512;
      var LifecycleEffectMask = 932;
      var HostEffectMask = 1023;
      var Incomplete = 1024;
      var ShouldCapture = 2048;
      var ReactCurrentOwner$1 = ReactSharedInternals.ReactCurrentOwner;
      var MOUNTING = 1;
      var MOUNTED = 2;
      var UNMOUNTED = 3;

      function isFiberMountedImpl(fiber) {
        var node = fiber;

        if (!fiber.alternate) {
          if ((node.effectTag & Placement) !== NoEffect) {
            return MOUNTING;
          }

          while (node.return) {
            node = node.return;

            if ((node.effectTag & Placement) !== NoEffect) {
              return MOUNTING;
            }
          }
        } else {
          while (node.return) {
            node = node.return;
          }
        }

        if (node.tag === HostRoot) {
          return MOUNTED;
        }

        return UNMOUNTED;
      }

      function isFiberMounted(fiber) {
        return isFiberMountedImpl(fiber) === MOUNTED;
      }

      function isMounted(component) {
        {
          var owner = ReactCurrentOwner$1.current;

          if (owner !== null && owner.tag === ClassComponent) {
            var ownerFiber = owner;
            var instance = ownerFiber.stateNode;
            !instance._warnedAboutRefsInRender ? warningWithoutStack$1(false, "%s is accessing isMounted inside its render() function. " + "render() should be a pure function of props and state. It should " + "never access something that requires stale data from the previous " + "render, such as refs. Move this logic to componentDidMount and " + "componentDidUpdate instead.", getComponentName(ownerFiber.type) || "A component") : void 0;
            instance._warnedAboutRefsInRender = true;
          }
        }
        var fiber = get(component);

        if (!fiber) {
          return false;
        }

        return isFiberMountedImpl(fiber) === MOUNTED;
      }

      function assertIsMounted(fiber) {
        (function () {
          if (!(isFiberMountedImpl(fiber) === MOUNTED)) {
            throw ReactError(Error("Unable to find node on an unmounted component."));
          }
        })();
      }

      function findCurrentFiberUsingSlowPath(fiber) {
        var alternate = fiber.alternate;

        if (!alternate) {
          var state = isFiberMountedImpl(fiber);

          (function () {
            if (!(state !== UNMOUNTED)) {
              throw ReactError(Error("Unable to find node on an unmounted component."));
            }
          })();

          if (state === MOUNTING) {
            return null;
          }

          return fiber;
        }

        var a = fiber;
        var b = alternate;

        while (true) {
          var parentA = a.return;

          if (parentA === null) {
            break;
          }

          var parentB = parentA.alternate;

          if (parentB === null) {
            var nextParent = parentA.return;

            if (nextParent !== null) {
              a = b = nextParent;
              continue;
            }

            break;
          }

          if (parentA.child === parentB.child) {
            var child = parentA.child;

            while (child) {
              if (child === a) {
                assertIsMounted(parentA);
                return fiber;
              }

              if (child === b) {
                assertIsMounted(parentA);
                return alternate;
              }

              child = child.sibling;
            }

            (function () {
              {
                throw ReactError(Error("Unable to find node on an unmounted component."));
              }
            })();
          }

          if (a.return !== b.return) {
            a = parentA;
            b = parentB;
          } else {
            var didFindChild = false;
            var _child = parentA.child;

            while (_child) {
              if (_child === a) {
                didFindChild = true;
                a = parentA;
                b = parentB;
                break;
              }

              if (_child === b) {
                didFindChild = true;
                b = parentA;
                a = parentB;
                break;
              }

              _child = _child.sibling;
            }

            if (!didFindChild) {
              _child = parentB.child;

              while (_child) {
                if (_child === a) {
                  didFindChild = true;
                  a = parentB;
                  b = parentA;
                  break;
                }

                if (_child === b) {
                  didFindChild = true;
                  b = parentB;
                  a = parentA;
                  break;
                }

                _child = _child.sibling;
              }

              (function () {
                if (!didFindChild) {
                  throw ReactError(Error("Child was not found in either parent set. This indicates a bug in React related to the return pointer. Please file an issue."));
                }
              })();
            }
          }

          (function () {
            if (!(a.alternate === b)) {
              throw ReactError(Error("Return fibers should always be each others' alternates. This error is likely caused by a bug in React. Please file an issue."));
            }
          })();
        }

        (function () {
          if (!(a.tag === HostRoot)) {
            throw ReactError(Error("Unable to find node on an unmounted component."));
          }
        })();

        if (a.stateNode.current === a) {
          return fiber;
        }

        return alternate;
      }

      function findCurrentHostFiber(parent) {
        var currentParent = findCurrentFiberUsingSlowPath(parent);

        if (!currentParent) {
          return null;
        }

        var node = currentParent;

        while (true) {
          if (node.tag === HostComponent || node.tag === HostText) {
            return node;
          } else if (node.child) {
            node.child.return = node;
            node = node.child;
            continue;
          }

          if (node === currentParent) {
            return null;
          }

          while (!node.sibling) {
            if (!node.return || node.return === currentParent) {
              return null;
            }

            node = node.return;
          }

          node.sibling.return = node.return;
          node = node.sibling;
        }

        return null;
      }

      var emptyObject = {};
      var removedKeys = null;
      var removedKeyCount = 0;

      function defaultDiffer(prevProp, nextProp) {
        if (typeof nextProp !== "object" || nextProp === null) {
          return true;
        } else {
          return ReactNativePrivateInterface.deepDiffer(prevProp, nextProp);
        }
      }

      function restoreDeletedValuesInNestedArray(updatePayload, node, validAttributes) {
        if (Array.isArray(node)) {
          var i = node.length;

          while (i-- && removedKeyCount > 0) {
            restoreDeletedValuesInNestedArray(updatePayload, node[i], validAttributes);
          }
        } else if (node && removedKeyCount > 0) {
          var obj = node;

          for (var propKey in removedKeys) {
            if (!removedKeys[propKey]) {
              continue;
            }

            var nextProp = obj[propKey];

            if (nextProp === undefined) {
              continue;
            }

            var attributeConfig = validAttributes[propKey];

            if (!attributeConfig) {
              continue;
            }

            if (typeof nextProp === "function") {
              nextProp = true;
            }

            if (typeof nextProp === "undefined") {
              nextProp = null;
            }

            if (typeof attributeConfig !== "object") {
              updatePayload[propKey] = nextProp;
            } else if (typeof attributeConfig.diff === "function" || typeof attributeConfig.process === "function") {
              var nextValue = typeof attributeConfig.process === "function" ? attributeConfig.process(nextProp) : nextProp;
              updatePayload[propKey] = nextValue;
            }

            removedKeys[propKey] = false;
            removedKeyCount--;
          }
        }
      }

      function diffNestedArrayProperty(updatePayload, prevArray, nextArray, validAttributes) {
        var minLength = prevArray.length < nextArray.length ? prevArray.length : nextArray.length;
        var i = void 0;

        for (i = 0; i < minLength; i++) {
          updatePayload = diffNestedProperty(updatePayload, prevArray[i], nextArray[i], validAttributes);
        }

        for (; i < prevArray.length; i++) {
          updatePayload = clearNestedProperty(updatePayload, prevArray[i], validAttributes);
        }

        for (; i < nextArray.length; i++) {
          updatePayload = addNestedProperty(updatePayload, nextArray[i], validAttributes);
        }

        return updatePayload;
      }

      function diffNestedProperty(updatePayload, prevProp, nextProp, validAttributes) {
        if (!updatePayload && prevProp === nextProp) {
          return updatePayload;
        }

        if (!prevProp || !nextProp) {
          if (nextProp) {
            return addNestedProperty(updatePayload, nextProp, validAttributes);
          }

          if (prevProp) {
            return clearNestedProperty(updatePayload, prevProp, validAttributes);
          }

          return updatePayload;
        }

        if (!Array.isArray(prevProp) && !Array.isArray(nextProp)) {
          return diffProperties(updatePayload, prevProp, nextProp, validAttributes);
        }

        if (Array.isArray(prevProp) && Array.isArray(nextProp)) {
          return diffNestedArrayProperty(updatePayload, prevProp, nextProp, validAttributes);
        }

        if (Array.isArray(prevProp)) {
          return diffProperties(updatePayload, ReactNativePrivateInterface.flattenStyle(prevProp), nextProp, validAttributes);
        }

        return diffProperties(updatePayload, prevProp, ReactNativePrivateInterface.flattenStyle(nextProp), validAttributes);
      }

      function addNestedProperty(updatePayload, nextProp, validAttributes) {
        if (!nextProp) {
          return updatePayload;
        }

        if (!Array.isArray(nextProp)) {
          return addProperties(updatePayload, nextProp, validAttributes);
        }

        for (var i = 0; i < nextProp.length; i++) {
          updatePayload = addNestedProperty(updatePayload, nextProp[i], validAttributes);
        }

        return updatePayload;
      }

      function clearNestedProperty(updatePayload, prevProp, validAttributes) {
        if (!prevProp) {
          return updatePayload;
        }

        if (!Array.isArray(prevProp)) {
          return clearProperties(updatePayload, prevProp, validAttributes);
        }

        for (var i = 0; i < prevProp.length; i++) {
          updatePayload = clearNestedProperty(updatePayload, prevProp[i], validAttributes);
        }

        return updatePayload;
      }

      function diffProperties(updatePayload, prevProps, nextProps, validAttributes) {
        var attributeConfig = void 0;
        var nextProp = void 0;
        var prevProp = void 0;

        for (var propKey in nextProps) {
          attributeConfig = validAttributes[propKey];

          if (!attributeConfig) {
            continue;
          }

          prevProp = prevProps[propKey];
          nextProp = nextProps[propKey];

          if (typeof nextProp === "function") {
            nextProp = true;

            if (typeof prevProp === "function") {
              prevProp = true;
            }
          }

          if (typeof nextProp === "undefined") {
            nextProp = null;

            if (typeof prevProp === "undefined") {
              prevProp = null;
            }
          }

          if (removedKeys) {
            removedKeys[propKey] = false;
          }

          if (updatePayload && updatePayload[propKey] !== undefined) {
            if (typeof attributeConfig !== "object") {
              updatePayload[propKey] = nextProp;
            } else if (typeof attributeConfig.diff === "function" || typeof attributeConfig.process === "function") {
              var nextValue = typeof attributeConfig.process === "function" ? attributeConfig.process(nextProp) : nextProp;
              updatePayload[propKey] = nextValue;
            }

            continue;
          }

          if (prevProp === nextProp) {
            continue;
          }

          if (typeof attributeConfig !== "object") {
            if (defaultDiffer(prevProp, nextProp)) {
              (updatePayload || (updatePayload = {}))[propKey] = nextProp;
            }
          } else if (typeof attributeConfig.diff === "function" || typeof attributeConfig.process === "function") {
            var shouldUpdate = prevProp === undefined || (typeof attributeConfig.diff === "function" ? attributeConfig.diff(prevProp, nextProp) : defaultDiffer(prevProp, nextProp));

            if (shouldUpdate) {
              var _nextValue = typeof attributeConfig.process === "function" ? attributeConfig.process(nextProp) : nextProp;

              (updatePayload || (updatePayload = {}))[propKey] = _nextValue;
            }
          } else {
            removedKeys = null;
            removedKeyCount = 0;
            updatePayload = diffNestedProperty(updatePayload, prevProp, nextProp, attributeConfig);

            if (removedKeyCount > 0 && updatePayload) {
              restoreDeletedValuesInNestedArray(updatePayload, nextProp, attributeConfig);
              removedKeys = null;
            }
          }
        }

        for (var _propKey in prevProps) {
          if (nextProps[_propKey] !== undefined) {
            continue;
          }

          attributeConfig = validAttributes[_propKey];

          if (!attributeConfig) {
            continue;
          }

          if (updatePayload && updatePayload[_propKey] !== undefined) {
            continue;
          }

          prevProp = prevProps[_propKey];

          if (prevProp === undefined) {
            continue;
          }

          if (typeof attributeConfig !== "object" || typeof attributeConfig.diff === "function" || typeof attributeConfig.process === "function") {
            (updatePayload || (updatePayload = {}))[_propKey] = null;

            if (!removedKeys) {
              removedKeys = {};
            }

            if (!removedKeys[_propKey]) {
              removedKeys[_propKey] = true;
              removedKeyCount++;
            }
          } else {
            updatePayload = clearNestedProperty(updatePayload, prevProp, attributeConfig);
          }
        }

        return updatePayload;
      }

      function addProperties(updatePayload, props, validAttributes) {
        return diffProperties(updatePayload, emptyObject, props, validAttributes);
      }

      function clearProperties(updatePayload, prevProps, validAttributes) {
        return diffProperties(updatePayload, prevProps, emptyObject, validAttributes);
      }

      function create(props, validAttributes) {
        return addProperties(null, props, validAttributes);
      }

      function diff(prevProps, nextProps, validAttributes) {
        return diffProperties(null, prevProps, nextProps, validAttributes);
      }

      function mountSafeCallback_NOT_REALLY_SAFE(context, callback) {
        return function () {
          if (!callback) {
            return undefined;
          }

          if (typeof context.__isMounted === "boolean") {
            if (!context.__isMounted) {
              return undefined;
            }
          }

          return callback.apply(context, arguments);
        };
      }

      function throwOnStylesProp(component, props) {
        if (props.styles !== undefined) {
          var owner = component._owner || null;
          var name = component.constructor.displayName;
          var msg = "`styles` is not a supported property of `" + name + "`, did " + "you mean `style` (singular)?";

          if (owner && owner.constructor && owner.constructor.displayName) {
            msg += "\n\nCheck the `" + owner.constructor.displayName + "` parent " + " component.";
          }

          throw new Error(msg);
        }
      }

      function warnForStyleProps(props, validAttributes) {
        for (var key in validAttributes.style) {
          if (!(validAttributes[key] || props[key] === undefined)) {
            console.error("You are setting the style `{ " + key + ": ... }` as a prop. You " + "should nest it in a style object. " + "E.g. `{ style: { " + key + ": ... } }`");
          }
        }
      }

      function _classCallCheck(instance, Constructor) {
        if (!(instance instanceof Constructor)) {
          throw new TypeError("Cannot call a class as a function");
        }
      }

      var ReactNativeFiberHostComponent = function () {
        function ReactNativeFiberHostComponent(tag, viewConfig) {
          _classCallCheck(this, ReactNativeFiberHostComponent);

          this._nativeTag = tag;
          this._children = [];
          this.viewConfig = viewConfig;
        }

        ReactNativeFiberHostComponent.prototype.blur = function blur() {
          ReactNativePrivateInterface.TextInputState.blurTextInput(this._nativeTag);
        };

        ReactNativeFiberHostComponent.prototype.focus = function focus() {
          ReactNativePrivateInterface.TextInputState.focusTextInput(this._nativeTag);
        };

        ReactNativeFiberHostComponent.prototype.measure = function measure(callback) {
          ReactNativePrivateInterface.UIManager.measure(this._nativeTag, mountSafeCallback_NOT_REALLY_SAFE(this, callback));
        };

        ReactNativeFiberHostComponent.prototype.measureInWindow = function measureInWindow(callback) {
          ReactNativePrivateInterface.UIManager.measureInWindow(this._nativeTag, mountSafeCallback_NOT_REALLY_SAFE(this, callback));
        };

        ReactNativeFiberHostComponent.prototype.measureLayout = function measureLayout(relativeToNativeNode, onSuccess, onFail) {
          var relativeNode = void 0;

          if (typeof relativeToNativeNode === "number") {
            relativeNode = relativeToNativeNode;
          } else if (relativeToNativeNode._nativeTag) {
            relativeNode = relativeToNativeNode._nativeTag;
          } else if (relativeToNativeNode.canonical && relativeToNativeNode.canonical._nativeTag) {
            relativeNode = relativeToNativeNode.canonical._nativeTag;
          }

          if (relativeNode == null) {
            warningWithoutStack$1(false, "Warning: ref.measureLayout must be called with a node handle or a ref to a native component.");
            return;
          }

          ReactNativePrivateInterface.UIManager.measureLayout(this._nativeTag, relativeNode, mountSafeCallback_NOT_REALLY_SAFE(this, onFail), mountSafeCallback_NOT_REALLY_SAFE(this, onSuccess));
        };

        ReactNativeFiberHostComponent.prototype.setNativeProps = function setNativeProps(nativeProps) {
          {
            if (warnAboutDeprecatedSetNativeProps) {
              warningWithoutStack$1(false, "Warning: Calling ref.setNativeProps(nativeProps) " + "is deprecated and will be removed in a future release. " + "Use the setNativeProps export from the react-native package instead." + "\n\timport {setNativeProps} from 'react-native';\n\tsetNativeProps(ref, nativeProps);\n");
            }

            warnForStyleProps(nativeProps, this.viewConfig.validAttributes);
          }
          var updatePayload = create(nativeProps, this.viewConfig.validAttributes);

          if (updatePayload != null) {
            ReactNativePrivateInterface.UIManager.updateView(this._nativeTag, this.viewConfig.uiViewClassName, updatePayload);
          }
        };

        return ReactNativeFiberHostComponent;
      }();

      function shim() {
        (function () {
          {
            throw ReactError(Error("The current renderer does not support persistence. This error is likely caused by a bug in React. Please file an issue."));
          }
        })();
      }

      var supportsPersistence = false;
      var cloneInstance = shim;
      var cloneFundamentalInstance = shim;
      var createContainerChildSet = shim;
      var appendChildToContainerChildSet = shim;
      var finalizeContainerChildren = shim;
      var replaceContainerChildren = shim;
      var cloneHiddenInstance = shim;
      var cloneHiddenTextInstance = shim;

      function shim$1() {
        (function () {
          {
            throw ReactError(Error("The current renderer does not support hydration. This error is likely caused by a bug in React. Please file an issue."));
          }
        })();
      }

      var supportsHydration = false;
      var canHydrateInstance = shim$1;
      var canHydrateTextInstance = shim$1;
      var canHydrateSuspenseInstance = shim$1;
      var isSuspenseInstancePending = shim$1;
      var isSuspenseInstanceFallback = shim$1;
      var registerSuspenseInstanceRetry = shim$1;
      var getNextHydratableSibling = shim$1;
      var getFirstHydratableChild = shim$1;
      var hydrateInstance = shim$1;
      var hydrateTextInstance = shim$1;
      var getNextHydratableInstanceAfterSuspenseInstance = shim$1;
      var clearSuspenseBoundary = shim$1;
      var clearSuspenseBoundaryFromContainer = shim$1;
      var didNotMatchHydratedContainerTextInstance = shim$1;
      var didNotMatchHydratedTextInstance = shim$1;
      var didNotHydrateContainerInstance = shim$1;
      var didNotHydrateInstance = shim$1;
      var didNotFindHydratableContainerInstance = shim$1;
      var didNotFindHydratableContainerTextInstance = shim$1;
      var didNotFindHydratableContainerSuspenseInstance = shim$1;
      var didNotFindHydratableInstance = shim$1;
      var didNotFindHydratableTextInstance = shim$1;
      var didNotFindHydratableSuspenseInstance = shim$1;
      var getViewConfigForType = ReactNativePrivateInterface.ReactNativeViewConfigRegistry.get;
      var UPDATE_SIGNAL = {};
      {
        Object.freeze(UPDATE_SIGNAL);
      }
      var nextReactTag = 3;

      function allocateTag() {
        var tag = nextReactTag;

        if (tag % 10 === 1) {
          tag += 2;
        }

        nextReactTag = tag + 2;
        return tag;
      }

      function recursivelyUncacheFiberNode(node) {
        if (typeof node === "number") {
          uncacheFiberNode(node);
        } else {
          uncacheFiberNode(node._nativeTag);

          node._children.forEach(recursivelyUncacheFiberNode);
        }
      }

      function appendInitialChild(parentInstance, child) {
        parentInstance._children.push(child);
      }

      function createInstance(type, props, rootContainerInstance, hostContext, internalInstanceHandle) {
        var tag = allocateTag();
        var viewConfig = getViewConfigForType(type);
        {
          for (var key in viewConfig.validAttributes) {
            if (props.hasOwnProperty(key)) {
              ReactNativePrivateInterface.deepFreezeAndThrowOnMutationInDev(props[key]);
            }
          }
        }
        var updatePayload = create(props, viewConfig.validAttributes);
        ReactNativePrivateInterface.UIManager.createView(tag, viewConfig.uiViewClassName, rootContainerInstance, updatePayload);
        var component = new ReactNativeFiberHostComponent(tag, viewConfig);
        precacheFiberNode(internalInstanceHandle, tag);
        updateFiberProps(tag, props);
        return component;
      }

      function createTextInstance(text, rootContainerInstance, hostContext, internalInstanceHandle) {
        (function () {
          if (!hostContext.isInAParentText) {
            throw ReactError(Error("Text strings must be rendered within a <Text> component."));
          }
        })();

        var tag = allocateTag();
        ReactNativePrivateInterface.UIManager.createView(tag, "RCTRawText", rootContainerInstance, {
          text: text
        });
        precacheFiberNode(internalInstanceHandle, tag);
        return tag;
      }

      function finalizeInitialChildren(parentInstance, type, props, rootContainerInstance, hostContext) {
        if (parentInstance._children.length === 0) {
          return false;
        }

        var nativeTags = parentInstance._children.map(function (child) {
          return typeof child === "number" ? child : child._nativeTag;
        });

        ReactNativePrivateInterface.UIManager.setChildren(parentInstance._nativeTag, nativeTags);
        return false;
      }

      function getRootHostContext(rootContainerInstance) {
        return {
          isInAParentText: false
        };
      }

      function getChildHostContext(parentHostContext, type, rootContainerInstance) {
        var prevIsInAParentText = parentHostContext.isInAParentText;
        var isInAParentText = type === "AndroidTextInput" || type === "RCTMultilineTextInputView" || type === "RCTSinglelineTextInputView" || type === "RCTText" || type === "RCTVirtualText";

        if (prevIsInAParentText !== isInAParentText) {
          return {
            isInAParentText: isInAParentText
          };
        } else {
          return parentHostContext;
        }
      }

      function getPublicInstance(instance) {
        return instance;
      }

      function prepareForCommit(containerInfo) {}

      function prepareUpdate(instance, type, oldProps, newProps, rootContainerInstance, hostContext) {
        return UPDATE_SIGNAL;
      }

      function resetAfterCommit(containerInfo) {}

      var isPrimaryRenderer = true;
      var warnsIfNotActing = true;
      var scheduleTimeout = setTimeout;
      var cancelTimeout = clearTimeout;
      var noTimeout = -1;

      function shouldDeprioritizeSubtree(type, props) {
        return false;
      }

      function shouldSetTextContent(type, props) {
        return false;
      }

      var supportsMutation = true;

      function appendChild(parentInstance, child) {
        var childTag = typeof child === "number" ? child : child._nativeTag;
        var children = parentInstance._children;
        var index = children.indexOf(child);

        if (index >= 0) {
          children.splice(index, 1);
          children.push(child);
          ReactNativePrivateInterface.UIManager.manageChildren(parentInstance._nativeTag, [index], [children.length - 1], [], [], []);
        } else {
          children.push(child);
          ReactNativePrivateInterface.UIManager.manageChildren(parentInstance._nativeTag, [], [], [childTag], [children.length - 1], []);
        }
      }

      function appendChildToContainer(parentInstance, child) {
        var childTag = typeof child === "number" ? child : child._nativeTag;
        ReactNativePrivateInterface.UIManager.setChildren(parentInstance, [childTag]);
      }

      function commitTextUpdate(textInstance, oldText, newText) {
        ReactNativePrivateInterface.UIManager.updateView(textInstance, "RCTRawText", {
          text: newText
        });
      }

      function commitUpdate(instance, updatePayloadTODO, type, oldProps, newProps, internalInstanceHandle) {
        var viewConfig = instance.viewConfig;
        updateFiberProps(instance._nativeTag, newProps);
        var updatePayload = diff(oldProps, newProps, viewConfig.validAttributes);

        if (updatePayload != null) {
          ReactNativePrivateInterface.UIManager.updateView(instance._nativeTag, viewConfig.uiViewClassName, updatePayload);
        }
      }

      function insertBefore(parentInstance, child, beforeChild) {
        var children = parentInstance._children;
        var index = children.indexOf(child);

        if (index >= 0) {
          children.splice(index, 1);
          var beforeChildIndex = children.indexOf(beforeChild);
          children.splice(beforeChildIndex, 0, child);
          ReactNativePrivateInterface.UIManager.manageChildren(parentInstance._nativeTag, [index], [beforeChildIndex], [], [], []);
        } else {
          var _beforeChildIndex = children.indexOf(beforeChild);

          children.splice(_beforeChildIndex, 0, child);
          var childTag = typeof child === "number" ? child : child._nativeTag;
          ReactNativePrivateInterface.UIManager.manageChildren(parentInstance._nativeTag, [], [], [childTag], [_beforeChildIndex], []);
        }
      }

      function insertInContainerBefore(parentInstance, child, beforeChild) {
        (function () {
          if (!(typeof parentInstance !== "number")) {
            throw ReactError(Error("Container does not support insertBefore operation"));
          }
        })();
      }

      function removeChild(parentInstance, child) {
        recursivelyUncacheFiberNode(child);
        var children = parentInstance._children;
        var index = children.indexOf(child);
        children.splice(index, 1);
        ReactNativePrivateInterface.UIManager.manageChildren(parentInstance._nativeTag, [], [], [], [], [index]);
      }

      function removeChildFromContainer(parentInstance, child) {
        recursivelyUncacheFiberNode(child);
        ReactNativePrivateInterface.UIManager.manageChildren(parentInstance, [], [], [], [], [0]);
      }

      function resetTextContent(instance) {}

      function hideInstance(instance) {
        var viewConfig = instance.viewConfig;
        var updatePayload = create({
          style: {
            display: "none"
          }
        }, viewConfig.validAttributes);
        ReactNativePrivateInterface.UIManager.updateView(instance._nativeTag, viewConfig.uiViewClassName, updatePayload);
      }

      function hideTextInstance(textInstance) {
        throw new Error("Not yet implemented.");
      }

      function unhideInstance(instance, props) {
        var viewConfig = instance.viewConfig;
        var updatePayload = diff(_extends({}, props, {
          style: [props.style, {
            display: "none"
          }]
        }), props, viewConfig.validAttributes);
        ReactNativePrivateInterface.UIManager.updateView(instance._nativeTag, viewConfig.uiViewClassName, updatePayload);
      }

      function unhideTextInstance(textInstance, text) {
        throw new Error("Not yet implemented.");
      }

      function mountResponderInstance(responder, responderInstance, props, state, instance, rootContainerInstance) {
        throw new Error("Not yet implemented.");
      }

      function unmountResponderInstance(responderInstance) {
        throw new Error("Not yet implemented.");
      }

      function getFundamentalComponentInstance(fundamentalInstance) {
        throw new Error("Not yet implemented.");
      }

      function mountFundamentalComponent(fundamentalInstance) {
        throw new Error("Not yet implemented.");
      }

      function shouldUpdateFundamentalComponent(fundamentalInstance) {
        throw new Error("Not yet implemented.");
      }

      function updateFundamentalComponent(fundamentalInstance) {
        throw new Error("Not yet implemented.");
      }

      function unmountFundamentalComponent(fundamentalInstance) {
        throw new Error("Not yet implemented.");
      }

      var BEFORE_SLASH_RE = /^(.*)[\\\/]/;

      var describeComponentFrame = function describeComponentFrame(name, source, ownerName) {
        var sourceInfo = "";

        if (source) {
          var path = source.fileName;
          var fileName = path.replace(BEFORE_SLASH_RE, "");
          {
            if (/^index\./.test(fileName)) {
              var match = path.match(BEFORE_SLASH_RE);

              if (match) {
                var pathBeforeSlash = match[1];

                if (pathBeforeSlash) {
                  var folderName = pathBeforeSlash.replace(BEFORE_SLASH_RE, "");
                  fileName = folderName + "/" + fileName;
                }
              }
            }
          }
          sourceInfo = " (at " + fileName + ":" + source.lineNumber + ")";
        } else if (ownerName) {
          sourceInfo = " (created by " + ownerName + ")";
        }

        return "\n    in " + (name || "Unknown") + sourceInfo;
      };

      var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;

      function describeFiber(fiber) {
        switch (fiber.tag) {
          case HostRoot:
          case HostPortal:
          case HostText:
          case Fragment:
          case ContextProvider:
          case ContextConsumer:
            return "";

          default:
            var owner = fiber._debugOwner;
            var source = fiber._debugSource;
            var name = getComponentName(fiber.type);
            var ownerName = null;

            if (owner) {
              ownerName = getComponentName(owner.type);
            }

            return describeComponentFrame(name, source, ownerName);
        }
      }

      function getStackByFiberInDevAndProd(workInProgress) {
        var info = "";
        var node = workInProgress;

        do {
          info += describeFiber(node);
          node = node.return;
        } while (node);

        return info;
      }

      var current = null;
      var phase = null;

      function getCurrentFiberOwnerNameInDevOrNull() {
        {
          if (current === null) {
            return null;
          }

          var owner = current._debugOwner;

          if (owner !== null && typeof owner !== "undefined") {
            return getComponentName(owner.type);
          }
        }
        return null;
      }

      function getCurrentFiberStackInDev() {
        {
          if (current === null) {
            return "";
          }

          return getStackByFiberInDevAndProd(current);
        }
        return "";
      }

      function resetCurrentFiber() {
        {
          ReactDebugCurrentFrame.getCurrentStack = null;
          current = null;
          phase = null;
        }
      }

      function setCurrentFiber(fiber) {
        {
          ReactDebugCurrentFrame.getCurrentStack = getCurrentFiberStackInDev;
          current = fiber;
          phase = null;
        }
      }

      function setCurrentPhase(lifeCyclePhase) {
        {
          phase = lifeCyclePhase;
        }
      }

      var reactEmoji = "\u269B";
      var warningEmoji = "\u26D4";
      var supportsUserTiming = typeof performance !== "undefined" && typeof performance.mark === "function" && typeof performance.clearMarks === "function" && typeof performance.measure === "function" && typeof performance.clearMeasures === "function";
      var currentFiber = null;
      var currentPhase = null;
      var currentPhaseFiber = null;
      var isCommitting = false;
      var hasScheduledUpdateInCurrentCommit = false;
      var hasScheduledUpdateInCurrentPhase = false;
      var commitCountInCurrentWorkLoop = 0;
      var effectCountInCurrentCommit = 0;
      var isWaitingForCallback = false;
      var labelsInCurrentCommit = new Set();

      var formatMarkName = function formatMarkName(markName) {
        return reactEmoji + " " + markName;
      };

      var formatLabel = function formatLabel(label, warning) {
        var prefix = warning ? warningEmoji + " " : reactEmoji + " ";
        var suffix = warning ? " Warning: " + warning : "";
        return "" + prefix + label + suffix;
      };

      var beginMark = function beginMark(markName) {
        performance.mark(formatMarkName(markName));
      };

      var clearMark = function clearMark(markName) {
        performance.clearMarks(formatMarkName(markName));
      };

      var endMark = function endMark(label, markName, warning) {
        var formattedMarkName = formatMarkName(markName);
        var formattedLabel = formatLabel(label, warning);

        try {
          performance.measure(formattedLabel, formattedMarkName);
        } catch (err) {}

        performance.clearMarks(formattedMarkName);
        performance.clearMeasures(formattedLabel);
      };

      var getFiberMarkName = function getFiberMarkName(label, debugID) {
        return label + " (#" + debugID + ")";
      };

      var getFiberLabel = function getFiberLabel(componentName, isMounted, phase) {
        if (phase === null) {
          return componentName + " [" + (isMounted ? "update" : "mount") + "]";
        } else {
          return componentName + "." + phase;
        }
      };

      var beginFiberMark = function beginFiberMark(fiber, phase) {
        var componentName = getComponentName(fiber.type) || "Unknown";
        var debugID = fiber._debugID;
        var isMounted = fiber.alternate !== null;
        var label = getFiberLabel(componentName, isMounted, phase);

        if (isCommitting && labelsInCurrentCommit.has(label)) {
          return false;
        }

        labelsInCurrentCommit.add(label);
        var markName = getFiberMarkName(label, debugID);
        beginMark(markName);
        return true;
      };

      var clearFiberMark = function clearFiberMark(fiber, phase) {
        var componentName = getComponentName(fiber.type) || "Unknown";
        var debugID = fiber._debugID;
        var isMounted = fiber.alternate !== null;
        var label = getFiberLabel(componentName, isMounted, phase);
        var markName = getFiberMarkName(label, debugID);
        clearMark(markName);
      };

      var endFiberMark = function endFiberMark(fiber, phase, warning) {
        var componentName = getComponentName(fiber.type) || "Unknown";
        var debugID = fiber._debugID;
        var isMounted = fiber.alternate !== null;
        var label = getFiberLabel(componentName, isMounted, phase);
        var markName = getFiberMarkName(label, debugID);
        endMark(label, markName, warning);
      };

      var shouldIgnoreFiber = function shouldIgnoreFiber(fiber) {
        switch (fiber.tag) {
          case HostRoot:
          case HostComponent:
          case HostText:
          case HostPortal:
          case Fragment:
          case ContextProvider:
          case ContextConsumer:
          case Mode:
            return true;

          default:
            return false;
        }
      };

      var clearPendingPhaseMeasurement = function clearPendingPhaseMeasurement() {
        if (currentPhase !== null && currentPhaseFiber !== null) {
          clearFiberMark(currentPhaseFiber, currentPhase);
        }

        currentPhaseFiber = null;
        currentPhase = null;
        hasScheduledUpdateInCurrentPhase = false;
      };

      var pauseTimers = function pauseTimers() {
        var fiber = currentFiber;

        while (fiber) {
          if (fiber._debugIsCurrentlyTiming) {
            endFiberMark(fiber, null, null);
          }

          fiber = fiber.return;
        }
      };

      var resumeTimersRecursively = function resumeTimersRecursively(fiber) {
        if (fiber.return !== null) {
          resumeTimersRecursively(fiber.return);
        }

        if (fiber._debugIsCurrentlyTiming) {
          beginFiberMark(fiber, null);
        }
      };

      var resumeTimers = function resumeTimers() {
        if (currentFiber !== null) {
          resumeTimersRecursively(currentFiber);
        }
      };

      function recordEffect() {
        if (enableUserTimingAPI) {
          effectCountInCurrentCommit++;
        }
      }

      function recordScheduleUpdate() {
        if (enableUserTimingAPI) {
          if (isCommitting) {
            hasScheduledUpdateInCurrentCommit = true;
          }

          if (currentPhase !== null && currentPhase !== "componentWillMount" && currentPhase !== "componentWillReceiveProps") {
            hasScheduledUpdateInCurrentPhase = true;
          }
        }
      }

      function startRequestCallbackTimer() {
        if (enableUserTimingAPI) {
          if (supportsUserTiming && !isWaitingForCallback) {
            isWaitingForCallback = true;
            beginMark("(Waiting for async callback...)");
          }
        }
      }

      function stopRequestCallbackTimer(didExpire) {
        if (enableUserTimingAPI) {
          if (supportsUserTiming) {
            isWaitingForCallback = false;
            var warning = didExpire ? "Update expired; will flush synchronously" : null;
            endMark("(Waiting for async callback...)", "(Waiting for async callback...)", warning);
          }
        }
      }

      function startWorkTimer(fiber) {
        if (enableUserTimingAPI) {
          if (!supportsUserTiming || shouldIgnoreFiber(fiber)) {
            return;
          }

          currentFiber = fiber;

          if (!beginFiberMark(fiber, null)) {
            return;
          }

          fiber._debugIsCurrentlyTiming = true;
        }
      }

      function cancelWorkTimer(fiber) {
        if (enableUserTimingAPI) {
          if (!supportsUserTiming || shouldIgnoreFiber(fiber)) {
            return;
          }

          fiber._debugIsCurrentlyTiming = false;
          clearFiberMark(fiber, null);
        }
      }

      function stopWorkTimer(fiber) {
        if (enableUserTimingAPI) {
          if (!supportsUserTiming || shouldIgnoreFiber(fiber)) {
            return;
          }

          currentFiber = fiber.return;

          if (!fiber._debugIsCurrentlyTiming) {
            return;
          }

          fiber._debugIsCurrentlyTiming = false;
          endFiberMark(fiber, null, null);
        }
      }

      function stopFailedWorkTimer(fiber) {
        if (enableUserTimingAPI) {
          if (!supportsUserTiming || shouldIgnoreFiber(fiber)) {
            return;
          }

          currentFiber = fiber.return;

          if (!fiber._debugIsCurrentlyTiming) {
            return;
          }

          fiber._debugIsCurrentlyTiming = false;
          var warning = fiber.tag === SuspenseComponent || fiber.tag === DehydratedSuspenseComponent ? "Rendering was suspended" : "An error was thrown inside this error boundary";
          endFiberMark(fiber, null, warning);
        }
      }

      function startPhaseTimer(fiber, phase) {
        if (enableUserTimingAPI) {
          if (!supportsUserTiming) {
            return;
          }

          clearPendingPhaseMeasurement();

          if (!beginFiberMark(fiber, phase)) {
            return;
          }

          currentPhaseFiber = fiber;
          currentPhase = phase;
        }
      }

      function stopPhaseTimer() {
        if (enableUserTimingAPI) {
          if (!supportsUserTiming) {
            return;
          }

          if (currentPhase !== null && currentPhaseFiber !== null) {
            var warning = hasScheduledUpdateInCurrentPhase ? "Scheduled a cascading update" : null;
            endFiberMark(currentPhaseFiber, currentPhase, warning);
          }

          currentPhase = null;
          currentPhaseFiber = null;
        }
      }

      function startWorkLoopTimer(nextUnitOfWork) {
        if (enableUserTimingAPI) {
          currentFiber = nextUnitOfWork;

          if (!supportsUserTiming) {
            return;
          }

          commitCountInCurrentWorkLoop = 0;
          beginMark("(React Tree Reconciliation)");
          resumeTimers();
        }
      }

      function stopWorkLoopTimer(interruptedBy, didCompleteRoot) {
        if (enableUserTimingAPI) {
          if (!supportsUserTiming) {
            return;
          }

          var warning = null;

          if (interruptedBy !== null) {
            if (interruptedBy.tag === HostRoot) {
              warning = "A top-level update interrupted the previous render";
            } else {
              var componentName = getComponentName(interruptedBy.type) || "Unknown";
              warning = "An update to " + componentName + " interrupted the previous render";
            }
          } else if (commitCountInCurrentWorkLoop > 1) {
            warning = "There were cascading updates";
          }

          commitCountInCurrentWorkLoop = 0;
          var label = didCompleteRoot ? "(React Tree Reconciliation: Completed Root)" : "(React Tree Reconciliation: Yielded)";
          pauseTimers();
          endMark(label, "(React Tree Reconciliation)", warning);
        }
      }

      function startCommitTimer() {
        if (enableUserTimingAPI) {
          if (!supportsUserTiming) {
            return;
          }

          isCommitting = true;
          hasScheduledUpdateInCurrentCommit = false;
          labelsInCurrentCommit.clear();
          beginMark("(Committing Changes)");
        }
      }

      function stopCommitTimer() {
        if (enableUserTimingAPI) {
          if (!supportsUserTiming) {
            return;
          }

          var warning = null;

          if (hasScheduledUpdateInCurrentCommit) {
            warning = "Lifecycle hook scheduled a cascading update";
          } else if (commitCountInCurrentWorkLoop > 0) {
            warning = "Caused by a cascading update in earlier commit";
          }

          hasScheduledUpdateInCurrentCommit = false;
          commitCountInCurrentWorkLoop++;
          isCommitting = false;
          labelsInCurrentCommit.clear();
          endMark("(Committing Changes)", "(Committing Changes)", warning);
        }
      }

      function startCommitSnapshotEffectsTimer() {
        if (enableUserTimingAPI) {
          if (!supportsUserTiming) {
            return;
          }

          effectCountInCurrentCommit = 0;
          beginMark("(Committing Snapshot Effects)");
        }
      }

      function stopCommitSnapshotEffectsTimer() {
        if (enableUserTimingAPI) {
          if (!supportsUserTiming) {
            return;
          }

          var count = effectCountInCurrentCommit;
          effectCountInCurrentCommit = 0;
          endMark("(Committing Snapshot Effects: " + count + " Total)", "(Committing Snapshot Effects)", null);
        }
      }

      function startCommitHostEffectsTimer() {
        if (enableUserTimingAPI) {
          if (!supportsUserTiming) {
            return;
          }

          effectCountInCurrentCommit = 0;
          beginMark("(Committing Host Effects)");
        }
      }

      function stopCommitHostEffectsTimer() {
        if (enableUserTimingAPI) {
          if (!supportsUserTiming) {
            return;
          }

          var count = effectCountInCurrentCommit;
          effectCountInCurrentCommit = 0;
          endMark("(Committing Host Effects: " + count + " Total)", "(Committing Host Effects)", null);
        }
      }

      function startCommitLifeCyclesTimer() {
        if (enableUserTimingAPI) {
          if (!supportsUserTiming) {
            return;
          }

          effectCountInCurrentCommit = 0;
          beginMark("(Calling Lifecycle Methods)");
        }
      }

      function stopCommitLifeCyclesTimer() {
        if (enableUserTimingAPI) {
          if (!supportsUserTiming) {
            return;
          }

          var count = effectCountInCurrentCommit;
          effectCountInCurrentCommit = 0;
          endMark("(Calling Lifecycle Methods: " + count + " Total)", "(Calling Lifecycle Methods)", null);
        }
      }

      var valueStack = [];
      var fiberStack = void 0;
      {
        fiberStack = [];
      }
      var index = -1;

      function createCursor(defaultValue) {
        return {
          current: defaultValue
        };
      }

      function pop(cursor, fiber) {
        if (index < 0) {
          {
            warningWithoutStack$1(false, "Unexpected pop.");
          }
          return;
        }

        {
          if (fiber !== fiberStack[index]) {
            warningWithoutStack$1(false, "Unexpected Fiber popped.");
          }
        }
        cursor.current = valueStack[index];
        valueStack[index] = null;
        {
          fiberStack[index] = null;
        }
        index--;
      }

      function push(cursor, value, fiber) {
        index++;
        valueStack[index] = cursor.current;
        {
          fiberStack[index] = fiber;
        }
        cursor.current = value;
      }

      var warnedAboutMissingGetChildContext = void 0;
      {
        warnedAboutMissingGetChildContext = {};
      }
      var emptyContextObject = {};
      {
        Object.freeze(emptyContextObject);
      }
      var contextStackCursor = createCursor(emptyContextObject);
      var didPerformWorkStackCursor = createCursor(false);
      var previousContext = emptyContextObject;

      function getUnmaskedContext(workInProgress, Component, didPushOwnContextIfProvider) {
        if (disableLegacyContext) {
          return emptyContextObject;
        } else {
          if (didPushOwnContextIfProvider && isContextProvider(Component)) {
            return previousContext;
          }

          return contextStackCursor.current;
        }
      }

      function cacheContext(workInProgress, unmaskedContext, maskedContext) {
        if (disableLegacyContext) {
          return;
        } else {
          var instance = workInProgress.stateNode;
          instance.__reactInternalMemoizedUnmaskedChildContext = unmaskedContext;
          instance.__reactInternalMemoizedMaskedChildContext = maskedContext;
        }
      }

      function getMaskedContext(workInProgress, unmaskedContext) {
        if (disableLegacyContext) {
          return emptyContextObject;
        } else {
          var type = workInProgress.type;
          var contextTypes = type.contextTypes;

          if (!contextTypes) {
            return emptyContextObject;
          }

          var instance = workInProgress.stateNode;

          if (instance && instance.__reactInternalMemoizedUnmaskedChildContext === unmaskedContext) {
            return instance.__reactInternalMemoizedMaskedChildContext;
          }

          var context = {};

          for (var key in contextTypes) {
            context[key] = unmaskedContext[key];
          }

          {
            var name = getComponentName(type) || "Unknown";
            checkPropTypes(contextTypes, context, "context", name, getCurrentFiberStackInDev);
          }

          if (instance) {
            cacheContext(workInProgress, unmaskedContext, context);
          }

          return context;
        }
      }

      function hasContextChanged() {
        if (disableLegacyContext) {
          return false;
        } else {
          return didPerformWorkStackCursor.current;
        }
      }

      function isContextProvider(type) {
        if (disableLegacyContext) {
          return false;
        } else {
          var childContextTypes = type.childContextTypes;
          return childContextTypes !== null && childContextTypes !== undefined;
        }
      }

      function popContext(fiber) {
        if (disableLegacyContext) {
          return;
        } else {
          pop(didPerformWorkStackCursor, fiber);
          pop(contextStackCursor, fiber);
        }
      }

      function popTopLevelContextObject(fiber) {
        if (disableLegacyContext) {
          return;
        } else {
          pop(didPerformWorkStackCursor, fiber);
          pop(contextStackCursor, fiber);
        }
      }

      function pushTopLevelContextObject(fiber, context, didChange) {
        if (disableLegacyContext) {
          return;
        } else {
          (function () {
            if (!(contextStackCursor.current === emptyContextObject)) {
              throw ReactError(Error("Unexpected context found on stack. This error is likely caused by a bug in React. Please file an issue."));
            }
          })();

          push(contextStackCursor, context, fiber);
          push(didPerformWorkStackCursor, didChange, fiber);
        }
      }

      function processChildContext(fiber, type, parentContext) {
        if (disableLegacyContext) {
          return parentContext;
        } else {
          var instance = fiber.stateNode;
          var childContextTypes = type.childContextTypes;

          if (typeof instance.getChildContext !== "function") {
            {
              var componentName = getComponentName(type) || "Unknown";

              if (!warnedAboutMissingGetChildContext[componentName]) {
                warnedAboutMissingGetChildContext[componentName] = true;
                warningWithoutStack$1(false, "%s.childContextTypes is specified but there is no getChildContext() method " + "on the instance. You can either define getChildContext() on %s or remove " + "childContextTypes from it.", componentName, componentName);
              }
            }
            return parentContext;
          }

          var childContext = void 0;
          {
            setCurrentPhase("getChildContext");
          }
          startPhaseTimer(fiber, "getChildContext");
          childContext = instance.getChildContext();
          stopPhaseTimer();
          {
            setCurrentPhase(null);
          }

          for (var contextKey in childContext) {
            (function () {
              if (!(contextKey in childContextTypes)) {
                throw ReactError(Error((getComponentName(type) || "Unknown") + '.getChildContext(): key "' + contextKey + '" is not defined in childContextTypes.'));
              }
            })();
          }

          {
            var name = getComponentName(type) || "Unknown";
            checkPropTypes(childContextTypes, childContext, "child context", name, getCurrentFiberStackInDev);
          }
          return _extends({}, parentContext, childContext);
        }
      }

      function pushContextProvider(workInProgress) {
        if (disableLegacyContext) {
          return false;
        } else {
          var instance = workInProgress.stateNode;
          var memoizedMergedChildContext = instance && instance.__reactInternalMemoizedMergedChildContext || emptyContextObject;
          previousContext = contextStackCursor.current;
          push(contextStackCursor, memoizedMergedChildContext, workInProgress);
          push(didPerformWorkStackCursor, didPerformWorkStackCursor.current, workInProgress);
          return true;
        }
      }

      function invalidateContextProvider(workInProgress, type, didChange) {
        if (disableLegacyContext) {
          return;
        } else {
          var instance = workInProgress.stateNode;

          (function () {
            if (!instance) {
              throw ReactError(Error("Expected to have an instance by this point. This error is likely caused by a bug in React. Please file an issue."));
            }
          })();

          if (didChange) {
            var mergedContext = processChildContext(workInProgress, type, previousContext);
            instance.__reactInternalMemoizedMergedChildContext = mergedContext;
            pop(didPerformWorkStackCursor, workInProgress);
            pop(contextStackCursor, workInProgress);
            push(contextStackCursor, mergedContext, workInProgress);
            push(didPerformWorkStackCursor, didChange, workInProgress);
          } else {
            pop(didPerformWorkStackCursor, workInProgress);
            push(didPerformWorkStackCursor, didChange, workInProgress);
          }
        }
      }

      function findCurrentUnmaskedContext(fiber) {
        if (disableLegacyContext) {
          return emptyContextObject;
        } else {
          (function () {
            if (!(isFiberMounted(fiber) && fiber.tag === ClassComponent)) {
              throw ReactError(Error("Expected subtree parent to be a mounted class component. This error is likely caused by a bug in React. Please file an issue."));
            }
          })();

          var node = fiber;

          do {
            switch (node.tag) {
              case HostRoot:
                return node.stateNode.context;

              case ClassComponent:
                {
                  var Component = node.type;

                  if (isContextProvider(Component)) {
                    return node.stateNode.__reactInternalMemoizedMergedChildContext;
                  }

                  break;
                }
            }

            node = node.return;
          } while (node !== null);

          (function () {
            {
              throw ReactError(Error("Found unexpected detached subtree parent. This error is likely caused by a bug in React. Please file an issue."));
            }
          })();
        }
      }

      var LegacyRoot = 0;
      var BatchedRoot = 1;
      var ConcurrentRoot = 2;
      var warning = warningWithoutStack$1;
      {
        warning = function warning(condition, format) {
          if (condition) {
            return;
          }

          var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
          var stack = ReactDebugCurrentFrame.getStackAddendum();

          for (var _len = arguments.length, args = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
            args[_key - 2] = arguments[_key];
          }

          warningWithoutStack$1.apply(undefined, [false, format + "%s"].concat(args, [stack]));
        };
      }
      var warning$1 = warning;
      var Scheduler_runWithPriority = Scheduler.unstable_runWithPriority;
      var Scheduler_scheduleCallback = Scheduler.unstable_scheduleCallback;
      var Scheduler_cancelCallback = Scheduler.unstable_cancelCallback;
      var Scheduler_shouldYield = Scheduler.unstable_shouldYield;
      var Scheduler_requestPaint = Scheduler.unstable_requestPaint;
      var Scheduler_now = Scheduler.unstable_now;
      var Scheduler_getCurrentPriorityLevel = Scheduler.unstable_getCurrentPriorityLevel;
      var Scheduler_ImmediatePriority = Scheduler.unstable_ImmediatePriority;
      var Scheduler_UserBlockingPriority = Scheduler.unstable_UserBlockingPriority;
      var Scheduler_NormalPriority = Scheduler.unstable_NormalPriority;
      var Scheduler_LowPriority = Scheduler.unstable_LowPriority;
      var Scheduler_IdlePriority = Scheduler.unstable_IdlePriority;

      if (enableSchedulerTracing) {
        (function () {
          if (!(tracing.__interactionsRef != null && tracing.__interactionsRef.current != null)) {
            throw ReactError(Error("It is not supported to run the profiling version of a renderer (for example, `react-dom/profiling`) without also replacing the `scheduler/tracing` module with `scheduler/tracing-profiling`. Your bundler might have a setting for aliasing both modules. Learn more at http://fb.me/react-profiling"));
          }
        })();
      }

      var fakeCallbackNode = {};
      var ImmediatePriority = 99;
      var UserBlockingPriority = 98;
      var NormalPriority = 97;
      var LowPriority = 96;
      var IdlePriority = 95;
      var NoPriority = 90;
      var shouldYield = Scheduler_shouldYield;
      var requestPaint = Scheduler_requestPaint !== undefined ? Scheduler_requestPaint : function () {};
      var syncQueue = null;
      var immediateQueueCallbackNode = null;
      var isFlushingSyncQueue = false;
      var initialTimeMs = Scheduler_now();
      var now = initialTimeMs < 10000 ? Scheduler_now : function () {
        return Scheduler_now() - initialTimeMs;
      };

      function getCurrentPriorityLevel() {
        switch (Scheduler_getCurrentPriorityLevel()) {
          case Scheduler_ImmediatePriority:
            return ImmediatePriority;

          case Scheduler_UserBlockingPriority:
            return UserBlockingPriority;

          case Scheduler_NormalPriority:
            return NormalPriority;

          case Scheduler_LowPriority:
            return LowPriority;

          case Scheduler_IdlePriority:
            return IdlePriority;

          default:
            (function () {
              {
                throw ReactError(Error("Unknown priority level."));
              }
            })();

        }
      }

      function reactPriorityToSchedulerPriority(reactPriorityLevel) {
        switch (reactPriorityLevel) {
          case ImmediatePriority:
            return Scheduler_ImmediatePriority;

          case UserBlockingPriority:
            return Scheduler_UserBlockingPriority;

          case NormalPriority:
            return Scheduler_NormalPriority;

          case LowPriority:
            return Scheduler_LowPriority;

          case IdlePriority:
            return Scheduler_IdlePriority;

          default:
            (function () {
              {
                throw ReactError(Error("Unknown priority level."));
              }
            })();

        }
      }

      function runWithPriority(reactPriorityLevel, fn) {
        var priorityLevel = reactPriorityToSchedulerPriority(reactPriorityLevel);
        return Scheduler_runWithPriority(priorityLevel, fn);
      }

      function scheduleCallback(reactPriorityLevel, callback, options) {
        var priorityLevel = reactPriorityToSchedulerPriority(reactPriorityLevel);
        return Scheduler_scheduleCallback(priorityLevel, callback, options);
      }

      function scheduleSyncCallback(callback) {
        if (syncQueue === null) {
          syncQueue = [callback];
          immediateQueueCallbackNode = Scheduler_scheduleCallback(Scheduler_ImmediatePriority, flushSyncCallbackQueueImpl);
        } else {
          syncQueue.push(callback);
        }

        return fakeCallbackNode;
      }

      function cancelCallback(callbackNode) {
        if (callbackNode !== fakeCallbackNode) {
          Scheduler_cancelCallback(callbackNode);
        }
      }

      function flushSyncCallbackQueue() {
        if (immediateQueueCallbackNode !== null) {
          Scheduler_cancelCallback(immediateQueueCallbackNode);
        }

        flushSyncCallbackQueueImpl();
      }

      function flushSyncCallbackQueueImpl() {
        if (!isFlushingSyncQueue && syncQueue !== null) {
          isFlushingSyncQueue = true;
          var i = 0;

          try {
            var _isSync = true;
            var queue = syncQueue;
            runWithPriority(ImmediatePriority, function () {
              for (; i < queue.length; i++) {
                var callback = queue[i];

                do {
                  callback = callback(_isSync);
                } while (callback !== null);
              }
            });
            syncQueue = null;
          } catch (error) {
            if (syncQueue !== null) {
              syncQueue = syncQueue.slice(i + 1);
            }

            Scheduler_scheduleCallback(Scheduler_ImmediatePriority, flushSyncCallbackQueue);
            throw error;
          } finally {
            isFlushingSyncQueue = false;
          }
        }
      }

      var NoMode = 0;
      var StrictMode = 1;
      var BatchedMode = 2;
      var ConcurrentMode = 4;
      var ProfileMode = 8;
      var MAX_SIGNED_31_BIT_INT = 1073741823;
      var NoWork = 0;
      var Never = 1;
      var Sync = MAX_SIGNED_31_BIT_INT;
      var Batched = Sync - 1;
      var UNIT_SIZE = 10;
      var MAGIC_NUMBER_OFFSET = Batched - 1;

      function msToExpirationTime(ms) {
        return MAGIC_NUMBER_OFFSET - (ms / UNIT_SIZE | 0);
      }

      function expirationTimeToMs(expirationTime) {
        return (MAGIC_NUMBER_OFFSET - expirationTime) * UNIT_SIZE;
      }

      function ceiling(num, precision) {
        return ((num / precision | 0) + 1) * precision;
      }

      function computeExpirationBucket(currentTime, expirationInMs, bucketSizeMs) {
        return MAGIC_NUMBER_OFFSET - ceiling(MAGIC_NUMBER_OFFSET - currentTime + expirationInMs / UNIT_SIZE, bucketSizeMs / UNIT_SIZE);
      }

      var LOW_PRIORITY_EXPIRATION = 5000;
      var LOW_PRIORITY_BATCH_SIZE = 250;

      function computeAsyncExpiration(currentTime) {
        return computeExpirationBucket(currentTime, LOW_PRIORITY_EXPIRATION, LOW_PRIORITY_BATCH_SIZE);
      }

      function computeSuspenseExpiration(currentTime, timeoutMs) {
        return computeExpirationBucket(currentTime, timeoutMs, LOW_PRIORITY_BATCH_SIZE);
      }

      var HIGH_PRIORITY_EXPIRATION = 500;
      var HIGH_PRIORITY_BATCH_SIZE = 100;

      function computeInteractiveExpiration(currentTime) {
        return computeExpirationBucket(currentTime, HIGH_PRIORITY_EXPIRATION, HIGH_PRIORITY_BATCH_SIZE);
      }

      function inferPriorityFromExpirationTime(currentTime, expirationTime) {
        if (expirationTime === Sync) {
          return ImmediatePriority;
        }

        if (expirationTime === Never) {
          return IdlePriority;
        }

        var msUntil = expirationTimeToMs(expirationTime) - expirationTimeToMs(currentTime);

        if (msUntil <= 0) {
          return ImmediatePriority;
        }

        if (msUntil <= HIGH_PRIORITY_EXPIRATION + HIGH_PRIORITY_BATCH_SIZE) {
          return UserBlockingPriority;
        }

        if (msUntil <= LOW_PRIORITY_EXPIRATION + LOW_PRIORITY_BATCH_SIZE) {
          return NormalPriority;
        }

        return IdlePriority;
      }

      function is(x, y) {
        return x === y && (x !== 0 || 1 / x === 1 / y) || x !== x && y !== y;
      }

      var hasOwnProperty = Object.prototype.hasOwnProperty;

      function shallowEqual(objA, objB) {
        if (is(objA, objB)) {
          return true;
        }

        if (typeof objA !== "object" || objA === null || typeof objB !== "object" || objB === null) {
          return false;
        }

        var keysA = Object.keys(objA);
        var keysB = Object.keys(objB);

        if (keysA.length !== keysB.length) {
          return false;
        }

        for (var i = 0; i < keysA.length; i++) {
          if (!hasOwnProperty.call(objB, keysA[i]) || !is(objA[keysA[i]], objB[keysA[i]])) {
            return false;
          }
        }

        return true;
      }

      var lowPriorityWarning = function lowPriorityWarning() {};

      {
        var printWarning = function printWarning(format) {
          for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
            args[_key - 1] = arguments[_key];
          }

          var argIndex = 0;
          var message = "Warning: " + format.replace(/%s/g, function () {
            return args[argIndex++];
          });

          if (typeof console !== "undefined") {
            console.warn(message);
          }

          try {
            throw new Error(message);
          } catch (x) {}
        };

        lowPriorityWarning = function lowPriorityWarning(condition, format) {
          if (format === undefined) {
            throw new Error("`lowPriorityWarning(condition, format, ...args)` requires a warning " + "message argument");
          }

          if (!condition) {
            for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
              args[_key2 - 2] = arguments[_key2];
            }

            printWarning.apply(undefined, [format].concat(args));
          }
        };
      }
      var lowPriorityWarning$1 = lowPriorityWarning;
      var ReactStrictModeWarnings = {
        recordUnsafeLifecycleWarnings: function recordUnsafeLifecycleWarnings(fiber, instance) {},
        flushPendingUnsafeLifecycleWarnings: function flushPendingUnsafeLifecycleWarnings() {},
        recordLegacyContextWarning: function recordLegacyContextWarning(fiber, instance) {},
        flushLegacyContextWarning: function flushLegacyContextWarning() {},
        discardPendingWarnings: function discardPendingWarnings() {}
      };
      {
        var findStrictRoot = function findStrictRoot(fiber) {
          var maybeStrictRoot = null;
          var node = fiber;

          while (node !== null) {
            if (node.mode & StrictMode) {
              maybeStrictRoot = node;
            }

            node = node.return;
          }

          return maybeStrictRoot;
        };

        var setToSortedString = function setToSortedString(set) {
          var array = [];
          set.forEach(function (value) {
            array.push(value);
          });
          return array.sort().join(", ");
        };

        var pendingComponentWillMountWarnings = [];
        var pendingUNSAFE_ComponentWillMountWarnings = [];
        var pendingComponentWillReceivePropsWarnings = [];
        var pendingUNSAFE_ComponentWillReceivePropsWarnings = [];
        var pendingComponentWillUpdateWarnings = [];
        var pendingUNSAFE_ComponentWillUpdateWarnings = [];
        var didWarnAboutUnsafeLifecycles = new Set();

        ReactStrictModeWarnings.recordUnsafeLifecycleWarnings = function (fiber, instance) {
          if (didWarnAboutUnsafeLifecycles.has(fiber.type)) {
            return;
          }

          if (typeof instance.componentWillMount === "function" && instance.componentWillMount.__suppressDeprecationWarning !== true) {
            pendingComponentWillMountWarnings.push(fiber);
          }

          if (fiber.mode & StrictMode && typeof instance.UNSAFE_componentWillMount === "function") {
            pendingUNSAFE_ComponentWillMountWarnings.push(fiber);
          }

          if (typeof instance.componentWillReceiveProps === "function" && instance.componentWillReceiveProps.__suppressDeprecationWarning !== true) {
            pendingComponentWillReceivePropsWarnings.push(fiber);
          }

          if (fiber.mode & StrictMode && typeof instance.UNSAFE_componentWillReceiveProps === "function") {
            pendingUNSAFE_ComponentWillReceivePropsWarnings.push(fiber);
          }

          if (typeof instance.componentWillUpdate === "function" && instance.componentWillUpdate.__suppressDeprecationWarning !== true) {
            pendingComponentWillUpdateWarnings.push(fiber);
          }

          if (fiber.mode & StrictMode && typeof instance.UNSAFE_componentWillUpdate === "function") {
            pendingUNSAFE_ComponentWillUpdateWarnings.push(fiber);
          }
        };

        ReactStrictModeWarnings.flushPendingUnsafeLifecycleWarnings = function () {
          var componentWillMountUniqueNames = new Set();

          if (pendingComponentWillMountWarnings.length > 0) {
            pendingComponentWillMountWarnings.forEach(function (fiber) {
              componentWillMountUniqueNames.add(getComponentName(fiber.type) || "Component");
              didWarnAboutUnsafeLifecycles.add(fiber.type);
            });
            pendingComponentWillMountWarnings = [];
          }

          var UNSAFE_componentWillMountUniqueNames = new Set();

          if (pendingUNSAFE_ComponentWillMountWarnings.length > 0) {
            pendingUNSAFE_ComponentWillMountWarnings.forEach(function (fiber) {
              UNSAFE_componentWillMountUniqueNames.add(getComponentName(fiber.type) || "Component");
              didWarnAboutUnsafeLifecycles.add(fiber.type);
            });
            pendingUNSAFE_ComponentWillMountWarnings = [];
          }

          var componentWillReceivePropsUniqueNames = new Set();

          if (pendingComponentWillReceivePropsWarnings.length > 0) {
            pendingComponentWillReceivePropsWarnings.forEach(function (fiber) {
              componentWillReceivePropsUniqueNames.add(getComponentName(fiber.type) || "Component");
              didWarnAboutUnsafeLifecycles.add(fiber.type);
            });
            pendingComponentWillReceivePropsWarnings = [];
          }

          var UNSAFE_componentWillReceivePropsUniqueNames = new Set();

          if (pendingUNSAFE_ComponentWillReceivePropsWarnings.length > 0) {
            pendingUNSAFE_ComponentWillReceivePropsWarnings.forEach(function (fiber) {
              UNSAFE_componentWillReceivePropsUniqueNames.add(getComponentName(fiber.type) || "Component");
              didWarnAboutUnsafeLifecycles.add(fiber.type);
            });
            pendingUNSAFE_ComponentWillReceivePropsWarnings = [];
          }

          var componentWillUpdateUniqueNames = new Set();

          if (pendingComponentWillUpdateWarnings.length > 0) {
            pendingComponentWillUpdateWarnings.forEach(function (fiber) {
              componentWillUpdateUniqueNames.add(getComponentName(fiber.type) || "Component");
              didWarnAboutUnsafeLifecycles.add(fiber.type);
            });
            pendingComponentWillUpdateWarnings = [];
          }

          var UNSAFE_componentWillUpdateUniqueNames = new Set();

          if (pendingUNSAFE_ComponentWillUpdateWarnings.length > 0) {
            pendingUNSAFE_ComponentWillUpdateWarnings.forEach(function (fiber) {
              UNSAFE_componentWillUpdateUniqueNames.add(getComponentName(fiber.type) || "Component");
              didWarnAboutUnsafeLifecycles.add(fiber.type);
            });
            pendingUNSAFE_ComponentWillUpdateWarnings = [];
          }

          if (UNSAFE_componentWillMountUniqueNames.size > 0) {
            var sortedNames = setToSortedString(UNSAFE_componentWillMountUniqueNames);
            warningWithoutStack$1(false, "Using UNSAFE_componentWillMount in strict mode is not recommended and may indicate bugs in your code. " + "See https://fb.me/react-async-component-lifecycle-hooks for details.\n\n" + "* Move code with side effects to componentDidMount, and set initial state in the constructor.\n" + "\nPlease update the following components: %s", sortedNames);
          }

          if (UNSAFE_componentWillReceivePropsUniqueNames.size > 0) {
            var _sortedNames = setToSortedString(UNSAFE_componentWillReceivePropsUniqueNames);

            warningWithoutStack$1(false, "Using UNSAFE_componentWillReceiveProps in strict mode is not recommended " + "and may indicate bugs in your code. " + "See https://fb.me/react-async-component-lifecycle-hooks for details.\n\n" + "* Move data fetching code or side effects to componentDidUpdate.\n" + "* If you're updating state whenever props change, " + "refactor your code to use memoization techniques or move it to " + "static getDerivedStateFromProps. Learn more at: https://fb.me/react-derived-state\n" + "\nPlease update the following components: %s", _sortedNames);
          }

          if (UNSAFE_componentWillUpdateUniqueNames.size > 0) {
            var _sortedNames2 = setToSortedString(UNSAFE_componentWillUpdateUniqueNames);

            warningWithoutStack$1(false, "Using UNSAFE_componentWillUpdate in strict mode is not recommended " + "and may indicate bugs in your code. " + "See https://fb.me/react-async-component-lifecycle-hooks for details.\n\n" + "* Move data fetching code or side effects to componentDidUpdate.\n" + "\nPlease update the following components: %s", _sortedNames2);
          }

          if (componentWillMountUniqueNames.size > 0) {
            var _sortedNames3 = setToSortedString(componentWillMountUniqueNames);

            lowPriorityWarning$1(false, "componentWillMount has been renamed, and is not recommended for use. " + "See https://fb.me/react-async-component-lifecycle-hooks for details.\n\n" + "* Move code with side effects to componentDidMount, and set initial state in the constructor.\n" + "* Rename componentWillMount to UNSAFE_componentWillMount to suppress " + "this warning in non-strict mode. In React 17.x, only the UNSAFE_ name will work. " + "To rename all deprecated lifecycles to their new names, you can run " + "`npx react-codemod rename-unsafe-lifecycles` in your project source folder.\n" + "\nPlease update the following components: %s", _sortedNames3);
          }

          if (componentWillReceivePropsUniqueNames.size > 0) {
            var _sortedNames4 = setToSortedString(componentWillReceivePropsUniqueNames);

            lowPriorityWarning$1(false, "componentWillReceiveProps has been renamed, and is not recommended for use. " + "See https://fb.me/react-async-component-lifecycle-hooks for details.\n\n" + "* Move data fetching code or side effects to componentDidUpdate.\n" + "* If you're updating state whenever props change, refactor your " + "code to use memoization techniques or move it to " + "static getDerivedStateFromProps. Learn more at: https://fb.me/react-derived-state\n" + "* Rename componentWillReceiveProps to UNSAFE_componentWillReceiveProps to suppress " + "this warning in non-strict mode. In React 17.x, only the UNSAFE_ name will work. " + "To rename all deprecated lifecycles to their new names, you can run " + "`npx react-codemod rename-unsafe-lifecycles` in your project source folder.\n" + "\nPlease update the following components: %s", _sortedNames4);
          }

          if (componentWillUpdateUniqueNames.size > 0) {
            var _sortedNames5 = setToSortedString(componentWillUpdateUniqueNames);

            lowPriorityWarning$1(false, "componentWillUpdate has been renamed, and is not recommended for use. " + "See https://fb.me/react-async-component-lifecycle-hooks for details.\n\n" + "* Move data fetching code or side effects to componentDidUpdate.\n" + "* Rename componentWillUpdate to UNSAFE_componentWillUpdate to suppress " + "this warning in non-strict mode. In React 17.x, only the UNSAFE_ name will work. " + "To rename all deprecated lifecycles to their new names, you can run " + "`npx react-codemod rename-unsafe-lifecycles` in your project source folder.\n" + "\nPlease update the following components: %s", _sortedNames5);
          }
        };

        var pendingLegacyContextWarning = new Map();
        var didWarnAboutLegacyContext = new Set();

        ReactStrictModeWarnings.recordLegacyContextWarning = function (fiber, instance) {
          var strictRoot = findStrictRoot(fiber);

          if (strictRoot === null) {
            warningWithoutStack$1(false, "Expected to find a StrictMode component in a strict mode tree. " + "This error is likely caused by a bug in React. Please file an issue.");
            return;
          }

          if (didWarnAboutLegacyContext.has(fiber.type)) {
            return;
          }

          var warningsForRoot = pendingLegacyContextWarning.get(strictRoot);

          if (fiber.type.contextTypes != null || fiber.type.childContextTypes != null || instance !== null && typeof instance.getChildContext === "function") {
            if (warningsForRoot === undefined) {
              warningsForRoot = [];
              pendingLegacyContextWarning.set(strictRoot, warningsForRoot);
            }

            warningsForRoot.push(fiber);
          }
        };

        ReactStrictModeWarnings.flushLegacyContextWarning = function () {
          pendingLegacyContextWarning.forEach(function (fiberArray, strictRoot) {
            var uniqueNames = new Set();
            fiberArray.forEach(function (fiber) {
              uniqueNames.add(getComponentName(fiber.type) || "Component");
              didWarnAboutLegacyContext.add(fiber.type);
            });
            var sortedNames = setToSortedString(uniqueNames);
            var strictRootComponentStack = getStackByFiberInDevAndProd(strictRoot);
            warningWithoutStack$1(false, "Legacy context API has been detected within a strict-mode tree: %s" + "\n\nThe old API will be supported in all 16.x releases, but applications " + "using it should migrate to the new version." + "\n\nPlease update the following components: %s" + "\n\nLearn more about this warning here:" + "\nhttps://fb.me/react-legacy-context", strictRootComponentStack, sortedNames);
          });
        };

        ReactStrictModeWarnings.discardPendingWarnings = function () {
          pendingComponentWillMountWarnings = [];
          pendingUNSAFE_ComponentWillMountWarnings = [];
          pendingComponentWillReceivePropsWarnings = [];
          pendingUNSAFE_ComponentWillReceivePropsWarnings = [];
          pendingComponentWillUpdateWarnings = [];
          pendingUNSAFE_ComponentWillUpdateWarnings = [];
          pendingLegacyContextWarning = new Map();
        };
      }
      var resolveFamily = null;
      var failedBoundaries = null;

      var setRefreshHandler = function setRefreshHandler(handler) {
        {
          resolveFamily = handler;
        }
      };

      function resolveFunctionForHotReloading(type) {
        {
          if (resolveFamily === null) {
            return type;
          }

          var family = resolveFamily(type);

          if (family === undefined) {
            return type;
          }

          return family.current;
        }
      }

      function resolveClassForHotReloading(type) {
        return resolveFunctionForHotReloading(type);
      }

      function resolveForwardRefForHotReloading(type) {
        {
          if (resolveFamily === null) {
            return type;
          }

          var family = resolveFamily(type);

          if (family === undefined) {
            if (type !== null && type !== undefined && typeof type.render === "function") {
              var currentRender = resolveFunctionForHotReloading(type.render);

              if (type.render !== currentRender) {
                var syntheticType = {
                  $$typeof: REACT_FORWARD_REF_TYPE,
                  render: currentRender
                };

                if (type.displayName !== undefined) {
                  syntheticType.displayName = type.displayName;
                }

                return syntheticType;
              }
            }

            return type;
          }

          return family.current;
        }
      }

      function isCompatibleFamilyForHotReloading(fiber, element) {
        {
          if (resolveFamily === null) {
            return false;
          }

          var prevType = fiber.elementType;
          var nextType = element.type;
          var needsCompareFamilies = false;
          var $$typeofNextType = typeof nextType === "object" && nextType !== null ? nextType.$$typeof : null;

          switch (fiber.tag) {
            case ClassComponent:
              {
                if (typeof nextType === "function") {
                  needsCompareFamilies = true;
                }

                break;
              }

            case FunctionComponent:
              {
                if (typeof nextType === "function") {
                  needsCompareFamilies = true;
                } else if ($$typeofNextType === REACT_LAZY_TYPE) {
                  needsCompareFamilies = true;
                }

                break;
              }

            case ForwardRef:
              {
                if ($$typeofNextType === REACT_FORWARD_REF_TYPE) {
                  needsCompareFamilies = true;
                } else if ($$typeofNextType === REACT_LAZY_TYPE) {
                  needsCompareFamilies = true;
                }

                break;
              }

            case MemoComponent:
            case SimpleMemoComponent:
              {
                if ($$typeofNextType === REACT_MEMO_TYPE) {
                  needsCompareFamilies = true;
                } else if ($$typeofNextType === REACT_LAZY_TYPE) {
                  needsCompareFamilies = true;
                }

                break;
              }

            default:
              return false;
          }

          if (needsCompareFamilies) {
            var prevFamily = resolveFamily(prevType);

            if (prevFamily !== undefined && prevFamily === resolveFamily(nextType)) {
              return true;
            }
          }

          return false;
        }
      }

      function markFailedErrorBoundaryForHotReloading(fiber) {
        {
          if (resolveFamily === null) {
            return;
          }

          if (typeof WeakSet !== "function") {
            return;
          }

          if (failedBoundaries === null) {
            failedBoundaries = new WeakSet();
          }

          failedBoundaries.add(fiber);
        }
      }

      var scheduleRefresh = function scheduleRefresh(root, update) {
        {
          if (resolveFamily === null) {
            return;
          }

          var _staleFamilies = update.staleFamilies,
              _updatedFamilies = update.updatedFamilies;
          flushPassiveEffects();
          flushSync(function () {
            scheduleFibersWithFamiliesRecursively(root.current, _updatedFamilies, _staleFamilies);
          });
        }
      };

      var scheduleRoot = function scheduleRoot(root, element) {
        {
          if (root.context !== emptyContextObject) {
            return;
          }

          flushPassiveEffects();
          updateContainerAtExpirationTime(element, root, null, Sync, null);
        }
      };

      function scheduleFibersWithFamiliesRecursively(fiber, updatedFamilies, staleFamilies) {
        {
          var alternate = fiber.alternate,
              child = fiber.child,
              sibling = fiber.sibling,
              tag = fiber.tag,
              type = fiber.type;
          var candidateType = null;

          switch (tag) {
            case FunctionComponent:
            case SimpleMemoComponent:
            case ClassComponent:
              candidateType = type;
              break;

            case ForwardRef:
              candidateType = type.render;
              break;

            default:
              break;
          }

          if (resolveFamily === null) {
            throw new Error("Expected resolveFamily to be set during hot reload.");
          }

          var needsRender = false;
          var needsRemount = false;

          if (candidateType !== null) {
            var family = resolveFamily(candidateType);

            if (family !== undefined) {
              if (staleFamilies.has(family)) {
                needsRemount = true;
              } else if (updatedFamilies.has(family)) {
                if (tag === ClassComponent) {
                  needsRemount = true;
                } else {
                  needsRender = true;
                }
              }
            }
          }

          if (failedBoundaries !== null) {
            if (failedBoundaries.has(fiber) || alternate !== null && failedBoundaries.has(alternate)) {
              needsRemount = true;
            }
          }

          if (needsRemount) {
            fiber._debugNeedsRemount = true;
          }

          if (needsRemount || needsRender) {
            scheduleWork(fiber, Sync);
          }

          if (child !== null && !needsRemount) {
            scheduleFibersWithFamiliesRecursively(child, updatedFamilies, staleFamilies);
          }

          if (sibling !== null) {
            scheduleFibersWithFamiliesRecursively(sibling, updatedFamilies, staleFamilies);
          }
        }
      }

      var findHostInstancesForRefresh = function findHostInstancesForRefresh(root, families) {
        {
          var hostInstances = new Set();
          var types = new Set(families.map(function (family) {
            return family.current;
          }));
          findHostInstancesForMatchingFibersRecursively(root.current, types, hostInstances);
          return hostInstances;
        }
      };

      function findHostInstancesForMatchingFibersRecursively(fiber, types, hostInstances) {
        {
          var child = fiber.child,
              sibling = fiber.sibling,
              tag = fiber.tag,
              type = fiber.type;
          var candidateType = null;

          switch (tag) {
            case FunctionComponent:
            case SimpleMemoComponent:
            case ClassComponent:
              candidateType = type;
              break;

            case ForwardRef:
              candidateType = type.render;
              break;

            default:
              break;
          }

          var didMatch = false;

          if (candidateType !== null) {
            if (types.has(candidateType)) {
              didMatch = true;
            }
          }

          if (didMatch) {
            findHostInstancesForFiberShallowly(fiber, hostInstances);
          } else {
            if (child !== null) {
              findHostInstancesForMatchingFibersRecursively(child, types, hostInstances);
            }
          }

          if (sibling !== null) {
            findHostInstancesForMatchingFibersRecursively(sibling, types, hostInstances);
          }
        }
      }

      function findHostInstancesForFiberShallowly(fiber, hostInstances) {
        {
          var foundHostInstances = findChildHostInstancesForFiberShallowly(fiber, hostInstances);

          if (foundHostInstances) {
            return;
          }

          var node = fiber;

          while (true) {
            switch (node.tag) {
              case HostComponent:
                hostInstances.add(node.stateNode);
                return;

              case HostPortal:
                hostInstances.add(node.stateNode.containerInfo);
                return;

              case HostRoot:
                hostInstances.add(node.stateNode.containerInfo);
                return;
            }

            if (node.return === null) {
              throw new Error("Expected to reach root first.");
            }

            node = node.return;
          }
        }
      }

      function findChildHostInstancesForFiberShallowly(fiber, hostInstances) {
        {
          var node = fiber;
          var foundHostInstances = false;

          while (true) {
            if (node.tag === HostComponent) {
              foundHostInstances = true;
              hostInstances.add(node.stateNode);
            } else if (node.child !== null) {
              node.child.return = node;
              node = node.child;
              continue;
            }

            if (node === fiber) {
              return foundHostInstances;
            }

            while (node.sibling === null) {
              if (node.return === null || node.return === fiber) {
                return foundHostInstances;
              }

              node = node.return;
            }

            node.sibling.return = node.return;
            node = node.sibling;
          }
        }
        return false;
      }

      function resolveDefaultProps(Component, baseProps) {
        if (Component && Component.defaultProps) {
          var props = _extends({}, baseProps);

          var defaultProps = Component.defaultProps;

          for (var propName in defaultProps) {
            if (props[propName] === undefined) {
              props[propName] = defaultProps[propName];
            }
          }

          return props;
        }

        return baseProps;
      }

      function readLazyComponentType(lazyComponent) {
        var status = lazyComponent._status;
        var result = lazyComponent._result;

        switch (status) {
          case Resolved:
            {
              var Component = result;
              return Component;
            }

          case Rejected:
            {
              var error = result;
              throw error;
            }

          case Pending:
            {
              var thenable = result;
              throw thenable;
            }

          default:
            {
              lazyComponent._status = Pending;
              var ctor = lazyComponent._ctor;

              var _thenable = ctor();

              _thenable.then(function (moduleObject) {
                if (lazyComponent._status === Pending) {
                  var defaultExport = moduleObject.default;
                  {
                    if (defaultExport === undefined) {
                      warning$1(false, "lazy: Expected the result of a dynamic import() call. " + "Instead received: %s\n\nYour code should look like: \n  " + "const MyComponent = lazy(() => import('./MyComponent'))", moduleObject);
                    }
                  }
                  lazyComponent._status = Resolved;
                  lazyComponent._result = defaultExport;
                }
              }, function (error) {
                if (lazyComponent._status === Pending) {
                  lazyComponent._status = Rejected;
                  lazyComponent._result = error;
                }
              });

              switch (lazyComponent._status) {
                case Resolved:
                  return lazyComponent._result;

                case Rejected:
                  throw lazyComponent._result;
              }

              lazyComponent._result = _thenable;
              throw _thenable;
            }
        }
      }

      var valueCursor = createCursor(null);
      var rendererSigil = void 0;
      {
        rendererSigil = {};
      }
      var currentlyRenderingFiber = null;
      var lastContextDependency = null;
      var lastContextWithAllBitsObserved = null;
      var isDisallowedContextReadInDEV = false;

      function resetContextDependencies() {
        currentlyRenderingFiber = null;
        lastContextDependency = null;
        lastContextWithAllBitsObserved = null;
        {
          isDisallowedContextReadInDEV = false;
        }
      }

      function enterDisallowedContextReadInDEV() {
        {
          isDisallowedContextReadInDEV = true;
        }
      }

      function exitDisallowedContextReadInDEV() {
        {
          isDisallowedContextReadInDEV = false;
        }
      }

      function pushProvider(providerFiber, nextValue) {
        var context = providerFiber.type._context;

        if (isPrimaryRenderer) {
          push(valueCursor, context._currentValue, providerFiber);
          context._currentValue = nextValue;
          {
            !(context._currentRenderer === undefined || context._currentRenderer === null || context._currentRenderer === rendererSigil) ? warningWithoutStack$1(false, "Detected multiple renderers concurrently rendering the " + "same context provider. This is currently unsupported.") : void 0;
            context._currentRenderer = rendererSigil;
          }
        } else {
          push(valueCursor, context._currentValue2, providerFiber);
          context._currentValue2 = nextValue;
          {
            !(context._currentRenderer2 === undefined || context._currentRenderer2 === null || context._currentRenderer2 === rendererSigil) ? warningWithoutStack$1(false, "Detected multiple renderers concurrently rendering the " + "same context provider. This is currently unsupported.") : void 0;
            context._currentRenderer2 = rendererSigil;
          }
        }
      }

      function popProvider(providerFiber) {
        var currentValue = valueCursor.current;
        pop(valueCursor, providerFiber);
        var context = providerFiber.type._context;

        if (isPrimaryRenderer) {
          context._currentValue = currentValue;
        } else {
          context._currentValue2 = currentValue;
        }
      }

      function calculateChangedBits(context, newValue, oldValue) {
        if (is(oldValue, newValue)) {
          return 0;
        } else {
          var changedBits = typeof context._calculateChangedBits === "function" ? context._calculateChangedBits(oldValue, newValue) : MAX_SIGNED_31_BIT_INT;
          {
            !((changedBits & MAX_SIGNED_31_BIT_INT) === changedBits) ? warning$1(false, "calculateChangedBits: Expected the return value to be a " + "31-bit integer. Instead received: %s", changedBits) : void 0;
          }
          return changedBits | 0;
        }
      }

      function scheduleWorkOnParentPath(parent, renderExpirationTime) {
        var node = parent;

        while (node !== null) {
          var alternate = node.alternate;

          if (node.childExpirationTime < renderExpirationTime) {
            node.childExpirationTime = renderExpirationTime;

            if (alternate !== null && alternate.childExpirationTime < renderExpirationTime) {
              alternate.childExpirationTime = renderExpirationTime;
            }
          } else if (alternate !== null && alternate.childExpirationTime < renderExpirationTime) {
            alternate.childExpirationTime = renderExpirationTime;
          } else {
            break;
          }

          node = node.return;
        }
      }

      function propagateContextChange(workInProgress, context, changedBits, renderExpirationTime) {
        var fiber = workInProgress.child;

        if (fiber !== null) {
          fiber.return = workInProgress;
        }

        while (fiber !== null) {
          var nextFiber = void 0;
          var list = fiber.dependencies;

          if (list !== null) {
            nextFiber = fiber.child;
            var dependency = list.firstContext;

            while (dependency !== null) {
              if (dependency.context === context && (dependency.observedBits & changedBits) !== 0) {
                if (fiber.tag === ClassComponent) {
                  var update = createUpdate(renderExpirationTime, null);
                  update.tag = ForceUpdate;
                  enqueueUpdate(fiber, update);
                }

                if (fiber.expirationTime < renderExpirationTime) {
                  fiber.expirationTime = renderExpirationTime;
                }

                var alternate = fiber.alternate;

                if (alternate !== null && alternate.expirationTime < renderExpirationTime) {
                  alternate.expirationTime = renderExpirationTime;
                }

                scheduleWorkOnParentPath(fiber.return, renderExpirationTime);

                if (list.expirationTime < renderExpirationTime) {
                  list.expirationTime = renderExpirationTime;
                }

                break;
              }

              dependency = dependency.next;
            }
          } else if (fiber.tag === ContextProvider) {
            nextFiber = fiber.type === workInProgress.type ? null : fiber.child;
          } else if (enableSuspenseServerRenderer && fiber.tag === DehydratedSuspenseComponent) {
            if (fiber.expirationTime < renderExpirationTime) {
              fiber.expirationTime = renderExpirationTime;
            }

            var _alternate = fiber.alternate;

            if (_alternate !== null && _alternate.expirationTime < renderExpirationTime) {
              _alternate.expirationTime = renderExpirationTime;
            }

            scheduleWorkOnParentPath(fiber, renderExpirationTime);
            nextFiber = fiber.sibling;
          } else {
            nextFiber = fiber.child;
          }

          if (nextFiber !== null) {
            nextFiber.return = fiber;
          } else {
            nextFiber = fiber;

            while (nextFiber !== null) {
              if (nextFiber === workInProgress) {
                nextFiber = null;
                break;
              }

              var sibling = nextFiber.sibling;

              if (sibling !== null) {
                sibling.return = nextFiber.return;
                nextFiber = sibling;
                break;
              }

              nextFiber = nextFiber.return;
            }
          }

          fiber = nextFiber;
        }
      }

      function prepareToReadContext(workInProgress, renderExpirationTime) {
        currentlyRenderingFiber = workInProgress;
        lastContextDependency = null;
        lastContextWithAllBitsObserved = null;
        var dependencies = workInProgress.dependencies;

        if (dependencies !== null) {
          var firstContext = dependencies.firstContext;

          if (firstContext !== null) {
            if (dependencies.expirationTime >= renderExpirationTime) {
              markWorkInProgressReceivedUpdate();
            }

            dependencies.firstContext = null;
          }
        }
      }

      function _readContext(context, observedBits) {
        {
          !!isDisallowedContextReadInDEV ? warning$1(false, "Context can only be read while React is rendering. " + "In classes, you can read it in the render method or getDerivedStateFromProps. " + "In function components, you can read it directly in the function body, but not " + "inside Hooks like useReducer() or useMemo().") : void 0;
        }

        if (lastContextWithAllBitsObserved === context) {} else if (observedBits === false || observedBits === 0) {} else {
          var resolvedObservedBits = void 0;

          if (typeof observedBits !== "number" || observedBits === MAX_SIGNED_31_BIT_INT) {
            lastContextWithAllBitsObserved = context;
            resolvedObservedBits = MAX_SIGNED_31_BIT_INT;
          } else {
            resolvedObservedBits = observedBits;
          }

          var contextItem = {
            context: context,
            observedBits: resolvedObservedBits,
            next: null
          };

          if (lastContextDependency === null) {
            (function () {
              if (!(currentlyRenderingFiber !== null)) {
                throw ReactError(Error("Context can only be read while React is rendering. In classes, you can read it in the render method or getDerivedStateFromProps. In function components, you can read it directly in the function body, but not inside Hooks like useReducer() or useMemo()."));
              }
            })();

            lastContextDependency = contextItem;
            currentlyRenderingFiber.dependencies = {
              expirationTime: NoWork,
              firstContext: contextItem,
              responders: null
            };
          } else {
            lastContextDependency = lastContextDependency.next = contextItem;
          }
        }

        return isPrimaryRenderer ? context._currentValue : context._currentValue2;
      }

      var UpdateState = 0;
      var ReplaceState = 1;
      var ForceUpdate = 2;
      var CaptureUpdate = 3;
      var hasForceUpdate = false;
      var didWarnUpdateInsideUpdate = void 0;
      var currentlyProcessingQueue = void 0;
      {
        didWarnUpdateInsideUpdate = false;
        currentlyProcessingQueue = null;
      }

      function createUpdateQueue(baseState) {
        var queue = {
          baseState: baseState,
          firstUpdate: null,
          lastUpdate: null,
          firstCapturedUpdate: null,
          lastCapturedUpdate: null,
          firstEffect: null,
          lastEffect: null,
          firstCapturedEffect: null,
          lastCapturedEffect: null
        };
        return queue;
      }

      function cloneUpdateQueue(currentQueue) {
        var queue = {
          baseState: currentQueue.baseState,
          firstUpdate: currentQueue.firstUpdate,
          lastUpdate: currentQueue.lastUpdate,
          firstCapturedUpdate: null,
          lastCapturedUpdate: null,
          firstEffect: null,
          lastEffect: null,
          firstCapturedEffect: null,
          lastCapturedEffect: null
        };
        return queue;
      }

      function createUpdate(expirationTime, suspenseConfig) {
        var update = {
          expirationTime: expirationTime,
          suspenseConfig: suspenseConfig,
          tag: UpdateState,
          payload: null,
          callback: null,
          next: null,
          nextEffect: null
        };
        {
          update.priority = getCurrentPriorityLevel();
        }
        return update;
      }

      function appendUpdateToQueue(queue, update) {
        if (queue.lastUpdate === null) {
          queue.firstUpdate = queue.lastUpdate = update;
        } else {
          queue.lastUpdate.next = update;
          queue.lastUpdate = update;
        }
      }

      function enqueueUpdate(fiber, update) {
        var alternate = fiber.alternate;
        var queue1 = void 0;
        var queue2 = void 0;

        if (alternate === null) {
          queue1 = fiber.updateQueue;
          queue2 = null;

          if (queue1 === null) {
            queue1 = fiber.updateQueue = createUpdateQueue(fiber.memoizedState);
          }
        } else {
          queue1 = fiber.updateQueue;
          queue2 = alternate.updateQueue;

          if (queue1 === null) {
            if (queue2 === null) {
              queue1 = fiber.updateQueue = createUpdateQueue(fiber.memoizedState);
              queue2 = alternate.updateQueue = createUpdateQueue(alternate.memoizedState);
            } else {
              queue1 = fiber.updateQueue = cloneUpdateQueue(queue2);
            }
          } else {
            if (queue2 === null) {
              queue2 = alternate.updateQueue = cloneUpdateQueue(queue1);
            } else {}
          }
        }

        if (queue2 === null || queue1 === queue2) {
          appendUpdateToQueue(queue1, update);
        } else {
          if (queue1.lastUpdate === null || queue2.lastUpdate === null) {
            appendUpdateToQueue(queue1, update);
            appendUpdateToQueue(queue2, update);
          } else {
            appendUpdateToQueue(queue1, update);
            queue2.lastUpdate = update;
          }
        }

        {
          if (fiber.tag === ClassComponent && (currentlyProcessingQueue === queue1 || queue2 !== null && currentlyProcessingQueue === queue2) && !didWarnUpdateInsideUpdate) {
            warningWithoutStack$1(false, "An update (setState, replaceState, or forceUpdate) was scheduled " + "from inside an update function. Update functions should be pure, " + "with zero side-effects. Consider using componentDidUpdate or a " + "callback.");
            didWarnUpdateInsideUpdate = true;
          }
        }
      }

      function enqueueCapturedUpdate(workInProgress, update) {
        var workInProgressQueue = workInProgress.updateQueue;

        if (workInProgressQueue === null) {
          workInProgressQueue = workInProgress.updateQueue = createUpdateQueue(workInProgress.memoizedState);
        } else {
          workInProgressQueue = ensureWorkInProgressQueueIsAClone(workInProgress, workInProgressQueue);
        }

        if (workInProgressQueue.lastCapturedUpdate === null) {
          workInProgressQueue.firstCapturedUpdate = workInProgressQueue.lastCapturedUpdate = update;
        } else {
          workInProgressQueue.lastCapturedUpdate.next = update;
          workInProgressQueue.lastCapturedUpdate = update;
        }
      }

      function ensureWorkInProgressQueueIsAClone(workInProgress, queue) {
        var current = workInProgress.alternate;

        if (current !== null) {
          if (queue === current.updateQueue) {
            queue = workInProgress.updateQueue = cloneUpdateQueue(queue);
          }
        }

        return queue;
      }

      function getStateFromUpdate(workInProgress, queue, update, prevState, nextProps, instance) {
        switch (update.tag) {
          case ReplaceState:
            {
              var _payload = update.payload;

              if (typeof _payload === "function") {
                {
                  enterDisallowedContextReadInDEV();

                  if (debugRenderPhaseSideEffects || debugRenderPhaseSideEffectsForStrictMode && workInProgress.mode & StrictMode) {
                    _payload.call(instance, prevState, nextProps);
                  }
                }

                var nextState = _payload.call(instance, prevState, nextProps);

                {
                  exitDisallowedContextReadInDEV();
                }
                return nextState;
              }

              return _payload;
            }

          case CaptureUpdate:
            {
              workInProgress.effectTag = workInProgress.effectTag & ~ShouldCapture | DidCapture;
            }

          case UpdateState:
            {
              var _payload2 = update.payload;
              var partialState = void 0;

              if (typeof _payload2 === "function") {
                {
                  enterDisallowedContextReadInDEV();

                  if (debugRenderPhaseSideEffects || debugRenderPhaseSideEffectsForStrictMode && workInProgress.mode & StrictMode) {
                    _payload2.call(instance, prevState, nextProps);
                  }
                }
                partialState = _payload2.call(instance, prevState, nextProps);
                {
                  exitDisallowedContextReadInDEV();
                }
              } else {
                partialState = _payload2;
              }

              if (partialState === null || partialState === undefined) {
                return prevState;
              }

              return _extends({}, prevState, partialState);
            }

          case ForceUpdate:
            {
              hasForceUpdate = true;
              return prevState;
            }
        }

        return prevState;
      }

      function processUpdateQueue(workInProgress, queue, props, instance, renderExpirationTime) {
        hasForceUpdate = false;
        queue = ensureWorkInProgressQueueIsAClone(workInProgress, queue);
        {
          currentlyProcessingQueue = queue;
        }
        var newBaseState = queue.baseState;
        var newFirstUpdate = null;
        var newExpirationTime = NoWork;
        var update = queue.firstUpdate;
        var resultState = newBaseState;

        while (update !== null) {
          var updateExpirationTime = update.expirationTime;

          if (updateExpirationTime < renderExpirationTime) {
            if (newFirstUpdate === null) {
              newFirstUpdate = update;
              newBaseState = resultState;
            }

            if (newExpirationTime < updateExpirationTime) {
              newExpirationTime = updateExpirationTime;
            }
          } else {
            markRenderEventTimeAndConfig(updateExpirationTime, update.suspenseConfig);
            resultState = getStateFromUpdate(workInProgress, queue, update, resultState, props, instance);
            var _callback = update.callback;

            if (_callback !== null) {
              workInProgress.effectTag |= Callback;
              update.nextEffect = null;

              if (queue.lastEffect === null) {
                queue.firstEffect = queue.lastEffect = update;
              } else {
                queue.lastEffect.nextEffect = update;
                queue.lastEffect = update;
              }
            }
          }

          update = update.next;
        }

        var newFirstCapturedUpdate = null;
        update = queue.firstCapturedUpdate;

        while (update !== null) {
          var _updateExpirationTime = update.expirationTime;

          if (_updateExpirationTime < renderExpirationTime) {
            if (newFirstCapturedUpdate === null) {
              newFirstCapturedUpdate = update;

              if (newFirstUpdate === null) {
                newBaseState = resultState;
              }
            }

            if (newExpirationTime < _updateExpirationTime) {
              newExpirationTime = _updateExpirationTime;
            }
          } else {
            resultState = getStateFromUpdate(workInProgress, queue, update, resultState, props, instance);
            var _callback2 = update.callback;

            if (_callback2 !== null) {
              workInProgress.effectTag |= Callback;
              update.nextEffect = null;

              if (queue.lastCapturedEffect === null) {
                queue.firstCapturedEffect = queue.lastCapturedEffect = update;
              } else {
                queue.lastCapturedEffect.nextEffect = update;
                queue.lastCapturedEffect = update;
              }
            }
          }

          update = update.next;
        }

        if (newFirstUpdate === null) {
          queue.lastUpdate = null;
        }

        if (newFirstCapturedUpdate === null) {
          queue.lastCapturedUpdate = null;
        } else {
          workInProgress.effectTag |= Callback;
        }

        if (newFirstUpdate === null && newFirstCapturedUpdate === null) {
          newBaseState = resultState;
        }

        queue.baseState = newBaseState;
        queue.firstUpdate = newFirstUpdate;
        queue.firstCapturedUpdate = newFirstCapturedUpdate;
        workInProgress.expirationTime = newExpirationTime;
        workInProgress.memoizedState = resultState;
        {
          currentlyProcessingQueue = null;
        }
      }

      function callCallback(callback, context) {
        (function () {
          if (!(typeof callback === "function")) {
            throw ReactError(Error("Invalid argument passed as callback. Expected a function. Instead received: " + callback));
          }
        })();

        callback.call(context);
      }

      function resetHasForceUpdateBeforeProcessing() {
        hasForceUpdate = false;
      }

      function checkHasForceUpdateAfterProcessing() {
        return hasForceUpdate;
      }

      function commitUpdateQueue(finishedWork, finishedQueue, instance, renderExpirationTime) {
        if (finishedQueue.firstCapturedUpdate !== null) {
          if (finishedQueue.lastUpdate !== null) {
            finishedQueue.lastUpdate.next = finishedQueue.firstCapturedUpdate;
            finishedQueue.lastUpdate = finishedQueue.lastCapturedUpdate;
          }

          finishedQueue.firstCapturedUpdate = finishedQueue.lastCapturedUpdate = null;
        }

        commitUpdateEffects(finishedQueue.firstEffect, instance);
        finishedQueue.firstEffect = finishedQueue.lastEffect = null;
        commitUpdateEffects(finishedQueue.firstCapturedEffect, instance);
        finishedQueue.firstCapturedEffect = finishedQueue.lastCapturedEffect = null;
      }

      function commitUpdateEffects(effect, instance) {
        while (effect !== null) {
          var _callback3 = effect.callback;

          if (_callback3 !== null) {
            effect.callback = null;
            callCallback(_callback3, instance);
          }

          effect = effect.nextEffect;
        }
      }

      var ReactCurrentBatchConfig = ReactSharedInternals.ReactCurrentBatchConfig;

      function requestCurrentSuspenseConfig() {
        return ReactCurrentBatchConfig.suspense;
      }

      var fakeInternalInstance = {};
      var isArray$1 = Array.isArray;
      var emptyRefsObject = new React.Component().refs;
      var didWarnAboutStateAssignmentForComponent = void 0;
      var didWarnAboutUninitializedState = void 0;
      var didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate = void 0;
      var didWarnAboutLegacyLifecyclesAndDerivedState = void 0;
      var didWarnAboutUndefinedDerivedState = void 0;
      var warnOnUndefinedDerivedState = void 0;
      var warnOnInvalidCallback = void 0;
      var didWarnAboutDirectlyAssigningPropsToState = void 0;
      var didWarnAboutContextTypeAndContextTypes = void 0;
      var didWarnAboutInvalidateContextType = void 0;
      {
        didWarnAboutStateAssignmentForComponent = new Set();
        didWarnAboutUninitializedState = new Set();
        didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate = new Set();
        didWarnAboutLegacyLifecyclesAndDerivedState = new Set();
        didWarnAboutDirectlyAssigningPropsToState = new Set();
        didWarnAboutUndefinedDerivedState = new Set();
        didWarnAboutContextTypeAndContextTypes = new Set();
        didWarnAboutInvalidateContextType = new Set();
        var didWarnOnInvalidCallback = new Set();

        warnOnInvalidCallback = function warnOnInvalidCallback(callback, callerName) {
          if (callback === null || typeof callback === "function") {
            return;
          }

          var key = callerName + "_" + callback;

          if (!didWarnOnInvalidCallback.has(key)) {
            didWarnOnInvalidCallback.add(key);
            warningWithoutStack$1(false, "%s(...): Expected the last optional `callback` argument to be a " + "function. Instead received: %s.", callerName, callback);
          }
        };

        warnOnUndefinedDerivedState = function warnOnUndefinedDerivedState(type, partialState) {
          if (partialState === undefined) {
            var componentName = getComponentName(type) || "Component";

            if (!didWarnAboutUndefinedDerivedState.has(componentName)) {
              didWarnAboutUndefinedDerivedState.add(componentName);
              warningWithoutStack$1(false, "%s.getDerivedStateFromProps(): A valid state object (or null) must be returned. " + "You have returned undefined.", componentName);
            }
          }
        };

        Object.defineProperty(fakeInternalInstance, "_processChildContext", {
          enumerable: false,
          value: function value() {
            (function () {
              {
                throw ReactError(Error("_processChildContext is not available in React 16+. This likely means you have multiple copies of React and are attempting to nest a React 15 tree inside a React 16 tree using unstable_renderSubtreeIntoContainer, which isn't supported. Try to make sure you have only one copy of React (and ideally, switch to ReactDOM.createPortal)."));
              }
            })();
          }
        });
        Object.freeze(fakeInternalInstance);
      }

      function applyDerivedStateFromProps(workInProgress, ctor, getDerivedStateFromProps, nextProps) {
        var prevState = workInProgress.memoizedState;
        {
          if (debugRenderPhaseSideEffects || debugRenderPhaseSideEffectsForStrictMode && workInProgress.mode & StrictMode) {
            getDerivedStateFromProps(nextProps, prevState);
          }
        }
        var partialState = getDerivedStateFromProps(nextProps, prevState);
        {
          warnOnUndefinedDerivedState(ctor, partialState);
        }
        var memoizedState = partialState === null || partialState === undefined ? prevState : _extends({}, prevState, partialState);
        workInProgress.memoizedState = memoizedState;
        var updateQueue = workInProgress.updateQueue;

        if (updateQueue !== null && workInProgress.expirationTime === NoWork) {
          updateQueue.baseState = memoizedState;
        }
      }

      var classComponentUpdater = {
        isMounted: isMounted,
        enqueueSetState: function enqueueSetState(inst, payload, callback) {
          var fiber = get(inst);
          var currentTime = requestCurrentTime();
          var suspenseConfig = requestCurrentSuspenseConfig();
          var expirationTime = computeExpirationForFiber(currentTime, fiber, suspenseConfig);
          var update = createUpdate(expirationTime, suspenseConfig);
          update.payload = payload;

          if (callback !== undefined && callback !== null) {
            {
              warnOnInvalidCallback(callback, "setState");
            }
            update.callback = callback;
          }

          if (revertPassiveEffectsChange) {
            flushPassiveEffects();
          }

          enqueueUpdate(fiber, update);
          scheduleWork(fiber, expirationTime);
        },
        enqueueReplaceState: function enqueueReplaceState(inst, payload, callback) {
          var fiber = get(inst);
          var currentTime = requestCurrentTime();
          var suspenseConfig = requestCurrentSuspenseConfig();
          var expirationTime = computeExpirationForFiber(currentTime, fiber, suspenseConfig);
          var update = createUpdate(expirationTime, suspenseConfig);
          update.tag = ReplaceState;
          update.payload = payload;

          if (callback !== undefined && callback !== null) {
            {
              warnOnInvalidCallback(callback, "replaceState");
            }
            update.callback = callback;
          }

          if (revertPassiveEffectsChange) {
            flushPassiveEffects();
          }

          enqueueUpdate(fiber, update);
          scheduleWork(fiber, expirationTime);
        },
        enqueueForceUpdate: function enqueueForceUpdate(inst, callback) {
          var fiber = get(inst);
          var currentTime = requestCurrentTime();
          var suspenseConfig = requestCurrentSuspenseConfig();
          var expirationTime = computeExpirationForFiber(currentTime, fiber, suspenseConfig);
          var update = createUpdate(expirationTime, suspenseConfig);
          update.tag = ForceUpdate;

          if (callback !== undefined && callback !== null) {
            {
              warnOnInvalidCallback(callback, "forceUpdate");
            }
            update.callback = callback;
          }

          if (revertPassiveEffectsChange) {
            flushPassiveEffects();
          }

          enqueueUpdate(fiber, update);
          scheduleWork(fiber, expirationTime);
        }
      };

      function checkShouldComponentUpdate(workInProgress, ctor, oldProps, newProps, oldState, newState, nextContext) {
        var instance = workInProgress.stateNode;

        if (typeof instance.shouldComponentUpdate === "function") {
          startPhaseTimer(workInProgress, "shouldComponentUpdate");
          var shouldUpdate = instance.shouldComponentUpdate(newProps, newState, nextContext);
          stopPhaseTimer();
          {
            !(shouldUpdate !== undefined) ? warningWithoutStack$1(false, "%s.shouldComponentUpdate(): Returned undefined instead of a " + "boolean value. Make sure to return true or false.", getComponentName(ctor) || "Component") : void 0;
          }
          return shouldUpdate;
        }

        if (ctor.prototype && ctor.prototype.isPureReactComponent) {
          return !shallowEqual(oldProps, newProps) || !shallowEqual(oldState, newState);
        }

        return true;
      }

      function checkClassInstance(workInProgress, ctor, newProps) {
        var instance = workInProgress.stateNode;
        {
          var name = getComponentName(ctor) || "Component";
          var renderPresent = instance.render;

          if (!renderPresent) {
            if (ctor.prototype && typeof ctor.prototype.render === "function") {
              warningWithoutStack$1(false, "%s(...): No `render` method found on the returned component " + "instance: did you accidentally return an object from the constructor?", name);
            } else {
              warningWithoutStack$1(false, "%s(...): No `render` method found on the returned component " + "instance: you may have forgotten to define `render`.", name);
            }
          }

          var noGetInitialStateOnES6 = !instance.getInitialState || instance.getInitialState.isReactClassApproved || instance.state;
          !noGetInitialStateOnES6 ? warningWithoutStack$1(false, "getInitialState was defined on %s, a plain JavaScript class. " + "This is only supported for classes created using React.createClass. " + "Did you mean to define a state property instead?", name) : void 0;
          var noGetDefaultPropsOnES6 = !instance.getDefaultProps || instance.getDefaultProps.isReactClassApproved;
          !noGetDefaultPropsOnES6 ? warningWithoutStack$1(false, "getDefaultProps was defined on %s, a plain JavaScript class. " + "This is only supported for classes created using React.createClass. " + "Use a static property to define defaultProps instead.", name) : void 0;
          var noInstancePropTypes = !instance.propTypes;
          !noInstancePropTypes ? warningWithoutStack$1(false, "propTypes was defined as an instance property on %s. Use a static " + "property to define propTypes instead.", name) : void 0;
          var noInstanceContextType = !instance.contextType;
          !noInstanceContextType ? warningWithoutStack$1(false, "contextType was defined as an instance property on %s. Use a static " + "property to define contextType instead.", name) : void 0;

          if (disableLegacyContext) {
            if (ctor.childContextTypes) {
              warningWithoutStack$1(false, "%s uses the legacy childContextTypes API which is no longer supported. " + "Use React.createContext() instead.", name);
            }

            if (ctor.contextTypes) {
              warningWithoutStack$1(false, "%s uses the legacy contextTypes API which is no longer supported. " + "Use React.createContext() with static contextType instead.", name);
            }
          } else {
            var noInstanceContextTypes = !instance.contextTypes;
            !noInstanceContextTypes ? warningWithoutStack$1(false, "contextTypes was defined as an instance property on %s. Use a static " + "property to define contextTypes instead.", name) : void 0;

            if (ctor.contextType && ctor.contextTypes && !didWarnAboutContextTypeAndContextTypes.has(ctor)) {
              didWarnAboutContextTypeAndContextTypes.add(ctor);
              warningWithoutStack$1(false, "%s declares both contextTypes and contextType static properties. " + "The legacy contextTypes property will be ignored.", name);
            }
          }

          var noComponentShouldUpdate = typeof instance.componentShouldUpdate !== "function";
          !noComponentShouldUpdate ? warningWithoutStack$1(false, "%s has a method called " + "componentShouldUpdate(). Did you mean shouldComponentUpdate()? " + "The name is phrased as a question because the function is " + "expected to return a value.", name) : void 0;

          if (ctor.prototype && ctor.prototype.isPureReactComponent && typeof instance.shouldComponentUpdate !== "undefined") {
            warningWithoutStack$1(false, "%s has a method called shouldComponentUpdate(). " + "shouldComponentUpdate should not be used when extending React.PureComponent. " + "Please extend React.Component if shouldComponentUpdate is used.", getComponentName(ctor) || "A pure component");
          }

          var noComponentDidUnmount = typeof instance.componentDidUnmount !== "function";
          !noComponentDidUnmount ? warningWithoutStack$1(false, "%s has a method called " + "componentDidUnmount(). But there is no such lifecycle method. " + "Did you mean componentWillUnmount()?", name) : void 0;
          var noComponentDidReceiveProps = typeof instance.componentDidReceiveProps !== "function";
          !noComponentDidReceiveProps ? warningWithoutStack$1(false, "%s has a method called " + "componentDidReceiveProps(). But there is no such lifecycle method. " + "If you meant to update the state in response to changing props, " + "use componentWillReceiveProps(). If you meant to fetch data or " + "run side-effects or mutations after React has updated the UI, use componentDidUpdate().", name) : void 0;
          var noComponentWillRecieveProps = typeof instance.componentWillRecieveProps !== "function";
          !noComponentWillRecieveProps ? warningWithoutStack$1(false, "%s has a method called " + "componentWillRecieveProps(). Did you mean componentWillReceiveProps()?", name) : void 0;
          var noUnsafeComponentWillRecieveProps = typeof instance.UNSAFE_componentWillRecieveProps !== "function";
          !noUnsafeComponentWillRecieveProps ? warningWithoutStack$1(false, "%s has a method called " + "UNSAFE_componentWillRecieveProps(). Did you mean UNSAFE_componentWillReceiveProps()?", name) : void 0;
          var hasMutatedProps = instance.props !== newProps;
          !(instance.props === undefined || !hasMutatedProps) ? warningWithoutStack$1(false, "%s(...): When calling super() in `%s`, make sure to pass " + "up the same props that your component's constructor was passed.", name, name) : void 0;
          var noInstanceDefaultProps = !instance.defaultProps;
          !noInstanceDefaultProps ? warningWithoutStack$1(false, "Setting defaultProps as an instance property on %s is not supported and will be ignored." + " Instead, define defaultProps as a static property on %s.", name, name) : void 0;

          if (typeof instance.getSnapshotBeforeUpdate === "function" && typeof instance.componentDidUpdate !== "function" && !didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate.has(ctor)) {
            didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate.add(ctor);
            warningWithoutStack$1(false, "%s: getSnapshotBeforeUpdate() should be used with componentDidUpdate(). " + "This component defines getSnapshotBeforeUpdate() only.", getComponentName(ctor));
          }

          var noInstanceGetDerivedStateFromProps = typeof instance.getDerivedStateFromProps !== "function";
          !noInstanceGetDerivedStateFromProps ? warningWithoutStack$1(false, "%s: getDerivedStateFromProps() is defined as an instance method " + "and will be ignored. Instead, declare it as a static method.", name) : void 0;
          var noInstanceGetDerivedStateFromCatch = typeof instance.getDerivedStateFromError !== "function";
          !noInstanceGetDerivedStateFromCatch ? warningWithoutStack$1(false, "%s: getDerivedStateFromError() is defined as an instance method " + "and will be ignored. Instead, declare it as a static method.", name) : void 0;
          var noStaticGetSnapshotBeforeUpdate = typeof ctor.getSnapshotBeforeUpdate !== "function";
          !noStaticGetSnapshotBeforeUpdate ? warningWithoutStack$1(false, "%s: getSnapshotBeforeUpdate() is defined as a static method " + "and will be ignored. Instead, declare it as an instance method.", name) : void 0;
          var _state = instance.state;

          if (_state && (typeof _state !== "object" || isArray$1(_state))) {
            warningWithoutStack$1(false, "%s.state: must be set to an object or null", name);
          }

          if (typeof instance.getChildContext === "function") {
            !(typeof ctor.childContextTypes === "object") ? warningWithoutStack$1(false, "%s.getChildContext(): childContextTypes must be defined in order to " + "use getChildContext().", name) : void 0;
          }
        }
      }

      function adoptClassInstance(workInProgress, instance) {
        instance.updater = classComponentUpdater;
        workInProgress.stateNode = instance;
        set(instance, workInProgress);
        {
          instance._reactInternalInstance = fakeInternalInstance;
        }
      }

      function constructClassInstance(workInProgress, ctor, props, renderExpirationTime) {
        var isLegacyContextConsumer = false;
        var unmaskedContext = emptyContextObject;
        var context = emptyContextObject;
        var contextType = ctor.contextType;
        {
          if ("contextType" in ctor) {
            var isValid = contextType === null || contextType !== undefined && contextType.$$typeof === REACT_CONTEXT_TYPE && contextType._context === undefined;

            if (!isValid && !didWarnAboutInvalidateContextType.has(ctor)) {
              didWarnAboutInvalidateContextType.add(ctor);
              var addendum = "";

              if (contextType === undefined) {
                addendum = " However, it is set to undefined. " + "This can be caused by a typo or by mixing up named and default imports. " + "This can also happen due to a circular dependency, so " + "try moving the createContext() call to a separate file.";
              } else if (typeof contextType !== "object") {
                addendum = " However, it is set to a " + typeof contextType + ".";
              } else if (contextType.$$typeof === REACT_PROVIDER_TYPE) {
                addendum = " Did you accidentally pass the Context.Provider instead?";
              } else if (contextType._context !== undefined) {
                addendum = " Did you accidentally pass the Context.Consumer instead?";
              } else {
                addendum = " However, it is set to an object with keys {" + Object.keys(contextType).join(", ") + "}.";
              }

              warningWithoutStack$1(false, "%s defines an invalid contextType. " + "contextType should point to the Context object returned by React.createContext().%s", getComponentName(ctor) || "Component", addendum);
            }
          }
        }

        if (typeof contextType === "object" && contextType !== null) {
          context = _readContext(contextType);
        } else if (!disableLegacyContext) {
          unmaskedContext = getUnmaskedContext(workInProgress, ctor, true);
          var contextTypes = ctor.contextTypes;
          isLegacyContextConsumer = contextTypes !== null && contextTypes !== undefined;
          context = isLegacyContextConsumer ? getMaskedContext(workInProgress, unmaskedContext) : emptyContextObject;
        }

        {
          if (debugRenderPhaseSideEffects || debugRenderPhaseSideEffectsForStrictMode && workInProgress.mode & StrictMode) {
            new ctor(props, context);
          }
        }
        var instance = new ctor(props, context);
        var state = workInProgress.memoizedState = instance.state !== null && instance.state !== undefined ? instance.state : null;
        adoptClassInstance(workInProgress, instance);
        {
          if (typeof ctor.getDerivedStateFromProps === "function" && state === null) {
            var componentName = getComponentName(ctor) || "Component";

            if (!didWarnAboutUninitializedState.has(componentName)) {
              didWarnAboutUninitializedState.add(componentName);
              warningWithoutStack$1(false, "`%s` uses `getDerivedStateFromProps` but its initial state is " + "%s. This is not recommended. Instead, define the initial state by " + "assigning an object to `this.state` in the constructor of `%s`. " + "This ensures that `getDerivedStateFromProps` arguments have a consistent shape.", componentName, instance.state === null ? "null" : "undefined", componentName);
            }
          }

          if (typeof ctor.getDerivedStateFromProps === "function" || typeof instance.getSnapshotBeforeUpdate === "function") {
            var foundWillMountName = null;
            var foundWillReceivePropsName = null;
            var foundWillUpdateName = null;

            if (typeof instance.componentWillMount === "function" && instance.componentWillMount.__suppressDeprecationWarning !== true) {
              foundWillMountName = "componentWillMount";
            } else if (typeof instance.UNSAFE_componentWillMount === "function") {
              foundWillMountName = "UNSAFE_componentWillMount";
            }

            if (typeof instance.componentWillReceiveProps === "function" && instance.componentWillReceiveProps.__suppressDeprecationWarning !== true) {
              foundWillReceivePropsName = "componentWillReceiveProps";
            } else if (typeof instance.UNSAFE_componentWillReceiveProps === "function") {
              foundWillReceivePropsName = "UNSAFE_componentWillReceiveProps";
            }

            if (typeof instance.componentWillUpdate === "function" && instance.componentWillUpdate.__suppressDeprecationWarning !== true) {
              foundWillUpdateName = "componentWillUpdate";
            } else if (typeof instance.UNSAFE_componentWillUpdate === "function") {
              foundWillUpdateName = "UNSAFE_componentWillUpdate";
            }

            if (foundWillMountName !== null || foundWillReceivePropsName !== null || foundWillUpdateName !== null) {
              var _componentName = getComponentName(ctor) || "Component";

              var newApiName = typeof ctor.getDerivedStateFromProps === "function" ? "getDerivedStateFromProps()" : "getSnapshotBeforeUpdate()";

              if (!didWarnAboutLegacyLifecyclesAndDerivedState.has(_componentName)) {
                didWarnAboutLegacyLifecyclesAndDerivedState.add(_componentName);
                warningWithoutStack$1(false, "Unsafe legacy lifecycles will not be called for components using new component APIs.\n\n" + "%s uses %s but also contains the following legacy lifecycles:%s%s%s\n\n" + "The above lifecycles should be removed. Learn more about this warning here:\n" + "https://fb.me/react-async-component-lifecycle-hooks", _componentName, newApiName, foundWillMountName !== null ? "\n  " + foundWillMountName : "", foundWillReceivePropsName !== null ? "\n  " + foundWillReceivePropsName : "", foundWillUpdateName !== null ? "\n  " + foundWillUpdateName : "");
              }
            }
          }
        }

        if (isLegacyContextConsumer) {
          cacheContext(workInProgress, unmaskedContext, context);
        }

        return instance;
      }

      function callComponentWillMount(workInProgress, instance) {
        startPhaseTimer(workInProgress, "componentWillMount");
        var oldState = instance.state;

        if (typeof instance.componentWillMount === "function") {
          instance.componentWillMount();
        }

        if (typeof instance.UNSAFE_componentWillMount === "function") {
          instance.UNSAFE_componentWillMount();
        }

        stopPhaseTimer();

        if (oldState !== instance.state) {
          {
            warningWithoutStack$1(false, "%s.componentWillMount(): Assigning directly to this.state is " + "deprecated (except inside a component's " + "constructor). Use setState instead.", getComponentName(workInProgress.type) || "Component");
          }
          classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
        }
      }

      function callComponentWillReceiveProps(workInProgress, instance, newProps, nextContext) {
        var oldState = instance.state;
        startPhaseTimer(workInProgress, "componentWillReceiveProps");

        if (typeof instance.componentWillReceiveProps === "function") {
          instance.componentWillReceiveProps(newProps, nextContext);
        }

        if (typeof instance.UNSAFE_componentWillReceiveProps === "function") {
          instance.UNSAFE_componentWillReceiveProps(newProps, nextContext);
        }

        stopPhaseTimer();

        if (instance.state !== oldState) {
          {
            var componentName = getComponentName(workInProgress.type) || "Component";

            if (!didWarnAboutStateAssignmentForComponent.has(componentName)) {
              didWarnAboutStateAssignmentForComponent.add(componentName);
              warningWithoutStack$1(false, "%s.componentWillReceiveProps(): Assigning directly to " + "this.state is deprecated (except inside a component's " + "constructor). Use setState instead.", componentName);
            }
          }
          classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
        }
      }

      function mountClassInstance(workInProgress, ctor, newProps, renderExpirationTime) {
        {
          checkClassInstance(workInProgress, ctor, newProps);
        }
        var instance = workInProgress.stateNode;
        instance.props = newProps;
        instance.state = workInProgress.memoizedState;
        instance.refs = emptyRefsObject;
        var contextType = ctor.contextType;

        if (typeof contextType === "object" && contextType !== null) {
          instance.context = _readContext(contextType);
        } else if (disableLegacyContext) {
          instance.context = emptyContextObject;
        } else {
          var unmaskedContext = getUnmaskedContext(workInProgress, ctor, true);
          instance.context = getMaskedContext(workInProgress, unmaskedContext);
        }

        {
          if (instance.state === newProps) {
            var componentName = getComponentName(ctor) || "Component";

            if (!didWarnAboutDirectlyAssigningPropsToState.has(componentName)) {
              didWarnAboutDirectlyAssigningPropsToState.add(componentName);
              warningWithoutStack$1(false, "%s: It is not recommended to assign props directly to state " + "because updates to props won't be reflected in state. " + "In most cases, it is better to use props directly.", componentName);
            }
          }

          if (workInProgress.mode & StrictMode) {
            ReactStrictModeWarnings.recordLegacyContextWarning(workInProgress, instance);
          }

          if (warnAboutDeprecatedLifecycles) {
            ReactStrictModeWarnings.recordUnsafeLifecycleWarnings(workInProgress, instance);
          }
        }
        var updateQueue = workInProgress.updateQueue;

        if (updateQueue !== null) {
          processUpdateQueue(workInProgress, updateQueue, newProps, instance, renderExpirationTime);
          instance.state = workInProgress.memoizedState;
        }

        var getDerivedStateFromProps = ctor.getDerivedStateFromProps;

        if (typeof getDerivedStateFromProps === "function") {
          applyDerivedStateFromProps(workInProgress, ctor, getDerivedStateFromProps, newProps);
          instance.state = workInProgress.memoizedState;
        }

        if (typeof ctor.getDerivedStateFromProps !== "function" && typeof instance.getSnapshotBeforeUpdate !== "function" && (typeof instance.UNSAFE_componentWillMount === "function" || typeof instance.componentWillMount === "function")) {
          callComponentWillMount(workInProgress, instance);
          updateQueue = workInProgress.updateQueue;

          if (updateQueue !== null) {
            processUpdateQueue(workInProgress, updateQueue, newProps, instance, renderExpirationTime);
            instance.state = workInProgress.memoizedState;
          }
        }

        if (typeof instance.componentDidMount === "function") {
          workInProgress.effectTag |= Update;
        }
      }

      function resumeMountClassInstance(workInProgress, ctor, newProps, renderExpirationTime) {
        var instance = workInProgress.stateNode;
        var oldProps = workInProgress.memoizedProps;
        instance.props = oldProps;
        var oldContext = instance.context;
        var contextType = ctor.contextType;
        var nextContext = emptyContextObject;

        if (typeof contextType === "object" && contextType !== null) {
          nextContext = _readContext(contextType);
        } else if (!disableLegacyContext) {
          var nextLegacyUnmaskedContext = getUnmaskedContext(workInProgress, ctor, true);
          nextContext = getMaskedContext(workInProgress, nextLegacyUnmaskedContext);
        }

        var getDerivedStateFromProps = ctor.getDerivedStateFromProps;
        var hasNewLifecycles = typeof getDerivedStateFromProps === "function" || typeof instance.getSnapshotBeforeUpdate === "function";

        if (!hasNewLifecycles && (typeof instance.UNSAFE_componentWillReceiveProps === "function" || typeof instance.componentWillReceiveProps === "function")) {
          if (oldProps !== newProps || oldContext !== nextContext) {
            callComponentWillReceiveProps(workInProgress, instance, newProps, nextContext);
          }
        }

        resetHasForceUpdateBeforeProcessing();
        var oldState = workInProgress.memoizedState;
        var newState = instance.state = oldState;
        var updateQueue = workInProgress.updateQueue;

        if (updateQueue !== null) {
          processUpdateQueue(workInProgress, updateQueue, newProps, instance, renderExpirationTime);
          newState = workInProgress.memoizedState;
        }

        if (oldProps === newProps && oldState === newState && !hasContextChanged() && !checkHasForceUpdateAfterProcessing()) {
          if (typeof instance.componentDidMount === "function") {
            workInProgress.effectTag |= Update;
          }

          return false;
        }

        if (typeof getDerivedStateFromProps === "function") {
          applyDerivedStateFromProps(workInProgress, ctor, getDerivedStateFromProps, newProps);
          newState = workInProgress.memoizedState;
        }

        var shouldUpdate = checkHasForceUpdateAfterProcessing() || checkShouldComponentUpdate(workInProgress, ctor, oldProps, newProps, oldState, newState, nextContext);

        if (shouldUpdate) {
          if (!hasNewLifecycles && (typeof instance.UNSAFE_componentWillMount === "function" || typeof instance.componentWillMount === "function")) {
            startPhaseTimer(workInProgress, "componentWillMount");

            if (typeof instance.componentWillMount === "function") {
              instance.componentWillMount();
            }

            if (typeof instance.UNSAFE_componentWillMount === "function") {
              instance.UNSAFE_componentWillMount();
            }

            stopPhaseTimer();
          }

          if (typeof instance.componentDidMount === "function") {
            workInProgress.effectTag |= Update;
          }
        } else {
          if (typeof instance.componentDidMount === "function") {
            workInProgress.effectTag |= Update;
          }

          workInProgress.memoizedProps = newProps;
          workInProgress.memoizedState = newState;
        }

        instance.props = newProps;
        instance.state = newState;
        instance.context = nextContext;
        return shouldUpdate;
      }

      function updateClassInstance(current, workInProgress, ctor, newProps, renderExpirationTime) {
        var instance = workInProgress.stateNode;
        var oldProps = workInProgress.memoizedProps;
        instance.props = workInProgress.type === workInProgress.elementType ? oldProps : resolveDefaultProps(workInProgress.type, oldProps);
        var oldContext = instance.context;
        var contextType = ctor.contextType;
        var nextContext = emptyContextObject;

        if (typeof contextType === "object" && contextType !== null) {
          nextContext = _readContext(contextType);
        } else if (!disableLegacyContext) {
          var nextUnmaskedContext = getUnmaskedContext(workInProgress, ctor, true);
          nextContext = getMaskedContext(workInProgress, nextUnmaskedContext);
        }

        var getDerivedStateFromProps = ctor.getDerivedStateFromProps;
        var hasNewLifecycles = typeof getDerivedStateFromProps === "function" || typeof instance.getSnapshotBeforeUpdate === "function";

        if (!hasNewLifecycles && (typeof instance.UNSAFE_componentWillReceiveProps === "function" || typeof instance.componentWillReceiveProps === "function")) {
          if (oldProps !== newProps || oldContext !== nextContext) {
            callComponentWillReceiveProps(workInProgress, instance, newProps, nextContext);
          }
        }

        resetHasForceUpdateBeforeProcessing();
        var oldState = workInProgress.memoizedState;
        var newState = instance.state = oldState;
        var updateQueue = workInProgress.updateQueue;

        if (updateQueue !== null) {
          processUpdateQueue(workInProgress, updateQueue, newProps, instance, renderExpirationTime);
          newState = workInProgress.memoizedState;
        }

        if (oldProps === newProps && oldState === newState && !hasContextChanged() && !checkHasForceUpdateAfterProcessing()) {
          if (typeof instance.componentDidUpdate === "function") {
            if (oldProps !== current.memoizedProps || oldState !== current.memoizedState) {
              workInProgress.effectTag |= Update;
            }
          }

          if (typeof instance.getSnapshotBeforeUpdate === "function") {
            if (oldProps !== current.memoizedProps || oldState !== current.memoizedState) {
              workInProgress.effectTag |= Snapshot;
            }
          }

          return false;
        }

        if (typeof getDerivedStateFromProps === "function") {
          applyDerivedStateFromProps(workInProgress, ctor, getDerivedStateFromProps, newProps);
          newState = workInProgress.memoizedState;
        }

        var shouldUpdate = checkHasForceUpdateAfterProcessing() || checkShouldComponentUpdate(workInProgress, ctor, oldProps, newProps, oldState, newState, nextContext);

        if (shouldUpdate) {
          if (!hasNewLifecycles && (typeof instance.UNSAFE_componentWillUpdate === "function" || typeof instance.componentWillUpdate === "function")) {
            startPhaseTimer(workInProgress, "componentWillUpdate");

            if (typeof instance.componentWillUpdate === "function") {
              instance.componentWillUpdate(newProps, newState, nextContext);
            }

            if (typeof instance.UNSAFE_componentWillUpdate === "function") {
              instance.UNSAFE_componentWillUpdate(newProps, newState, nextContext);
            }

            stopPhaseTimer();
          }

          if (typeof instance.componentDidUpdate === "function") {
            workInProgress.effectTag |= Update;
          }

          if (typeof instance.getSnapshotBeforeUpdate === "function") {
            workInProgress.effectTag |= Snapshot;
          }
        } else {
          if (typeof instance.componentDidUpdate === "function") {
            if (oldProps !== current.memoizedProps || oldState !== current.memoizedState) {
              workInProgress.effectTag |= Update;
            }
          }

          if (typeof instance.getSnapshotBeforeUpdate === "function") {
            if (oldProps !== current.memoizedProps || oldState !== current.memoizedState) {
              workInProgress.effectTag |= Snapshot;
            }
          }

          workInProgress.memoizedProps = newProps;
          workInProgress.memoizedState = newState;
        }

        instance.props = newProps;
        instance.state = newState;
        instance.context = nextContext;
        return shouldUpdate;
      }

      var didWarnAboutMaps = void 0;
      var didWarnAboutGenerators = void 0;
      var didWarnAboutStringRefs = void 0;
      var ownerHasKeyUseWarning = void 0;
      var ownerHasFunctionTypeWarning = void 0;

      var warnForMissingKey = function warnForMissingKey(child) {};

      {
        didWarnAboutMaps = false;
        didWarnAboutGenerators = false;
        didWarnAboutStringRefs = {};
        ownerHasKeyUseWarning = {};
        ownerHasFunctionTypeWarning = {};

        warnForMissingKey = function warnForMissingKey(child) {
          if (child === null || typeof child !== "object") {
            return;
          }

          if (!child._store || child._store.validated || child.key != null) {
            return;
          }

          (function () {
            if (!(typeof child._store === "object")) {
              throw ReactError(Error("React Component in warnForMissingKey should have a _store. This error is likely caused by a bug in React. Please file an issue."));
            }
          })();

          child._store.validated = true;
          var currentComponentErrorInfo = "Each child in a list should have a unique " + '"key" prop. See https://fb.me/react-warning-keys for ' + "more information." + getCurrentFiberStackInDev();

          if (ownerHasKeyUseWarning[currentComponentErrorInfo]) {
            return;
          }

          ownerHasKeyUseWarning[currentComponentErrorInfo] = true;
          warning$1(false, "Each child in a list should have a unique " + '"key" prop. See https://fb.me/react-warning-keys for ' + "more information.");
        };
      }
      var isArray = Array.isArray;

      function coerceRef(returnFiber, current$$1, element) {
        var mixedRef = element.ref;

        if (mixedRef !== null && typeof mixedRef !== "function" && typeof mixedRef !== "object") {
          {
            if (returnFiber.mode & StrictMode || warnAboutStringRefs) {
              var componentName = getComponentName(returnFiber.type) || "Component";

              if (!didWarnAboutStringRefs[componentName]) {
                if (warnAboutStringRefs) {
                  warningWithoutStack$1(false, 'Component "%s" contains the string ref "%s". Support for string refs ' + "will be removed in a future major release. We recommend using " + "useRef() or createRef() instead." + "\n%s" + "\n\nLearn more about using refs safely here:" + "\nhttps://fb.me/react-strict-mode-string-ref", componentName, mixedRef, getStackByFiberInDevAndProd(returnFiber));
                } else {
                  warningWithoutStack$1(false, 'A string ref, "%s", has been found within a strict mode tree. ' + "String refs are a source of potential bugs and should be avoided. " + "We recommend using useRef() or createRef() instead." + "\n%s" + "\n\nLearn more about using refs safely here:" + "\nhttps://fb.me/react-strict-mode-string-ref", mixedRef, getStackByFiberInDevAndProd(returnFiber));
                }

                didWarnAboutStringRefs[componentName] = true;
              }
            }
          }

          if (element._owner) {
            var owner = element._owner;
            var inst = void 0;

            if (owner) {
              var ownerFiber = owner;

              (function () {
                if (!(ownerFiber.tag === ClassComponent)) {
                  throw ReactError(Error("Function components cannot have refs. Did you mean to use React.forwardRef()?"));
                }
              })();

              inst = ownerFiber.stateNode;
            }

            (function () {
              if (!inst) {
                throw ReactError(Error("Missing owner for string ref " + mixedRef + ". This error is likely caused by a bug in React. Please file an issue."));
              }
            })();

            var stringRef = "" + mixedRef;

            if (current$$1 !== null && current$$1.ref !== null && typeof current$$1.ref === "function" && current$$1.ref._stringRef === stringRef) {
              return current$$1.ref;
            }

            var ref = function ref(value) {
              var refs = inst.refs;

              if (refs === emptyRefsObject) {
                refs = inst.refs = {};
              }

              if (value === null) {
                delete refs[stringRef];
              } else {
                refs[stringRef] = value;
              }
            };

            ref._stringRef = stringRef;
            return ref;
          } else {
            (function () {
              if (!(typeof mixedRef === "string")) {
                throw ReactError(Error("Expected ref to be a function, a string, an object returned by React.createRef(), or null."));
              }
            })();

            (function () {
              if (!element._owner) {
                throw ReactError(Error("Element ref was specified as a string (" + mixedRef + ") but no owner was set. This could happen for one of the following reasons:\n1. You may be adding a ref to a function component\n2. You may be adding a ref to a component that was not created inside a component's render method\n3. You have multiple copies of React loaded\nSee https://fb.me/react-refs-must-have-owner for more information."));
              }
            })();
          }
        }

        return mixedRef;
      }

      function throwOnInvalidObjectType(returnFiber, newChild) {
        if (returnFiber.type !== "textarea") {
          var addendum = "";
          {
            addendum = " If you meant to render a collection of children, use an array " + "instead." + getCurrentFiberStackInDev();
          }

          (function () {
            {
              throw ReactError(Error("Objects are not valid as a React child (found: " + (Object.prototype.toString.call(newChild) === "[object Object]" ? "object with keys {" + Object.keys(newChild).join(", ") + "}" : newChild) + ")." + addendum));
            }
          })();
        }
      }

      function warnOnFunctionType() {
        var currentComponentErrorInfo = "Functions are not valid as a React child. This may happen if " + "you return a Component instead of <Component /> from render. " + "Or maybe you meant to call this function rather than return it." + getCurrentFiberStackInDev();

        if (ownerHasFunctionTypeWarning[currentComponentErrorInfo]) {
          return;
        }

        ownerHasFunctionTypeWarning[currentComponentErrorInfo] = true;
        warning$1(false, "Functions are not valid as a React child. This may happen if " + "you return a Component instead of <Component /> from render. " + "Or maybe you meant to call this function rather than return it.");
      }

      function ChildReconciler(shouldTrackSideEffects) {
        function deleteChild(returnFiber, childToDelete) {
          if (!shouldTrackSideEffects) {
            return;
          }

          var last = returnFiber.lastEffect;

          if (last !== null) {
            last.nextEffect = childToDelete;
            returnFiber.lastEffect = childToDelete;
          } else {
            returnFiber.firstEffect = returnFiber.lastEffect = childToDelete;
          }

          childToDelete.nextEffect = null;
          childToDelete.effectTag = Deletion;
        }

        function deleteRemainingChildren(returnFiber, currentFirstChild) {
          if (!shouldTrackSideEffects) {
            return null;
          }

          var childToDelete = currentFirstChild;

          while (childToDelete !== null) {
            deleteChild(returnFiber, childToDelete);
            childToDelete = childToDelete.sibling;
          }

          return null;
        }

        function mapRemainingChildren(returnFiber, currentFirstChild) {
          var existingChildren = new Map();
          var existingChild = currentFirstChild;

          while (existingChild !== null) {
            if (existingChild.key !== null) {
              existingChildren.set(existingChild.key, existingChild);
            } else {
              existingChildren.set(existingChild.index, existingChild);
            }

            existingChild = existingChild.sibling;
          }

          return existingChildren;
        }

        function useFiber(fiber, pendingProps, expirationTime) {
          var clone = createWorkInProgress(fiber, pendingProps, expirationTime);
          clone.index = 0;
          clone.sibling = null;
          return clone;
        }

        function placeChild(newFiber, lastPlacedIndex, newIndex) {
          newFiber.index = newIndex;

          if (!shouldTrackSideEffects) {
            return lastPlacedIndex;
          }

          var current$$1 = newFiber.alternate;

          if (current$$1 !== null) {
            var oldIndex = current$$1.index;

            if (oldIndex < lastPlacedIndex) {
              newFiber.effectTag = Placement;
              return lastPlacedIndex;
            } else {
              return oldIndex;
            }
          } else {
            newFiber.effectTag = Placement;
            return lastPlacedIndex;
          }
        }

        function placeSingleChild(newFiber) {
          if (shouldTrackSideEffects && newFiber.alternate === null) {
            newFiber.effectTag = Placement;
          }

          return newFiber;
        }

        function updateTextNode(returnFiber, current$$1, textContent, expirationTime) {
          if (current$$1 === null || current$$1.tag !== HostText) {
            var created = createFiberFromText(textContent, returnFiber.mode, expirationTime);
            created.return = returnFiber;
            return created;
          } else {
            var existing = useFiber(current$$1, textContent, expirationTime);
            existing.return = returnFiber;
            return existing;
          }
        }

        function updateElement(returnFiber, current$$1, element, expirationTime) {
          if (current$$1 !== null && (current$$1.elementType === element.type || isCompatibleFamilyForHotReloading(current$$1, element))) {
            var existing = useFiber(current$$1, element.props, expirationTime);
            existing.ref = coerceRef(returnFiber, current$$1, element);
            existing.return = returnFiber;
            {
              existing._debugSource = element._source;
              existing._debugOwner = element._owner;
            }
            return existing;
          } else {
            var created = createFiberFromElement(element, returnFiber.mode, expirationTime);
            created.ref = coerceRef(returnFiber, current$$1, element);
            created.return = returnFiber;
            return created;
          }
        }

        function updatePortal(returnFiber, current$$1, portal, expirationTime) {
          if (current$$1 === null || current$$1.tag !== HostPortal || current$$1.stateNode.containerInfo !== portal.containerInfo || current$$1.stateNode.implementation !== portal.implementation) {
            var created = createFiberFromPortal(portal, returnFiber.mode, expirationTime);
            created.return = returnFiber;
            return created;
          } else {
            var existing = useFiber(current$$1, portal.children || [], expirationTime);
            existing.return = returnFiber;
            return existing;
          }
        }

        function updateFragment(returnFiber, current$$1, fragment, expirationTime, key) {
          if (current$$1 === null || current$$1.tag !== Fragment) {
            var created = createFiberFromFragment(fragment, returnFiber.mode, expirationTime, key);
            created.return = returnFiber;
            return created;
          } else {
            var existing = useFiber(current$$1, fragment, expirationTime);
            existing.return = returnFiber;
            return existing;
          }
        }

        function createChild(returnFiber, newChild, expirationTime) {
          if (typeof newChild === "string" || typeof newChild === "number") {
            var created = createFiberFromText("" + newChild, returnFiber.mode, expirationTime);
            created.return = returnFiber;
            return created;
          }

          if (typeof newChild === "object" && newChild !== null) {
            switch (newChild.$$typeof) {
              case REACT_ELEMENT_TYPE:
                {
                  var _created = createFiberFromElement(newChild, returnFiber.mode, expirationTime);

                  _created.ref = coerceRef(returnFiber, null, newChild);
                  _created.return = returnFiber;
                  return _created;
                }

              case REACT_PORTAL_TYPE:
                {
                  var _created2 = createFiberFromPortal(newChild, returnFiber.mode, expirationTime);

                  _created2.return = returnFiber;
                  return _created2;
                }
            }

            if (isArray(newChild) || getIteratorFn(newChild)) {
              var _created3 = createFiberFromFragment(newChild, returnFiber.mode, expirationTime, null);

              _created3.return = returnFiber;
              return _created3;
            }

            throwOnInvalidObjectType(returnFiber, newChild);
          }

          {
            if (typeof newChild === "function") {
              warnOnFunctionType();
            }
          }
          return null;
        }

        function updateSlot(returnFiber, oldFiber, newChild, expirationTime) {
          var key = oldFiber !== null ? oldFiber.key : null;

          if (typeof newChild === "string" || typeof newChild === "number") {
            if (key !== null) {
              return null;
            }

            return updateTextNode(returnFiber, oldFiber, "" + newChild, expirationTime);
          }

          if (typeof newChild === "object" && newChild !== null) {
            switch (newChild.$$typeof) {
              case REACT_ELEMENT_TYPE:
                {
                  if (newChild.key === key) {
                    if (newChild.type === REACT_FRAGMENT_TYPE) {
                      return updateFragment(returnFiber, oldFiber, newChild.props.children, expirationTime, key);
                    }

                    return updateElement(returnFiber, oldFiber, newChild, expirationTime);
                  } else {
                    return null;
                  }
                }

              case REACT_PORTAL_TYPE:
                {
                  if (newChild.key === key) {
                    return updatePortal(returnFiber, oldFiber, newChild, expirationTime);
                  } else {
                    return null;
                  }
                }
            }

            if (isArray(newChild) || getIteratorFn(newChild)) {
              if (key !== null) {
                return null;
              }

              return updateFragment(returnFiber, oldFiber, newChild, expirationTime, null);
            }

            throwOnInvalidObjectType(returnFiber, newChild);
          }

          {
            if (typeof newChild === "function") {
              warnOnFunctionType();
            }
          }
          return null;
        }

        function updateFromMap(existingChildren, returnFiber, newIdx, newChild, expirationTime) {
          if (typeof newChild === "string" || typeof newChild === "number") {
            var matchedFiber = existingChildren.get(newIdx) || null;
            return updateTextNode(returnFiber, matchedFiber, "" + newChild, expirationTime);
          }

          if (typeof newChild === "object" && newChild !== null) {
            switch (newChild.$$typeof) {
              case REACT_ELEMENT_TYPE:
                {
                  var _matchedFiber = existingChildren.get(newChild.key === null ? newIdx : newChild.key) || null;

                  if (newChild.type === REACT_FRAGMENT_TYPE) {
                    return updateFragment(returnFiber, _matchedFiber, newChild.props.children, expirationTime, newChild.key);
                  }

                  return updateElement(returnFiber, _matchedFiber, newChild, expirationTime);
                }

              case REACT_PORTAL_TYPE:
                {
                  var _matchedFiber2 = existingChildren.get(newChild.key === null ? newIdx : newChild.key) || null;

                  return updatePortal(returnFiber, _matchedFiber2, newChild, expirationTime);
                }
            }

            if (isArray(newChild) || getIteratorFn(newChild)) {
              var _matchedFiber3 = existingChildren.get(newIdx) || null;

              return updateFragment(returnFiber, _matchedFiber3, newChild, expirationTime, null);
            }

            throwOnInvalidObjectType(returnFiber, newChild);
          }

          {
            if (typeof newChild === "function") {
              warnOnFunctionType();
            }
          }
          return null;
        }

        function warnOnInvalidKey(child, knownKeys) {
          {
            if (typeof child !== "object" || child === null) {
              return knownKeys;
            }

            switch (child.$$typeof) {
              case REACT_ELEMENT_TYPE:
              case REACT_PORTAL_TYPE:
                warnForMissingKey(child);
                var key = child.key;

                if (typeof key !== "string") {
                  break;
                }

                if (knownKeys === null) {
                  knownKeys = new Set();
                  knownKeys.add(key);
                  break;
                }

                if (!knownKeys.has(key)) {
                  knownKeys.add(key);
                  break;
                }

                warning$1(false, "Encountered two children with the same key, `%s`. " + "Keys should be unique so that components maintain their identity " + "across updates. Non-unique keys may cause children to be " + "duplicated and/or omitted — the behavior is unsupported and " + "could change in a future version.", key);
                break;

              default:
                break;
            }
          }
          return knownKeys;
        }

        function reconcileChildrenArray(returnFiber, currentFirstChild, newChildren, expirationTime) {
          {
            var knownKeys = null;

            for (var i = 0; i < newChildren.length; i++) {
              var child = newChildren[i];
              knownKeys = warnOnInvalidKey(child, knownKeys);
            }
          }
          var resultingFirstChild = null;
          var previousNewFiber = null;
          var oldFiber = currentFirstChild;
          var lastPlacedIndex = 0;
          var newIdx = 0;
          var nextOldFiber = null;

          for (; oldFiber !== null && newIdx < newChildren.length; newIdx++) {
            if (oldFiber.index > newIdx) {
              nextOldFiber = oldFiber;
              oldFiber = null;
            } else {
              nextOldFiber = oldFiber.sibling;
            }

            var newFiber = updateSlot(returnFiber, oldFiber, newChildren[newIdx], expirationTime);

            if (newFiber === null) {
              if (oldFiber === null) {
                oldFiber = nextOldFiber;
              }

              break;
            }

            if (shouldTrackSideEffects) {
              if (oldFiber && newFiber.alternate === null) {
                deleteChild(returnFiber, oldFiber);
              }
            }

            lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx);

            if (previousNewFiber === null) {
              resultingFirstChild = newFiber;
            } else {
              previousNewFiber.sibling = newFiber;
            }

            previousNewFiber = newFiber;
            oldFiber = nextOldFiber;
          }

          if (newIdx === newChildren.length) {
            deleteRemainingChildren(returnFiber, oldFiber);
            return resultingFirstChild;
          }

          if (oldFiber === null) {
            for (; newIdx < newChildren.length; newIdx++) {
              var _newFiber = createChild(returnFiber, newChildren[newIdx], expirationTime);

              if (_newFiber === null) {
                continue;
              }

              lastPlacedIndex = placeChild(_newFiber, lastPlacedIndex, newIdx);

              if (previousNewFiber === null) {
                resultingFirstChild = _newFiber;
              } else {
                previousNewFiber.sibling = _newFiber;
              }

              previousNewFiber = _newFiber;
            }

            return resultingFirstChild;
          }

          var existingChildren = mapRemainingChildren(returnFiber, oldFiber);

          for (; newIdx < newChildren.length; newIdx++) {
            var _newFiber2 = updateFromMap(existingChildren, returnFiber, newIdx, newChildren[newIdx], expirationTime);

            if (_newFiber2 !== null) {
              if (shouldTrackSideEffects) {
                if (_newFiber2.alternate !== null) {
                  existingChildren.delete(_newFiber2.key === null ? newIdx : _newFiber2.key);
                }
              }

              lastPlacedIndex = placeChild(_newFiber2, lastPlacedIndex, newIdx);

              if (previousNewFiber === null) {
                resultingFirstChild = _newFiber2;
              } else {
                previousNewFiber.sibling = _newFiber2;
              }

              previousNewFiber = _newFiber2;
            }
          }

          if (shouldTrackSideEffects) {
            existingChildren.forEach(function (child) {
              return deleteChild(returnFiber, child);
            });
          }

          return resultingFirstChild;
        }

        function reconcileChildrenIterator(returnFiber, currentFirstChild, newChildrenIterable, expirationTime) {
          var iteratorFn = getIteratorFn(newChildrenIterable);

          (function () {
            if (!(typeof iteratorFn === "function")) {
              throw ReactError(Error("An object is not an iterable. This error is likely caused by a bug in React. Please file an issue."));
            }
          })();

          {
            if (typeof Symbol === "function" && newChildrenIterable[typeof Symbol === "function" ? Symbol.toStringTag : "@@toStringTag"] === "Generator") {
              !didWarnAboutGenerators ? warning$1(false, "Using Generators as children is unsupported and will likely yield " + "unexpected results because enumerating a generator mutates it. " + "You may convert it to an array with `Array.from()` or the " + "`[...spread]` operator before rendering. Keep in mind " + "you might need to polyfill these features for older browsers.") : void 0;
              didWarnAboutGenerators = true;
            }

            if (newChildrenIterable.entries === iteratorFn) {
              !didWarnAboutMaps ? warning$1(false, "Using Maps as children is unsupported and will likely yield " + "unexpected results. Convert it to a sequence/iterable of keyed " + "ReactElements instead.") : void 0;
              didWarnAboutMaps = true;
            }

            var _newChildren = iteratorFn.call(newChildrenIterable);

            if (_newChildren) {
              var knownKeys = null;

              var _step = _newChildren.next();

              for (; !_step.done; _step = _newChildren.next()) {
                var child = _step.value;
                knownKeys = warnOnInvalidKey(child, knownKeys);
              }
            }
          }
          var newChildren = iteratorFn.call(newChildrenIterable);

          (function () {
            if (!(newChildren != null)) {
              throw ReactError(Error("An iterable object provided no iterator."));
            }
          })();

          var resultingFirstChild = null;
          var previousNewFiber = null;
          var oldFiber = currentFirstChild;
          var lastPlacedIndex = 0;
          var newIdx = 0;
          var nextOldFiber = null;
          var step = newChildren.next();

          for (; oldFiber !== null && !step.done; newIdx++, step = newChildren.next()) {
            if (oldFiber.index > newIdx) {
              nextOldFiber = oldFiber;
              oldFiber = null;
            } else {
              nextOldFiber = oldFiber.sibling;
            }

            var newFiber = updateSlot(returnFiber, oldFiber, step.value, expirationTime);

            if (newFiber === null) {
              if (oldFiber === null) {
                oldFiber = nextOldFiber;
              }

              break;
            }

            if (shouldTrackSideEffects) {
              if (oldFiber && newFiber.alternate === null) {
                deleteChild(returnFiber, oldFiber);
              }
            }

            lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx);

            if (previousNewFiber === null) {
              resultingFirstChild = newFiber;
            } else {
              previousNewFiber.sibling = newFiber;
            }

            previousNewFiber = newFiber;
            oldFiber = nextOldFiber;
          }

          if (step.done) {
            deleteRemainingChildren(returnFiber, oldFiber);
            return resultingFirstChild;
          }

          if (oldFiber === null) {
            for (; !step.done; newIdx++, step = newChildren.next()) {
              var _newFiber3 = createChild(returnFiber, step.value, expirationTime);

              if (_newFiber3 === null) {
                continue;
              }

              lastPlacedIndex = placeChild(_newFiber3, lastPlacedIndex, newIdx);

              if (previousNewFiber === null) {
                resultingFirstChild = _newFiber3;
              } else {
                previousNewFiber.sibling = _newFiber3;
              }

              previousNewFiber = _newFiber3;
            }

            return resultingFirstChild;
          }

          var existingChildren = mapRemainingChildren(returnFiber, oldFiber);

          for (; !step.done; newIdx++, step = newChildren.next()) {
            var _newFiber4 = updateFromMap(existingChildren, returnFiber, newIdx, step.value, expirationTime);

            if (_newFiber4 !== null) {
              if (shouldTrackSideEffects) {
                if (_newFiber4.alternate !== null) {
                  existingChildren.delete(_newFiber4.key === null ? newIdx : _newFiber4.key);
                }
              }

              lastPlacedIndex = placeChild(_newFiber4, lastPlacedIndex, newIdx);

              if (previousNewFiber === null) {
                resultingFirstChild = _newFiber4;
              } else {
                previousNewFiber.sibling = _newFiber4;
              }

              previousNewFiber = _newFiber4;
            }
          }

          if (shouldTrackSideEffects) {
            existingChildren.forEach(function (child) {
              return deleteChild(returnFiber, child);
            });
          }

          return resultingFirstChild;
        }

        function reconcileSingleTextNode(returnFiber, currentFirstChild, textContent, expirationTime) {
          if (currentFirstChild !== null && currentFirstChild.tag === HostText) {
            deleteRemainingChildren(returnFiber, currentFirstChild.sibling);
            var existing = useFiber(currentFirstChild, textContent, expirationTime);
            existing.return = returnFiber;
            return existing;
          }

          deleteRemainingChildren(returnFiber, currentFirstChild);
          var created = createFiberFromText(textContent, returnFiber.mode, expirationTime);
          created.return = returnFiber;
          return created;
        }

        function reconcileSingleElement(returnFiber, currentFirstChild, element, expirationTime) {
          var key = element.key;
          var child = currentFirstChild;

          while (child !== null) {
            if (child.key === key) {
              if (child.tag === Fragment ? element.type === REACT_FRAGMENT_TYPE : child.elementType === element.type || isCompatibleFamilyForHotReloading(child, element)) {
                deleteRemainingChildren(returnFiber, child.sibling);
                var existing = useFiber(child, element.type === REACT_FRAGMENT_TYPE ? element.props.children : element.props, expirationTime);
                existing.ref = coerceRef(returnFiber, child, element);
                existing.return = returnFiber;
                {
                  existing._debugSource = element._source;
                  existing._debugOwner = element._owner;
                }
                return existing;
              } else {
                deleteRemainingChildren(returnFiber, child);
                break;
              }
            } else {
              deleteChild(returnFiber, child);
            }

            child = child.sibling;
          }

          if (element.type === REACT_FRAGMENT_TYPE) {
            var created = createFiberFromFragment(element.props.children, returnFiber.mode, expirationTime, element.key);
            created.return = returnFiber;
            return created;
          } else {
            var _created4 = createFiberFromElement(element, returnFiber.mode, expirationTime);

            _created4.ref = coerceRef(returnFiber, currentFirstChild, element);
            _created4.return = returnFiber;
            return _created4;
          }
        }

        function reconcileSinglePortal(returnFiber, currentFirstChild, portal, expirationTime) {
          var key = portal.key;
          var child = currentFirstChild;

          while (child !== null) {
            if (child.key === key) {
              if (child.tag === HostPortal && child.stateNode.containerInfo === portal.containerInfo && child.stateNode.implementation === portal.implementation) {
                deleteRemainingChildren(returnFiber, child.sibling);
                var existing = useFiber(child, portal.children || [], expirationTime);
                existing.return = returnFiber;
                return existing;
              } else {
                deleteRemainingChildren(returnFiber, child);
                break;
              }
            } else {
              deleteChild(returnFiber, child);
            }

            child = child.sibling;
          }

          var created = createFiberFromPortal(portal, returnFiber.mode, expirationTime);
          created.return = returnFiber;
          return created;
        }

        function reconcileChildFibers(returnFiber, currentFirstChild, newChild, expirationTime) {
          var isUnkeyedTopLevelFragment = typeof newChild === "object" && newChild !== null && newChild.type === REACT_FRAGMENT_TYPE && newChild.key === null;

          if (isUnkeyedTopLevelFragment) {
            newChild = newChild.props.children;
          }

          var isObject = typeof newChild === "object" && newChild !== null;

          if (isObject) {
            switch (newChild.$$typeof) {
              case REACT_ELEMENT_TYPE:
                return placeSingleChild(reconcileSingleElement(returnFiber, currentFirstChild, newChild, expirationTime));

              case REACT_PORTAL_TYPE:
                return placeSingleChild(reconcileSinglePortal(returnFiber, currentFirstChild, newChild, expirationTime));
            }
          }

          if (typeof newChild === "string" || typeof newChild === "number") {
            return placeSingleChild(reconcileSingleTextNode(returnFiber, currentFirstChild, "" + newChild, expirationTime));
          }

          if (isArray(newChild)) {
            return reconcileChildrenArray(returnFiber, currentFirstChild, newChild, expirationTime);
          }

          if (getIteratorFn(newChild)) {
            return reconcileChildrenIterator(returnFiber, currentFirstChild, newChild, expirationTime);
          }

          if (isObject) {
            throwOnInvalidObjectType(returnFiber, newChild);
          }

          {
            if (typeof newChild === "function") {
              warnOnFunctionType();
            }
          }

          if (typeof newChild === "undefined" && !isUnkeyedTopLevelFragment) {
            switch (returnFiber.tag) {
              case ClassComponent:
                {
                  {
                    var instance = returnFiber.stateNode;

                    if (instance.render._isMockFunction) {
                      break;
                    }
                  }
                }

              case FunctionComponent:
                {
                  var Component = returnFiber.type;

                  (function () {
                    {
                      throw ReactError(Error((Component.displayName || Component.name || "Component") + "(...): Nothing was returned from render. This usually means a return statement is missing. Or, to render nothing, return null."));
                    }
                  })();
                }
            }
          }

          return deleteRemainingChildren(returnFiber, currentFirstChild);
        }

        return reconcileChildFibers;
      }

      var reconcileChildFibers = ChildReconciler(true);
      var mountChildFibers = ChildReconciler(false);

      function cloneChildFibers(current$$1, workInProgress) {
        (function () {
          if (!(current$$1 === null || workInProgress.child === current$$1.child)) {
            throw ReactError(Error("Resuming work not yet implemented."));
          }
        })();

        if (workInProgress.child === null) {
          return;
        }

        var currentChild = workInProgress.child;
        var newChild = createWorkInProgress(currentChild, currentChild.pendingProps, currentChild.expirationTime);
        workInProgress.child = newChild;
        newChild.return = workInProgress;

        while (currentChild.sibling !== null) {
          currentChild = currentChild.sibling;
          newChild = newChild.sibling = createWorkInProgress(currentChild, currentChild.pendingProps, currentChild.expirationTime);
          newChild.return = workInProgress;
        }

        newChild.sibling = null;
      }

      function resetChildFibers(workInProgress, renderExpirationTime) {
        var child = workInProgress.child;

        while (child !== null) {
          resetWorkInProgress(child, renderExpirationTime);
          child = child.sibling;
        }
      }

      var NO_CONTEXT = {};
      var contextStackCursor$1 = createCursor(NO_CONTEXT);
      var contextFiberStackCursor = createCursor(NO_CONTEXT);
      var rootInstanceStackCursor = createCursor(NO_CONTEXT);

      function requiredContext(c) {
        (function () {
          if (!(c !== NO_CONTEXT)) {
            throw ReactError(Error("Expected host context to exist. This error is likely caused by a bug in React. Please file an issue."));
          }
        })();

        return c;
      }

      function getRootHostContainer() {
        var rootInstance = requiredContext(rootInstanceStackCursor.current);
        return rootInstance;
      }

      function pushHostContainer(fiber, nextRootInstance) {
        push(rootInstanceStackCursor, nextRootInstance, fiber);
        push(contextFiberStackCursor, fiber, fiber);
        push(contextStackCursor$1, NO_CONTEXT, fiber);
        var nextRootContext = getRootHostContext(nextRootInstance);
        pop(contextStackCursor$1, fiber);
        push(contextStackCursor$1, nextRootContext, fiber);
      }

      function popHostContainer(fiber) {
        pop(contextStackCursor$1, fiber);
        pop(contextFiberStackCursor, fiber);
        pop(rootInstanceStackCursor, fiber);
      }

      function getHostContext() {
        var context = requiredContext(contextStackCursor$1.current);
        return context;
      }

      function pushHostContext(fiber) {
        var rootInstance = requiredContext(rootInstanceStackCursor.current);
        var context = requiredContext(contextStackCursor$1.current);
        var nextContext = getChildHostContext(context, fiber.type, rootInstance);

        if (context === nextContext) {
          return;
        }

        push(contextFiberStackCursor, fiber, fiber);
        push(contextStackCursor$1, nextContext, fiber);
      }

      function popHostContext(fiber) {
        if (contextFiberStackCursor.current !== fiber) {
          return;
        }

        pop(contextStackCursor$1, fiber);
        pop(contextFiberStackCursor, fiber);
      }

      var DefaultSuspenseContext = 0;
      var SubtreeSuspenseContextMask = 1;
      var InvisibleParentSuspenseContext = 1;
      var ForceSuspenseFallback = 2;
      var suspenseStackCursor = createCursor(DefaultSuspenseContext);

      function hasSuspenseContext(parentContext, flag) {
        return (parentContext & flag) !== 0;
      }

      function setDefaultShallowSuspenseContext(parentContext) {
        return parentContext & SubtreeSuspenseContextMask;
      }

      function setShallowSuspenseContext(parentContext, shallowContext) {
        return parentContext & SubtreeSuspenseContextMask | shallowContext;
      }

      function addSubtreeSuspenseContext(parentContext, subtreeContext) {
        return parentContext | subtreeContext;
      }

      function pushSuspenseContext(fiber, newContext) {
        push(suspenseStackCursor, newContext, fiber);
      }

      function popSuspenseContext(fiber) {
        pop(suspenseStackCursor, fiber);
      }

      function shouldCaptureSuspense(workInProgress, hasInvisibleParent) {
        var nextState = workInProgress.memoizedState;

        if (nextState !== null) {
          return false;
        }

        var props = workInProgress.memoizedProps;

        if (props.fallback === undefined) {
          return false;
        }

        if (props.unstable_avoidThisFallback !== true) {
          return true;
        }

        if (hasInvisibleParent) {
          return false;
        }

        return true;
      }

      function findFirstSuspended(row) {
        var node = row;

        while (node !== null) {
          if (node.tag === SuspenseComponent) {
            var state = node.memoizedState;

            if (state !== null) {
              return node;
            }
          } else if (node.tag === SuspenseListComponent && node.memoizedProps.revealOrder !== undefined) {
            var didSuspend = (node.effectTag & DidCapture) !== NoEffect;

            if (didSuspend) {
              return node;
            }
          } else if (node.child !== null) {
            node.child.return = node;
            node = node.child;
            continue;
          }

          if (node === row) {
            return null;
          }

          while (node.sibling === null) {
            if (node.return === null || node.return === row) {
              return null;
            }

            node = node.return;
          }

          node.sibling.return = node.return;
          node = node.sibling;
        }

        return null;
      }

      function createResponderListener(responder, props) {
        var eventResponderListener = {
          responder: responder,
          props: props
        };
        {
          Object.freeze(eventResponderListener);
        }
        return eventResponderListener;
      }

      function createResponderInstance(responder, responderProps, responderState, target, fiber) {
        return {
          fiber: fiber,
          props: responderProps,
          responder: responder,
          rootEventTypes: null,
          state: responderState,
          target: target
        };
      }

      var NoEffect$1 = 0;
      var UnmountSnapshot = 2;
      var UnmountMutation = 4;
      var MountMutation = 8;
      var UnmountLayout = 16;
      var MountLayout = 32;
      var MountPassive = 64;
      var UnmountPassive = 128;
      var ReactCurrentDispatcher$1 = ReactSharedInternals.ReactCurrentDispatcher;
      var didWarnAboutMismatchedHooksForComponent = void 0;
      {
        didWarnAboutMismatchedHooksForComponent = new Set();
      }
      var renderExpirationTime$1 = NoWork;
      var currentlyRenderingFiber$1 = null;
      var currentHook = null;
      var nextCurrentHook = null;
      var firstWorkInProgressHook = null;
      var workInProgressHook = null;
      var nextWorkInProgressHook = null;
      var remainingExpirationTime = NoWork;
      var componentUpdateQueue = null;
      var sideEffectTag = 0;
      var didScheduleRenderPhaseUpdate = false;
      var renderPhaseUpdates = null;
      var numberOfReRenders = 0;
      var RE_RENDER_LIMIT = 25;
      var currentHookNameInDev = null;
      var hookTypesDev = null;
      var hookTypesUpdateIndexDev = -1;
      var ignorePreviousDependencies = false;

      function mountHookTypesDev() {
        {
          var hookName = currentHookNameInDev;

          if (hookTypesDev === null) {
            hookTypesDev = [hookName];
          } else {
            hookTypesDev.push(hookName);
          }
        }
      }

      function updateHookTypesDev() {
        {
          var hookName = currentHookNameInDev;

          if (hookTypesDev !== null) {
            hookTypesUpdateIndexDev++;

            if (hookTypesDev[hookTypesUpdateIndexDev] !== hookName) {
              warnOnHookMismatchInDev(hookName);
            }
          }
        }
      }

      function checkDepsAreArrayDev(deps) {
        {
          if (deps !== undefined && deps !== null && !Array.isArray(deps)) {
            warning$1(false, "%s received a final argument that is not an array (instead, received `%s`). When " + "specified, the final argument must be an array.", currentHookNameInDev, typeof deps);
          }
        }
      }

      function warnOnHookMismatchInDev(currentHookName) {
        {
          var componentName = getComponentName(currentlyRenderingFiber$1.type);

          if (!didWarnAboutMismatchedHooksForComponent.has(componentName)) {
            didWarnAboutMismatchedHooksForComponent.add(componentName);

            if (hookTypesDev !== null) {
              var table = "";
              var secondColumnStart = 30;

              for (var i = 0; i <= hookTypesUpdateIndexDev; i++) {
                var oldHookName = hookTypesDev[i];
                var newHookName = i === hookTypesUpdateIndexDev ? currentHookName : oldHookName;
                var row = i + 1 + ". " + oldHookName;

                while (row.length < secondColumnStart) {
                  row += " ";
                }

                row += newHookName + "\n";
                table += row;
              }

              warning$1(false, "React has detected a change in the order of Hooks called by %s. " + "This will lead to bugs and errors if not fixed. " + "For more information, read the Rules of Hooks: https://fb.me/rules-of-hooks\n\n" + "   Previous render            Next render\n" + "   ------------------------------------------------------\n" + "%s" + "   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", componentName, table);
            }
          }
        }
      }

      function throwInvalidHookError() {
        (function () {
          {
            throw ReactError(Error("Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of the following reasons:\n1. You might have mismatching versions of React and the renderer (such as React DOM)\n2. You might be breaking the Rules of Hooks\n3. You might have more than one copy of React in the same app\nSee https://fb.me/react-invalid-hook-call for tips about how to debug and fix this problem."));
          }
        })();
      }

      function areHookInputsEqual(nextDeps, prevDeps) {
        {
          if (ignorePreviousDependencies) {
            return false;
          }
        }

        if (prevDeps === null) {
          {
            warning$1(false, "%s received a final argument during this render, but not during " + "the previous render. Even though the final argument is optional, " + "its type cannot change between renders.", currentHookNameInDev);
          }
          return false;
        }

        {
          if (nextDeps.length !== prevDeps.length) {
            warning$1(false, "The final argument passed to %s changed size between renders. The " + "order and size of this array must remain constant.\n\n" + "Previous: %s\n" + "Incoming: %s", currentHookNameInDev, "[" + prevDeps.join(", ") + "]", "[" + nextDeps.join(", ") + "]");
          }
        }

        for (var i = 0; i < prevDeps.length && i < nextDeps.length; i++) {
          if (is(nextDeps[i], prevDeps[i])) {
            continue;
          }

          return false;
        }

        return true;
      }

      function renderWithHooks(current, workInProgress, Component, props, refOrContext, nextRenderExpirationTime) {
        renderExpirationTime$1 = nextRenderExpirationTime;
        currentlyRenderingFiber$1 = workInProgress;
        nextCurrentHook = current !== null ? current.memoizedState : null;
        {
          hookTypesDev = current !== null ? current._debugHookTypes : null;
          hookTypesUpdateIndexDev = -1;
          ignorePreviousDependencies = current !== null && current.type !== workInProgress.type;
        }
        {
          if (nextCurrentHook !== null) {
            ReactCurrentDispatcher$1.current = HooksDispatcherOnUpdateInDEV;
          } else if (hookTypesDev !== null) {
            ReactCurrentDispatcher$1.current = HooksDispatcherOnMountWithHookTypesInDEV;
          } else {
            ReactCurrentDispatcher$1.current = HooksDispatcherOnMountInDEV;
          }
        }
        var children = Component(props, refOrContext);

        if (didScheduleRenderPhaseUpdate) {
          do {
            didScheduleRenderPhaseUpdate = false;
            numberOfReRenders += 1;
            {
              ignorePreviousDependencies = false;
            }
            nextCurrentHook = current !== null ? current.memoizedState : null;
            nextWorkInProgressHook = firstWorkInProgressHook;
            currentHook = null;
            workInProgressHook = null;
            componentUpdateQueue = null;
            {
              hookTypesUpdateIndexDev = -1;
            }
            ReactCurrentDispatcher$1.current = HooksDispatcherOnUpdateInDEV;
            children = Component(props, refOrContext);
          } while (didScheduleRenderPhaseUpdate);

          renderPhaseUpdates = null;
          numberOfReRenders = 0;
        }

        ReactCurrentDispatcher$1.current = ContextOnlyDispatcher;
        var renderedWork = currentlyRenderingFiber$1;
        renderedWork.memoizedState = firstWorkInProgressHook;
        renderedWork.expirationTime = remainingExpirationTime;
        renderedWork.updateQueue = componentUpdateQueue;
        renderedWork.effectTag |= sideEffectTag;
        {
          renderedWork._debugHookTypes = hookTypesDev;
        }
        var didRenderTooFewHooks = currentHook !== null && currentHook.next !== null;
        renderExpirationTime$1 = NoWork;
        currentlyRenderingFiber$1 = null;
        currentHook = null;
        nextCurrentHook = null;
        firstWorkInProgressHook = null;
        workInProgressHook = null;
        nextWorkInProgressHook = null;
        {
          currentHookNameInDev = null;
          hookTypesDev = null;
          hookTypesUpdateIndexDev = -1;
        }
        remainingExpirationTime = NoWork;
        componentUpdateQueue = null;
        sideEffectTag = 0;

        (function () {
          if (!!didRenderTooFewHooks) {
            throw ReactError(Error("Rendered fewer hooks than expected. This may be caused by an accidental early return statement."));
          }
        })();

        return children;
      }

      function bailoutHooks(current, workInProgress, expirationTime) {
        workInProgress.updateQueue = current.updateQueue;
        workInProgress.effectTag &= ~(Passive | Update);

        if (current.expirationTime <= expirationTime) {
          current.expirationTime = NoWork;
        }
      }

      function resetHooks() {
        ReactCurrentDispatcher$1.current = ContextOnlyDispatcher;
        renderExpirationTime$1 = NoWork;
        currentlyRenderingFiber$1 = null;
        currentHook = null;
        nextCurrentHook = null;
        firstWorkInProgressHook = null;
        workInProgressHook = null;
        nextWorkInProgressHook = null;
        {
          hookTypesDev = null;
          hookTypesUpdateIndexDev = -1;
          currentHookNameInDev = null;
        }
        remainingExpirationTime = NoWork;
        componentUpdateQueue = null;
        sideEffectTag = 0;
        didScheduleRenderPhaseUpdate = false;
        renderPhaseUpdates = null;
        numberOfReRenders = 0;
      }

      function mountWorkInProgressHook() {
        var hook = {
          memoizedState: null,
          baseState: null,
          queue: null,
          baseUpdate: null,
          next: null
        };

        if (workInProgressHook === null) {
          firstWorkInProgressHook = workInProgressHook = hook;
        } else {
          workInProgressHook = workInProgressHook.next = hook;
        }

        return workInProgressHook;
      }

      function updateWorkInProgressHook() {
        if (nextWorkInProgressHook !== null) {
          workInProgressHook = nextWorkInProgressHook;
          nextWorkInProgressHook = workInProgressHook.next;
          currentHook = nextCurrentHook;
          nextCurrentHook = currentHook !== null ? currentHook.next : null;
        } else {
          (function () {
            if (!(nextCurrentHook !== null)) {
              throw ReactError(Error("Rendered more hooks than during the previous render."));
            }
          })();

          currentHook = nextCurrentHook;
          var newHook = {
            memoizedState: currentHook.memoizedState,
            baseState: currentHook.baseState,
            queue: currentHook.queue,
            baseUpdate: currentHook.baseUpdate,
            next: null
          };

          if (workInProgressHook === null) {
            workInProgressHook = firstWorkInProgressHook = newHook;
          } else {
            workInProgressHook = workInProgressHook.next = newHook;
          }

          nextCurrentHook = currentHook.next;
        }

        return workInProgressHook;
      }

      function createFunctionComponentUpdateQueue() {
        return {
          lastEffect: null
        };
      }

      function basicStateReducer(state, action) {
        return typeof action === "function" ? action(state) : action;
      }

      function mountReducer(reducer, initialArg, init) {
        var hook = mountWorkInProgressHook();
        var initialState = void 0;

        if (init !== undefined) {
          initialState = init(initialArg);
        } else {
          initialState = initialArg;
        }

        hook.memoizedState = hook.baseState = initialState;
        var queue = hook.queue = {
          last: null,
          dispatch: null,
          lastRenderedReducer: reducer,
          lastRenderedState: initialState
        };
        var dispatch = queue.dispatch = dispatchAction.bind(null, currentlyRenderingFiber$1, queue);
        return [hook.memoizedState, dispatch];
      }

      function updateReducer(reducer, initialArg, init) {
        var hook = updateWorkInProgressHook();
        var queue = hook.queue;

        (function () {
          if (!(queue !== null)) {
            throw ReactError(Error("Should have a queue. This is likely a bug in React. Please file an issue."));
          }
        })();

        queue.lastRenderedReducer = reducer;

        if (numberOfReRenders > 0) {
          var _dispatch = queue.dispatch;

          if (renderPhaseUpdates !== null) {
            var firstRenderPhaseUpdate = renderPhaseUpdates.get(queue);

            if (firstRenderPhaseUpdate !== undefined) {
              renderPhaseUpdates.delete(queue);
              var newState = hook.memoizedState;
              var update = firstRenderPhaseUpdate;

              do {
                var _action = update.action;
                newState = reducer(newState, _action);
                update = update.next;
              } while (update !== null);

              if (!is(newState, hook.memoizedState)) {
                markWorkInProgressReceivedUpdate();
              }

              hook.memoizedState = newState;

              if (hook.baseUpdate === queue.last) {
                hook.baseState = newState;
              }

              queue.lastRenderedState = newState;
              return [newState, _dispatch];
            }
          }

          return [hook.memoizedState, _dispatch];
        }

        var last = queue.last;
        var baseUpdate = hook.baseUpdate;
        var baseState = hook.baseState;
        var first = void 0;

        if (baseUpdate !== null) {
          if (last !== null) {
            last.next = null;
          }

          first = baseUpdate.next;
        } else {
          first = last !== null ? last.next : null;
        }

        if (first !== null) {
          var _newState = baseState;
          var newBaseState = null;
          var newBaseUpdate = null;
          var prevUpdate = baseUpdate;
          var _update = first;
          var didSkip = false;

          do {
            var updateExpirationTime = _update.expirationTime;

            if (updateExpirationTime < renderExpirationTime$1) {
              if (!didSkip) {
                didSkip = true;
                newBaseUpdate = prevUpdate;
                newBaseState = _newState;
              }

              if (updateExpirationTime > remainingExpirationTime) {
                remainingExpirationTime = updateExpirationTime;
              }
            } else {
              markRenderEventTimeAndConfig(updateExpirationTime, _update.suspenseConfig);

              if (_update.eagerReducer === reducer) {
                _newState = _update.eagerState;
              } else {
                var _action2 = _update.action;
                _newState = reducer(_newState, _action2);
              }
            }

            prevUpdate = _update;
            _update = _update.next;
          } while (_update !== null && _update !== first);

          if (!didSkip) {
            newBaseUpdate = prevUpdate;
            newBaseState = _newState;
          }

          if (!is(_newState, hook.memoizedState)) {
            markWorkInProgressReceivedUpdate();
          }

          hook.memoizedState = _newState;
          hook.baseUpdate = newBaseUpdate;
          hook.baseState = newBaseState;
          queue.lastRenderedState = _newState;
        }

        var dispatch = queue.dispatch;
        return [hook.memoizedState, dispatch];
      }

      function mountState(initialState) {
        var hook = mountWorkInProgressHook();

        if (typeof initialState === "function") {
          initialState = initialState();
        }

        hook.memoizedState = hook.baseState = initialState;
        var queue = hook.queue = {
          last: null,
          dispatch: null,
          lastRenderedReducer: basicStateReducer,
          lastRenderedState: initialState
        };
        var dispatch = queue.dispatch = dispatchAction.bind(null, currentlyRenderingFiber$1, queue);
        return [hook.memoizedState, dispatch];
      }

      function updateState(initialState) {
        return updateReducer(basicStateReducer, initialState);
      }

      function pushEffect(tag, create, destroy, deps) {
        var effect = {
          tag: tag,
          create: create,
          destroy: destroy,
          deps: deps,
          next: null
        };

        if (componentUpdateQueue === null) {
          componentUpdateQueue = createFunctionComponentUpdateQueue();
          componentUpdateQueue.lastEffect = effect.next = effect;
        } else {
          var _lastEffect = componentUpdateQueue.lastEffect;

          if (_lastEffect === null) {
            componentUpdateQueue.lastEffect = effect.next = effect;
          } else {
            var firstEffect = _lastEffect.next;
            _lastEffect.next = effect;
            effect.next = firstEffect;
            componentUpdateQueue.lastEffect = effect;
          }
        }

        return effect;
      }

      function mountRef(initialValue) {
        var hook = mountWorkInProgressHook();
        var ref = {
          current: initialValue
        };
        {
          Object.seal(ref);
        }
        hook.memoizedState = ref;
        return ref;
      }

      function updateRef(initialValue) {
        var hook = updateWorkInProgressHook();
        return hook.memoizedState;
      }

      function mountEffectImpl(fiberEffectTag, hookEffectTag, create, deps) {
        var hook = mountWorkInProgressHook();
        var nextDeps = deps === undefined ? null : deps;
        sideEffectTag |= fiberEffectTag;
        hook.memoizedState = pushEffect(hookEffectTag, create, undefined, nextDeps);
      }

      function updateEffectImpl(fiberEffectTag, hookEffectTag, create, deps) {
        var hook = updateWorkInProgressHook();
        var nextDeps = deps === undefined ? null : deps;
        var destroy = undefined;

        if (currentHook !== null) {
          var prevEffect = currentHook.memoizedState;
          destroy = prevEffect.destroy;

          if (nextDeps !== null) {
            var prevDeps = prevEffect.deps;

            if (areHookInputsEqual(nextDeps, prevDeps)) {
              pushEffect(NoEffect$1, create, destroy, nextDeps);
              return;
            }
          }
        }

        sideEffectTag |= fiberEffectTag;
        hook.memoizedState = pushEffect(hookEffectTag, create, destroy, nextDeps);
      }

      function mountEffect(create, deps) {
        {
          if ("undefined" !== typeof jest) {
            warnIfNotCurrentlyActingEffectsInDEV(currentlyRenderingFiber$1);
          }
        }
        return mountEffectImpl(Update | Passive, UnmountPassive | MountPassive, create, deps);
      }

      function updateEffect(create, deps) {
        {
          if ("undefined" !== typeof jest) {
            warnIfNotCurrentlyActingEffectsInDEV(currentlyRenderingFiber$1);
          }
        }
        return updateEffectImpl(Update | Passive, UnmountPassive | MountPassive, create, deps);
      }

      function mountLayoutEffect(create, deps) {
        return mountEffectImpl(Update, UnmountMutation | MountLayout, create, deps);
      }

      function updateLayoutEffect(create, deps) {
        return updateEffectImpl(Update, UnmountMutation | MountLayout, create, deps);
      }

      function imperativeHandleEffect(create, ref) {
        if (typeof ref === "function") {
          var refCallback = ref;

          var _inst = create();

          refCallback(_inst);
          return function () {
            refCallback(null);
          };
        } else if (ref !== null && ref !== undefined) {
          var refObject = ref;
          {
            !refObject.hasOwnProperty("current") ? warning$1(false, "Expected useImperativeHandle() first argument to either be a " + "ref callback or React.createRef() object. Instead received: %s.", "an object with keys {" + Object.keys(refObject).join(", ") + "}") : void 0;
          }

          var _inst2 = create();

          refObject.current = _inst2;
          return function () {
            refObject.current = null;
          };
        }
      }

      function mountImperativeHandle(ref, create, deps) {
        {
          !(typeof create === "function") ? warning$1(false, "Expected useImperativeHandle() second argument to be a function " + "that creates a handle. Instead received: %s.", create !== null ? typeof create : "null") : void 0;
        }
        var effectDeps = deps !== null && deps !== undefined ? deps.concat([ref]) : null;
        return mountEffectImpl(Update, UnmountMutation | MountLayout, imperativeHandleEffect.bind(null, create, ref), effectDeps);
      }

      function updateImperativeHandle(ref, create, deps) {
        {
          !(typeof create === "function") ? warning$1(false, "Expected useImperativeHandle() second argument to be a function " + "that creates a handle. Instead received: %s.", create !== null ? typeof create : "null") : void 0;
        }
        var effectDeps = deps !== null && deps !== undefined ? deps.concat([ref]) : null;
        return updateEffectImpl(Update, UnmountMutation | MountLayout, imperativeHandleEffect.bind(null, create, ref), effectDeps);
      }

      function mountDebugValue(value, formatterFn) {}

      var updateDebugValue = mountDebugValue;

      function mountCallback(callback, deps) {
        var hook = mountWorkInProgressHook();
        var nextDeps = deps === undefined ? null : deps;
        hook.memoizedState = [callback, nextDeps];
        return callback;
      }

      function updateCallback(callback, deps) {
        var hook = updateWorkInProgressHook();
        var nextDeps = deps === undefined ? null : deps;
        var prevState = hook.memoizedState;

        if (prevState !== null) {
          if (nextDeps !== null) {
            var prevDeps = prevState[1];

            if (areHookInputsEqual(nextDeps, prevDeps)) {
              return prevState[0];
            }
          }
        }

        hook.memoizedState = [callback, nextDeps];
        return callback;
      }

      function mountMemo(nextCreate, deps) {
        var hook = mountWorkInProgressHook();
        var nextDeps = deps === undefined ? null : deps;
        var nextValue = nextCreate();
        hook.memoizedState = [nextValue, nextDeps];
        return nextValue;
      }

      function updateMemo(nextCreate, deps) {
        var hook = updateWorkInProgressHook();
        var nextDeps = deps === undefined ? null : deps;
        var prevState = hook.memoizedState;

        if (prevState !== null) {
          if (nextDeps !== null) {
            var prevDeps = prevState[1];

            if (areHookInputsEqual(nextDeps, prevDeps)) {
              return prevState[0];
            }
          }
        }

        var nextValue = nextCreate();
        hook.memoizedState = [nextValue, nextDeps];
        return nextValue;
      }

      function dispatchAction(fiber, queue, action) {
        (function () {
          if (!(numberOfReRenders < RE_RENDER_LIMIT)) {
            throw ReactError(Error("Too many re-renders. React limits the number of renders to prevent an infinite loop."));
          }
        })();

        {
          !(arguments.length <= 3) ? warning$1(false, "State updates from the useState() and useReducer() Hooks don't support the " + "second callback argument. To execute a side effect after " + "rendering, declare it in the component body with useEffect().") : void 0;
        }
        var alternate = fiber.alternate;

        if (fiber === currentlyRenderingFiber$1 || alternate !== null && alternate === currentlyRenderingFiber$1) {
          didScheduleRenderPhaseUpdate = true;
          var update = {
            expirationTime: renderExpirationTime$1,
            suspenseConfig: null,
            action: action,
            eagerReducer: null,
            eagerState: null,
            next: null
          };
          {
            update.priority = getCurrentPriorityLevel();
          }

          if (renderPhaseUpdates === null) {
            renderPhaseUpdates = new Map();
          }

          var firstRenderPhaseUpdate = renderPhaseUpdates.get(queue);

          if (firstRenderPhaseUpdate === undefined) {
            renderPhaseUpdates.set(queue, update);
          } else {
            var lastRenderPhaseUpdate = firstRenderPhaseUpdate;

            while (lastRenderPhaseUpdate.next !== null) {
              lastRenderPhaseUpdate = lastRenderPhaseUpdate.next;
            }

            lastRenderPhaseUpdate.next = update;
          }
        } else {
          if (revertPassiveEffectsChange) {
            flushPassiveEffects();
          }

          var currentTime = requestCurrentTime();

          var _suspenseConfig = requestCurrentSuspenseConfig();

          var _expirationTime = computeExpirationForFiber(currentTime, fiber, _suspenseConfig);

          var _update2 = {
            expirationTime: _expirationTime,
            suspenseConfig: _suspenseConfig,
            action: action,
            eagerReducer: null,
            eagerState: null,
            next: null
          };
          {
            _update2.priority = getCurrentPriorityLevel();
          }
          var _last = queue.last;

          if (_last === null) {
            _update2.next = _update2;
          } else {
            var first = _last.next;

            if (first !== null) {
              _update2.next = first;
            }

            _last.next = _update2;
          }

          queue.last = _update2;

          if (fiber.expirationTime === NoWork && (alternate === null || alternate.expirationTime === NoWork)) {
            var _lastRenderedReducer = queue.lastRenderedReducer;

            if (_lastRenderedReducer !== null) {
              var prevDispatcher = void 0;
              {
                prevDispatcher = ReactCurrentDispatcher$1.current;
                ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnUpdateInDEV;
              }

              try {
                var currentState = queue.lastRenderedState;

                var _eagerState = _lastRenderedReducer(currentState, action);

                _update2.eagerReducer = _lastRenderedReducer;
                _update2.eagerState = _eagerState;

                if (is(_eagerState, currentState)) {
                  return;
                }
              } catch (error) {} finally {
                {
                  ReactCurrentDispatcher$1.current = prevDispatcher;
                }
              }
            }
          }

          {
            if ("undefined" !== typeof jest) {
              warnIfNotScopedWithMatchingAct(fiber);
              warnIfNotCurrentlyActingUpdatesInDev(fiber);
            }
          }
          scheduleWork(fiber, _expirationTime);
        }
      }

      var ContextOnlyDispatcher = {
        readContext: _readContext,
        useCallback: throwInvalidHookError,
        useContext: throwInvalidHookError,
        useEffect: throwInvalidHookError,
        useImperativeHandle: throwInvalidHookError,
        useLayoutEffect: throwInvalidHookError,
        useMemo: throwInvalidHookError,
        useReducer: throwInvalidHookError,
        useRef: throwInvalidHookError,
        useState: throwInvalidHookError,
        useDebugValue: throwInvalidHookError,
        useResponder: throwInvalidHookError
      };
      var HooksDispatcherOnMountInDEV = null;
      var HooksDispatcherOnMountWithHookTypesInDEV = null;
      var HooksDispatcherOnUpdateInDEV = null;
      var InvalidNestedHooksDispatcherOnMountInDEV = null;
      var InvalidNestedHooksDispatcherOnUpdateInDEV = null;
      {
        var warnInvalidContextAccess = function warnInvalidContextAccess() {
          warning$1(false, "Context can only be read while React is rendering. " + "In classes, you can read it in the render method or getDerivedStateFromProps. " + "In function components, you can read it directly in the function body, but not " + "inside Hooks like useReducer() or useMemo().");
        };

        var warnInvalidHookAccess = function warnInvalidHookAccess() {
          warning$1(false, "Do not call Hooks inside useEffect(...), useMemo(...), or other built-in Hooks. " + "You can only call Hooks at the top level of your React function. " + "For more information, see " + "https://fb.me/rules-of-hooks");
        };

        HooksDispatcherOnMountInDEV = {
          readContext: function readContext(context, observedBits) {
            return _readContext(context, observedBits);
          },
          useCallback: function useCallback(callback, deps) {
            currentHookNameInDev = "useCallback";
            mountHookTypesDev();
            checkDepsAreArrayDev(deps);
            return mountCallback(callback, deps);
          },
          useContext: function useContext(context, observedBits) {
            currentHookNameInDev = "useContext";
            mountHookTypesDev();
            return _readContext(context, observedBits);
          },
          useEffect: function useEffect(create, deps) {
            currentHookNameInDev = "useEffect";
            mountHookTypesDev();
            checkDepsAreArrayDev(deps);
            return mountEffect(create, deps);
          },
          useImperativeHandle: function useImperativeHandle(ref, create, deps) {
            currentHookNameInDev = "useImperativeHandle";
            mountHookTypesDev();
            checkDepsAreArrayDev(deps);
            return mountImperativeHandle(ref, create, deps);
          },
          useLayoutEffect: function useLayoutEffect(create, deps) {
            currentHookNameInDev = "useLayoutEffect";
            mountHookTypesDev();
            checkDepsAreArrayDev(deps);
            return mountLayoutEffect(create, deps);
          },
          useMemo: function useMemo(create, deps) {
            currentHookNameInDev = "useMemo";
            mountHookTypesDev();
            checkDepsAreArrayDev(deps);
            var prevDispatcher = ReactCurrentDispatcher$1.current;
            ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnMountInDEV;

            try {
              return mountMemo(create, deps);
            } finally {
              ReactCurrentDispatcher$1.current = prevDispatcher;
            }
          },
          useReducer: function useReducer(reducer, initialArg, init) {
            currentHookNameInDev = "useReducer";
            mountHookTypesDev();
            var prevDispatcher = ReactCurrentDispatcher$1.current;
            ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnMountInDEV;

            try {
              return mountReducer(reducer, initialArg, init);
            } finally {
              ReactCurrentDispatcher$1.current = prevDispatcher;
            }
          },
          useRef: function useRef(initialValue) {
            currentHookNameInDev = "useRef";
            mountHookTypesDev();
            return mountRef(initialValue);
          },
          useState: function useState(initialState) {
            currentHookNameInDev = "useState";
            mountHookTypesDev();
            var prevDispatcher = ReactCurrentDispatcher$1.current;
            ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnMountInDEV;

            try {
              return mountState(initialState);
            } finally {
              ReactCurrentDispatcher$1.current = prevDispatcher;
            }
          },
          useDebugValue: function useDebugValue(value, formatterFn) {
            currentHookNameInDev = "useDebugValue";
            mountHookTypesDev();
            return mountDebugValue(value, formatterFn);
          },
          useResponder: function useResponder(responder, props) {
            currentHookNameInDev = "useResponder";
            mountHookTypesDev();
            return createResponderListener(responder, props);
          }
        };
        HooksDispatcherOnMountWithHookTypesInDEV = {
          readContext: function readContext(context, observedBits) {
            return _readContext(context, observedBits);
          },
          useCallback: function useCallback(callback, deps) {
            currentHookNameInDev = "useCallback";
            updateHookTypesDev();
            return mountCallback(callback, deps);
          },
          useContext: function useContext(context, observedBits) {
            currentHookNameInDev = "useContext";
            updateHookTypesDev();
            return _readContext(context, observedBits);
          },
          useEffect: function useEffect(create, deps) {
            currentHookNameInDev = "useEffect";
            updateHookTypesDev();
            return mountEffect(create, deps);
          },
          useImperativeHandle: function useImperativeHandle(ref, create, deps) {
            currentHookNameInDev = "useImperativeHandle";
            updateHookTypesDev();
            return mountImperativeHandle(ref, create, deps);
          },
          useLayoutEffect: function useLayoutEffect(create, deps) {
            currentHookNameInDev = "useLayoutEffect";
            updateHookTypesDev();
            return mountLayoutEffect(create, deps);
          },
          useMemo: function useMemo(create, deps) {
            currentHookNameInDev = "useMemo";
            updateHookTypesDev();
            var prevDispatcher = ReactCurrentDispatcher$1.current;
            ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnMountInDEV;

            try {
              return mountMemo(create, deps);
            } finally {
              ReactCurrentDispatcher$1.current = prevDispatcher;
            }
          },
          useReducer: function useReducer(reducer, initialArg, init) {
            currentHookNameInDev = "useReducer";
            updateHookTypesDev();
            var prevDispatcher = ReactCurrentDispatcher$1.current;
            ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnMountInDEV;

            try {
              return mountReducer(reducer, initialArg, init);
            } finally {
              ReactCurrentDispatcher$1.current = prevDispatcher;
            }
          },
          useRef: function useRef(initialValue) {
            currentHookNameInDev = "useRef";
            updateHookTypesDev();
            return mountRef(initialValue);
          },
          useState: function useState(initialState) {
            currentHookNameInDev = "useState";
            updateHookTypesDev();
            var prevDispatcher = ReactCurrentDispatcher$1.current;
            ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnMountInDEV;

            try {
              return mountState(initialState);
            } finally {
              ReactCurrentDispatcher$1.current = prevDispatcher;
            }
          },
          useDebugValue: function useDebugValue(value, formatterFn) {
            currentHookNameInDev = "useDebugValue";
            updateHookTypesDev();
            return mountDebugValue(value, formatterFn);
          },
          useResponder: function useResponder(responder, props) {
            currentHookNameInDev = "useResponder";
            updateHookTypesDev();
            return createResponderListener(responder, props);
          }
        };
        HooksDispatcherOnUpdateInDEV = {
          readContext: function readContext(context, observedBits) {
            return _readContext(context, observedBits);
          },
          useCallback: function useCallback(callback, deps) {
            currentHookNameInDev = "useCallback";
            updateHookTypesDev();
            return updateCallback(callback, deps);
          },
          useContext: function useContext(context, observedBits) {
            currentHookNameInDev = "useContext";
            updateHookTypesDev();
            return _readContext(context, observedBits);
          },
          useEffect: function useEffect(create, deps) {
            currentHookNameInDev = "useEffect";
            updateHookTypesDev();
            return updateEffect(create, deps);
          },
          useImperativeHandle: function useImperativeHandle(ref, create, deps) {
            currentHookNameInDev = "useImperativeHandle";
            updateHookTypesDev();
            return updateImperativeHandle(ref, create, deps);
          },
          useLayoutEffect: function useLayoutEffect(create, deps) {
            currentHookNameInDev = "useLayoutEffect";
            updateHookTypesDev();
            return updateLayoutEffect(create, deps);
          },
          useMemo: function useMemo(create, deps) {
            currentHookNameInDev = "useMemo";
            updateHookTypesDev();
            var prevDispatcher = ReactCurrentDispatcher$1.current;
            ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnUpdateInDEV;

            try {
              return updateMemo(create, deps);
            } finally {
              ReactCurrentDispatcher$1.current = prevDispatcher;
            }
          },
          useReducer: function useReducer(reducer, initialArg, init) {
            currentHookNameInDev = "useReducer";
            updateHookTypesDev();
            var prevDispatcher = ReactCurrentDispatcher$1.current;
            ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnUpdateInDEV;

            try {
              return updateReducer(reducer, initialArg, init);
            } finally {
              ReactCurrentDispatcher$1.current = prevDispatcher;
            }
          },
          useRef: function useRef(initialValue) {
            currentHookNameInDev = "useRef";
            updateHookTypesDev();
            return updateRef(initialValue);
          },
          useState: function useState(initialState) {
            currentHookNameInDev = "useState";
            updateHookTypesDev();
            var prevDispatcher = ReactCurrentDispatcher$1.current;
            ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnUpdateInDEV;

            try {
              return updateState(initialState);
            } finally {
              ReactCurrentDispatcher$1.current = prevDispatcher;
            }
          },
          useDebugValue: function useDebugValue(value, formatterFn) {
            currentHookNameInDev = "useDebugValue";
            updateHookTypesDev();
            return updateDebugValue(value, formatterFn);
          },
          useResponder: function useResponder(responder, props) {
            currentHookNameInDev = "useResponder";
            updateHookTypesDev();
            return createResponderListener(responder, props);
          }
        };
        InvalidNestedHooksDispatcherOnMountInDEV = {
          readContext: function readContext(context, observedBits) {
            warnInvalidContextAccess();
            return _readContext(context, observedBits);
          },
          useCallback: function useCallback(callback, deps) {
            currentHookNameInDev = "useCallback";
            warnInvalidHookAccess();
            mountHookTypesDev();
            return mountCallback(callback, deps);
          },
          useContext: function useContext(context, observedBits) {
            currentHookNameInDev = "useContext";
            warnInvalidHookAccess();
            mountHookTypesDev();
            return _readContext(context, observedBits);
          },
          useEffect: function useEffect(create, deps) {
            currentHookNameInDev = "useEffect";
            warnInvalidHookAccess();
            mountHookTypesDev();
            return mountEffect(create, deps);
          },
          useImperativeHandle: function useImperativeHandle(ref, create, deps) {
            currentHookNameInDev = "useImperativeHandle";
            warnInvalidHookAccess();
            mountHookTypesDev();
            return mountImperativeHandle(ref, create, deps);
          },
          useLayoutEffect: function useLayoutEffect(create, deps) {
            currentHookNameInDev = "useLayoutEffect";
            warnInvalidHookAccess();
            mountHookTypesDev();
            return mountLayoutEffect(create, deps);
          },
          useMemo: function useMemo(create, deps) {
            currentHookNameInDev = "useMemo";
            warnInvalidHookAccess();
            mountHookTypesDev();
            var prevDispatcher = ReactCurrentDispatcher$1.current;
            ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnMountInDEV;

            try {
              return mountMemo(create, deps);
            } finally {
              ReactCurrentDispatcher$1.current = prevDispatcher;
            }
          },
          useReducer: function useReducer(reducer, initialArg, init) {
            currentHookNameInDev = "useReducer";
            warnInvalidHookAccess();
            mountHookTypesDev();
            var prevDispatcher = ReactCurrentDispatcher$1.current;
            ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnMountInDEV;

            try {
              return mountReducer(reducer, initialArg, init);
            } finally {
              ReactCurrentDispatcher$1.current = prevDispatcher;
            }
          },
          useRef: function useRef(initialValue) {
            currentHookNameInDev = "useRef";
            warnInvalidHookAccess();
            mountHookTypesDev();
            return mountRef(initialValue);
          },
          useState: function useState(initialState) {
            currentHookNameInDev = "useState";
            warnInvalidHookAccess();
            mountHookTypesDev();
            var prevDispatcher = ReactCurrentDispatcher$1.current;
            ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnMountInDEV;

            try {
              return mountState(initialState);
            } finally {
              ReactCurrentDispatcher$1.current = prevDispatcher;
            }
          },
          useDebugValue: function useDebugValue(value, formatterFn) {
            currentHookNameInDev = "useDebugValue";
            warnInvalidHookAccess();
            mountHookTypesDev();
            return mountDebugValue(value, formatterFn);
          },
          useResponder: function useResponder(responder, props) {
            currentHookNameInDev = "useResponder";
            warnInvalidHookAccess();
            mountHookTypesDev();
            return createResponderListener(responder, props);
          }
        };
        InvalidNestedHooksDispatcherOnUpdateInDEV = {
          readContext: function readContext(context, observedBits) {
            warnInvalidContextAccess();
            return _readContext(context, observedBits);
          },
          useCallback: function useCallback(callback, deps) {
            currentHookNameInDev = "useCallback";
            warnInvalidHookAccess();
            updateHookTypesDev();
            return updateCallback(callback, deps);
          },
          useContext: function useContext(context, observedBits) {
            currentHookNameInDev = "useContext";
            warnInvalidHookAccess();
            updateHookTypesDev();
            return _readContext(context, observedBits);
          },
          useEffect: function useEffect(create, deps) {
            currentHookNameInDev = "useEffect";
            warnInvalidHookAccess();
            updateHookTypesDev();
            return updateEffect(create, deps);
          },
          useImperativeHandle: function useImperativeHandle(ref, create, deps) {
            currentHookNameInDev = "useImperativeHandle";
            warnInvalidHookAccess();
            updateHookTypesDev();
            return updateImperativeHandle(ref, create, deps);
          },
          useLayoutEffect: function useLayoutEffect(create, deps) {
            currentHookNameInDev = "useLayoutEffect";
            warnInvalidHookAccess();
            updateHookTypesDev();
            return updateLayoutEffect(create, deps);
          },
          useMemo: function useMemo(create, deps) {
            currentHookNameInDev = "useMemo";
            warnInvalidHookAccess();
            updateHookTypesDev();
            var prevDispatcher = ReactCurrentDispatcher$1.current;
            ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnUpdateInDEV;

            try {
              return updateMemo(create, deps);
            } finally {
              ReactCurrentDispatcher$1.current = prevDispatcher;
            }
          },
          useReducer: function useReducer(reducer, initialArg, init) {
            currentHookNameInDev = "useReducer";
            warnInvalidHookAccess();
            updateHookTypesDev();
            var prevDispatcher = ReactCurrentDispatcher$1.current;
            ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnUpdateInDEV;

            try {
              return updateReducer(reducer, initialArg, init);
            } finally {
              ReactCurrentDispatcher$1.current = prevDispatcher;
            }
          },
          useRef: function useRef(initialValue) {
            currentHookNameInDev = "useRef";
            warnInvalidHookAccess();
            updateHookTypesDev();
            return updateRef(initialValue);
          },
          useState: function useState(initialState) {
            currentHookNameInDev = "useState";
            warnInvalidHookAccess();
            updateHookTypesDev();
            var prevDispatcher = ReactCurrentDispatcher$1.current;
            ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnUpdateInDEV;

            try {
              return updateState(initialState);
            } finally {
              ReactCurrentDispatcher$1.current = prevDispatcher;
            }
          },
          useDebugValue: function useDebugValue(value, formatterFn) {
            currentHookNameInDev = "useDebugValue";
            warnInvalidHookAccess();
            updateHookTypesDev();
            return updateDebugValue(value, formatterFn);
          },
          useResponder: function useResponder(responder, props) {
            currentHookNameInDev = "useResponder";
            warnInvalidHookAccess();
            updateHookTypesDev();
            return createResponderListener(responder, props);
          }
        };
      }
      var now$1 = Scheduler.unstable_now;
      var commitTime = 0;
      var profilerStartTime = -1;

      function getCommitTime() {
        return commitTime;
      }

      function recordCommitTime() {
        if (!enableProfilerTimer) {
          return;
        }

        commitTime = now$1();
      }

      function startProfilerTimer(fiber) {
        if (!enableProfilerTimer) {
          return;
        }

        profilerStartTime = now$1();

        if (fiber.actualStartTime < 0) {
          fiber.actualStartTime = now$1();
        }
      }

      function stopProfilerTimerIfRunning(fiber) {
        if (!enableProfilerTimer) {
          return;
        }

        profilerStartTime = -1;
      }

      function stopProfilerTimerIfRunningAndRecordDelta(fiber, overrideBaseTime) {
        if (!enableProfilerTimer) {
          return;
        }

        if (profilerStartTime >= 0) {
          var elapsedTime = now$1() - profilerStartTime;
          fiber.actualDuration += elapsedTime;

          if (overrideBaseTime) {
            fiber.selfBaseDuration = elapsedTime;
          }

          profilerStartTime = -1;
        }
      }

      var hydrationParentFiber = null;
      var nextHydratableInstance = null;
      var isHydrating = false;

      function warnIfHydrating() {
        {
          !!isHydrating ? warning$1(false, "We should not be hydrating here. This is a bug in React. Please file a bug.") : void 0;
        }
      }

      function enterHydrationState(fiber) {
        if (!supportsHydration) {
          return false;
        }

        var parentInstance = fiber.stateNode.containerInfo;
        nextHydratableInstance = getFirstHydratableChild(parentInstance);
        hydrationParentFiber = fiber;
        isHydrating = true;
        return true;
      }

      function reenterHydrationStateFromDehydratedSuspenseInstance(fiber) {
        if (!supportsHydration) {
          return false;
        }

        var suspenseInstance = fiber.stateNode;
        nextHydratableInstance = getNextHydratableSibling(suspenseInstance);
        popToNextHostParent(fiber);
        isHydrating = true;
        return true;
      }

      function deleteHydratableInstance(returnFiber, instance) {
        {
          switch (returnFiber.tag) {
            case HostRoot:
              didNotHydrateContainerInstance(returnFiber.stateNode.containerInfo, instance);
              break;

            case HostComponent:
              didNotHydrateInstance(returnFiber.type, returnFiber.memoizedProps, returnFiber.stateNode, instance);
              break;
          }
        }
        var childToDelete = createFiberFromHostInstanceForDeletion();
        childToDelete.stateNode = instance;
        childToDelete.return = returnFiber;
        childToDelete.effectTag = Deletion;

        if (returnFiber.lastEffect !== null) {
          returnFiber.lastEffect.nextEffect = childToDelete;
          returnFiber.lastEffect = childToDelete;
        } else {
          returnFiber.firstEffect = returnFiber.lastEffect = childToDelete;
        }
      }

      function insertNonHydratedInstance(returnFiber, fiber) {
        fiber.effectTag |= Placement;
        {
          switch (returnFiber.tag) {
            case HostRoot:
              {
                var parentContainer = returnFiber.stateNode.containerInfo;

                switch (fiber.tag) {
                  case HostComponent:
                    var type = fiber.type;
                    var props = fiber.pendingProps;
                    didNotFindHydratableContainerInstance(parentContainer, type, props);
                    break;

                  case HostText:
                    var text = fiber.pendingProps;
                    didNotFindHydratableContainerTextInstance(parentContainer, text);
                    break;

                  case SuspenseComponent:
                    didNotFindHydratableContainerSuspenseInstance(parentContainer);
                    break;
                }

                break;
              }

            case HostComponent:
              {
                var parentType = returnFiber.type;
                var parentProps = returnFiber.memoizedProps;
                var parentInstance = returnFiber.stateNode;

                switch (fiber.tag) {
                  case HostComponent:
                    var _type = fiber.type;
                    var _props = fiber.pendingProps;
                    didNotFindHydratableInstance(parentType, parentProps, parentInstance, _type, _props);
                    break;

                  case HostText:
                    var _text = fiber.pendingProps;
                    didNotFindHydratableTextInstance(parentType, parentProps, parentInstance, _text);
                    break;

                  case SuspenseComponent:
                    didNotFindHydratableSuspenseInstance(parentType, parentProps, parentInstance);
                    break;
                }

                break;
              }

            default:
              return;
          }
        }
      }

      function tryHydrate(fiber, nextInstance) {
        switch (fiber.tag) {
          case HostComponent:
            {
              var type = fiber.type;
              var props = fiber.pendingProps;
              var instance = canHydrateInstance(nextInstance, type, props);

              if (instance !== null) {
                fiber.stateNode = instance;
                return true;
              }

              return false;
            }

          case HostText:
            {
              var text = fiber.pendingProps;
              var textInstance = canHydrateTextInstance(nextInstance, text);

              if (textInstance !== null) {
                fiber.stateNode = textInstance;
                return true;
              }

              return false;
            }

          case SuspenseComponent:
            {
              if (enableSuspenseServerRenderer) {
                var suspenseInstance = canHydrateSuspenseInstance(nextInstance);

                if (suspenseInstance !== null) {
                  fiber.tag = DehydratedSuspenseComponent;
                  fiber.stateNode = suspenseInstance;
                  return true;
                }
              }

              return false;
            }

          default:
            return false;
        }
      }

      function tryToClaimNextHydratableInstance(fiber) {
        if (!isHydrating) {
          return;
        }

        var nextInstance = nextHydratableInstance;

        if (!nextInstance) {
          insertNonHydratedInstance(hydrationParentFiber, fiber);
          isHydrating = false;
          hydrationParentFiber = fiber;
          return;
        }

        var firstAttemptedInstance = nextInstance;

        if (!tryHydrate(fiber, nextInstance)) {
          nextInstance = getNextHydratableSibling(firstAttemptedInstance);

          if (!nextInstance || !tryHydrate(fiber, nextInstance)) {
            insertNonHydratedInstance(hydrationParentFiber, fiber);
            isHydrating = false;
            hydrationParentFiber = fiber;
            return;
          }

          deleteHydratableInstance(hydrationParentFiber, firstAttemptedInstance);
        }

        hydrationParentFiber = fiber;
        nextHydratableInstance = getFirstHydratableChild(nextInstance);
      }

      function prepareToHydrateHostInstance(fiber, rootContainerInstance, hostContext) {
        if (!supportsHydration) {
          (function () {
            {
              throw ReactError(Error("Expected prepareToHydrateHostInstance() to never be called. This error is likely caused by a bug in React. Please file an issue."));
            }
          })();
        }

        var instance = fiber.stateNode;
        var updatePayload = hydrateInstance(instance, fiber.type, fiber.memoizedProps, rootContainerInstance, hostContext, fiber);
        fiber.updateQueue = updatePayload;

        if (updatePayload !== null) {
          return true;
        }

        return false;
      }

      function prepareToHydrateHostTextInstance(fiber) {
        if (!supportsHydration) {
          (function () {
            {
              throw ReactError(Error("Expected prepareToHydrateHostTextInstance() to never be called. This error is likely caused by a bug in React. Please file an issue."));
            }
          })();
        }

        var textInstance = fiber.stateNode;
        var textContent = fiber.memoizedProps;
        var shouldUpdate = hydrateTextInstance(textInstance, textContent, fiber);
        {
          if (shouldUpdate) {
            var returnFiber = hydrationParentFiber;

            if (returnFiber !== null) {
              switch (returnFiber.tag) {
                case HostRoot:
                  {
                    var parentContainer = returnFiber.stateNode.containerInfo;
                    didNotMatchHydratedContainerTextInstance(parentContainer, textInstance, textContent);
                    break;
                  }

                case HostComponent:
                  {
                    var parentType = returnFiber.type;
                    var parentProps = returnFiber.memoizedProps;
                    var parentInstance = returnFiber.stateNode;
                    didNotMatchHydratedTextInstance(parentType, parentProps, parentInstance, textInstance, textContent);
                    break;
                  }
              }
            }
          }
        }
        return shouldUpdate;
      }

      function skipPastDehydratedSuspenseInstance(fiber) {
        if (!supportsHydration) {
          (function () {
            {
              throw ReactError(Error("Expected skipPastDehydratedSuspenseInstance() to never be called. This error is likely caused by a bug in React. Please file an issue."));
            }
          })();
        }

        var suspenseInstance = fiber.stateNode;

        (function () {
          if (!suspenseInstance) {
            throw ReactError(Error("Expected to have a hydrated suspense instance. This error is likely caused by a bug in React. Please file an issue."));
          }
        })();

        nextHydratableInstance = getNextHydratableInstanceAfterSuspenseInstance(suspenseInstance);
      }

      function popToNextHostParent(fiber) {
        var parent = fiber.return;

        while (parent !== null && parent.tag !== HostComponent && parent.tag !== HostRoot && parent.tag !== DehydratedSuspenseComponent) {
          parent = parent.return;
        }

        hydrationParentFiber = parent;
      }

      function popHydrationState(fiber) {
        if (!supportsHydration) {
          return false;
        }

        if (fiber !== hydrationParentFiber) {
          return false;
        }

        if (!isHydrating) {
          popToNextHostParent(fiber);
          isHydrating = true;
          return false;
        }

        var type = fiber.type;

        if (fiber.tag !== HostComponent || type !== "head" && type !== "body" && !shouldSetTextContent(type, fiber.memoizedProps)) {
          var nextInstance = nextHydratableInstance;

          while (nextInstance) {
            deleteHydratableInstance(fiber, nextInstance);
            nextInstance = getNextHydratableSibling(nextInstance);
          }
        }

        popToNextHostParent(fiber);
        nextHydratableInstance = hydrationParentFiber ? getNextHydratableSibling(fiber.stateNode) : null;
        return true;
      }

      function resetHydrationState() {
        if (!supportsHydration) {
          return;
        }

        hydrationParentFiber = null;
        nextHydratableInstance = null;
        isHydrating = false;
      }

      var ReactCurrentOwner$3 = ReactSharedInternals.ReactCurrentOwner;
      var didReceiveUpdate = false;
      var didWarnAboutBadClass = void 0;
      var didWarnAboutModulePatternComponent = void 0;
      var didWarnAboutContextTypeOnFunctionComponent = void 0;
      var didWarnAboutGetDerivedStateOnFunctionComponent = void 0;
      var didWarnAboutFunctionRefs = void 0;
      var didWarnAboutReassigningProps = void 0;
      var didWarnAboutMaxDuration = void 0;
      var didWarnAboutRevealOrder = void 0;
      var didWarnAboutTailOptions = void 0;
      var didWarnAboutDefaultPropsOnFunctionComponent = void 0;
      {
        didWarnAboutBadClass = {};
        didWarnAboutModulePatternComponent = {};
        didWarnAboutContextTypeOnFunctionComponent = {};
        didWarnAboutGetDerivedStateOnFunctionComponent = {};
        didWarnAboutFunctionRefs = {};
        didWarnAboutReassigningProps = false;
        didWarnAboutMaxDuration = false;
        didWarnAboutRevealOrder = {};
        didWarnAboutTailOptions = {};
        didWarnAboutDefaultPropsOnFunctionComponent = {};
      }

      function reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime) {
        if (current$$1 === null) {
          workInProgress.child = mountChildFibers(workInProgress, null, nextChildren, renderExpirationTime);
        } else {
          workInProgress.child = reconcileChildFibers(workInProgress, current$$1.child, nextChildren, renderExpirationTime);
        }
      }

      function forceUnmountCurrentAndReconcile(current$$1, workInProgress, nextChildren, renderExpirationTime) {
        workInProgress.child = reconcileChildFibers(workInProgress, current$$1.child, null, renderExpirationTime);
        workInProgress.child = reconcileChildFibers(workInProgress, null, nextChildren, renderExpirationTime);
      }

      function updateForwardRef(current$$1, workInProgress, Component, nextProps, renderExpirationTime) {
        {
          if (workInProgress.type !== workInProgress.elementType) {
            var innerPropTypes = Component.propTypes;

            if (innerPropTypes) {
              checkPropTypes(innerPropTypes, nextProps, "prop", getComponentName(Component), getCurrentFiberStackInDev);
            }
          }
        }
        var render = Component.render;
        var ref = workInProgress.ref;
        var nextChildren = void 0;
        prepareToReadContext(workInProgress, renderExpirationTime);
        {
          ReactCurrentOwner$3.current = workInProgress;
          setCurrentPhase("render");
          nextChildren = renderWithHooks(current$$1, workInProgress, render, nextProps, ref, renderExpirationTime);

          if (debugRenderPhaseSideEffects || debugRenderPhaseSideEffectsForStrictMode && workInProgress.mode & StrictMode) {
            if (workInProgress.memoizedState !== null) {
              nextChildren = renderWithHooks(current$$1, workInProgress, render, nextProps, ref, renderExpirationTime);
            }
          }

          setCurrentPhase(null);
        }

        if (current$$1 !== null && !didReceiveUpdate) {
          bailoutHooks(current$$1, workInProgress, renderExpirationTime);
          return bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
        }

        workInProgress.effectTag |= PerformedWork;
        reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime);
        return workInProgress.child;
      }

      function updateMemoComponent(current$$1, workInProgress, Component, nextProps, updateExpirationTime, renderExpirationTime) {
        if (current$$1 === null) {
          var type = Component.type;

          if (isSimpleFunctionComponent(type) && Component.compare === null && Component.defaultProps === undefined) {
            var resolvedType = type;
            {
              resolvedType = resolveFunctionForHotReloading(type);
            }
            workInProgress.tag = SimpleMemoComponent;
            workInProgress.type = resolvedType;
            {
              validateFunctionComponentInDev(workInProgress, type);
            }
            return updateSimpleMemoComponent(current$$1, workInProgress, resolvedType, nextProps, updateExpirationTime, renderExpirationTime);
          }

          {
            var innerPropTypes = type.propTypes;

            if (innerPropTypes) {
              checkPropTypes(innerPropTypes, nextProps, "prop", getComponentName(type), getCurrentFiberStackInDev);
            }
          }
          var child = createFiberFromTypeAndProps(Component.type, null, nextProps, null, workInProgress.mode, renderExpirationTime);
          child.ref = workInProgress.ref;
          child.return = workInProgress;
          workInProgress.child = child;
          return child;
        }

        {
          var _type = Component.type;
          var _innerPropTypes = _type.propTypes;

          if (_innerPropTypes) {
            checkPropTypes(_innerPropTypes, nextProps, "prop", getComponentName(_type), getCurrentFiberStackInDev);
          }
        }
        var currentChild = current$$1.child;

        if (updateExpirationTime < renderExpirationTime) {
          var prevProps = currentChild.memoizedProps;
          var compare = Component.compare;
          compare = compare !== null ? compare : shallowEqual;

          if (compare(prevProps, nextProps) && current$$1.ref === workInProgress.ref) {
            return bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
          }
        }

        workInProgress.effectTag |= PerformedWork;
        var newChild = createWorkInProgress(currentChild, nextProps, renderExpirationTime);
        newChild.ref = workInProgress.ref;
        newChild.return = workInProgress;
        workInProgress.child = newChild;
        return newChild;
      }

      function updateSimpleMemoComponent(current$$1, workInProgress, Component, nextProps, updateExpirationTime, renderExpirationTime) {
        {
          if (workInProgress.type !== workInProgress.elementType) {
            var outerMemoType = workInProgress.elementType;

            if (outerMemoType.$$typeof === REACT_LAZY_TYPE) {
              outerMemoType = refineResolvedLazyComponent(outerMemoType);
            }

            var outerPropTypes = outerMemoType && outerMemoType.propTypes;

            if (outerPropTypes) {
              checkPropTypes(outerPropTypes, nextProps, "prop", getComponentName(outerMemoType), getCurrentFiberStackInDev);
            }
          }
        }

        if (current$$1 !== null) {
          var prevProps = current$$1.memoizedProps;

          if (shallowEqual(prevProps, nextProps) && current$$1.ref === workInProgress.ref && workInProgress.type === current$$1.type) {
            didReceiveUpdate = false;

            if (updateExpirationTime < renderExpirationTime) {
              return bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
            }
          }
        }

        return updateFunctionComponent(current$$1, workInProgress, Component, nextProps, renderExpirationTime);
      }

      function updateFragment(current$$1, workInProgress, renderExpirationTime) {
        var nextChildren = workInProgress.pendingProps;
        reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime);
        return workInProgress.child;
      }

      function updateMode(current$$1, workInProgress, renderExpirationTime) {
        var nextChildren = workInProgress.pendingProps.children;
        reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime);
        return workInProgress.child;
      }

      function updateProfiler(current$$1, workInProgress, renderExpirationTime) {
        if (enableProfilerTimer) {
          workInProgress.effectTag |= Update;
        }

        var nextProps = workInProgress.pendingProps;
        var nextChildren = nextProps.children;
        reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime);
        return workInProgress.child;
      }

      function markRef(current$$1, workInProgress) {
        var ref = workInProgress.ref;

        if (current$$1 === null && ref !== null || current$$1 !== null && current$$1.ref !== ref) {
          workInProgress.effectTag |= Ref;
        }
      }

      function updateFunctionComponent(current$$1, workInProgress, Component, nextProps, renderExpirationTime) {
        {
          if (workInProgress.type !== workInProgress.elementType) {
            var innerPropTypes = Component.propTypes;

            if (innerPropTypes) {
              checkPropTypes(innerPropTypes, nextProps, "prop", getComponentName(Component), getCurrentFiberStackInDev);
            }
          }
        }
        var context = void 0;

        if (!disableLegacyContext) {
          var unmaskedContext = getUnmaskedContext(workInProgress, Component, true);
          context = getMaskedContext(workInProgress, unmaskedContext);
        }

        var nextChildren = void 0;
        prepareToReadContext(workInProgress, renderExpirationTime);
        {
          ReactCurrentOwner$3.current = workInProgress;
          setCurrentPhase("render");
          nextChildren = renderWithHooks(current$$1, workInProgress, Component, nextProps, context, renderExpirationTime);

          if (debugRenderPhaseSideEffects || debugRenderPhaseSideEffectsForStrictMode && workInProgress.mode & StrictMode) {
            if (workInProgress.memoizedState !== null) {
              nextChildren = renderWithHooks(current$$1, workInProgress, Component, nextProps, context, renderExpirationTime);
            }
          }

          setCurrentPhase(null);
        }

        if (current$$1 !== null && !didReceiveUpdate) {
          bailoutHooks(current$$1, workInProgress, renderExpirationTime);
          return bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
        }

        workInProgress.effectTag |= PerformedWork;
        reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime);
        return workInProgress.child;
      }

      function updateClassComponent(current$$1, workInProgress, Component, nextProps, renderExpirationTime) {
        {
          if (workInProgress.type !== workInProgress.elementType) {
            var innerPropTypes = Component.propTypes;

            if (innerPropTypes) {
              checkPropTypes(innerPropTypes, nextProps, "prop", getComponentName(Component), getCurrentFiberStackInDev);
            }
          }
        }
        var hasContext = void 0;

        if (isContextProvider(Component)) {
          hasContext = true;
          pushContextProvider(workInProgress);
        } else {
          hasContext = false;
        }

        prepareToReadContext(workInProgress, renderExpirationTime);
        var instance = workInProgress.stateNode;
        var shouldUpdate = void 0;

        if (instance === null) {
          if (current$$1 !== null) {
            current$$1.alternate = null;
            workInProgress.alternate = null;
            workInProgress.effectTag |= Placement;
          }

          constructClassInstance(workInProgress, Component, nextProps, renderExpirationTime);
          mountClassInstance(workInProgress, Component, nextProps, renderExpirationTime);
          shouldUpdate = true;
        } else if (current$$1 === null) {
          shouldUpdate = resumeMountClassInstance(workInProgress, Component, nextProps, renderExpirationTime);
        } else {
          shouldUpdate = updateClassInstance(current$$1, workInProgress, Component, nextProps, renderExpirationTime);
        }

        var nextUnitOfWork = finishClassComponent(current$$1, workInProgress, Component, shouldUpdate, hasContext, renderExpirationTime);
        {
          var inst = workInProgress.stateNode;

          if (inst.props !== nextProps) {
            !didWarnAboutReassigningProps ? warning$1(false, "It looks like %s is reassigning its own `this.props` while rendering. " + "This is not supported and can lead to confusing bugs.", getComponentName(workInProgress.type) || "a component") : void 0;
            didWarnAboutReassigningProps = true;
          }
        }
        return nextUnitOfWork;
      }

      function finishClassComponent(current$$1, workInProgress, Component, shouldUpdate, hasContext, renderExpirationTime) {
        markRef(current$$1, workInProgress);
        var didCaptureError = (workInProgress.effectTag & DidCapture) !== NoEffect;

        if (!shouldUpdate && !didCaptureError) {
          if (hasContext) {
            invalidateContextProvider(workInProgress, Component, false);
          }

          return bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
        }

        var instance = workInProgress.stateNode;
        ReactCurrentOwner$3.current = workInProgress;
        var nextChildren = void 0;

        if (didCaptureError && typeof Component.getDerivedStateFromError !== "function") {
          nextChildren = null;

          if (enableProfilerTimer) {
            stopProfilerTimerIfRunning(workInProgress);
          }
        } else {
          {
            setCurrentPhase("render");
            nextChildren = instance.render();

            if (debugRenderPhaseSideEffects || debugRenderPhaseSideEffectsForStrictMode && workInProgress.mode & StrictMode) {
              instance.render();
            }

            setCurrentPhase(null);
          }
        }

        workInProgress.effectTag |= PerformedWork;

        if (current$$1 !== null && didCaptureError) {
          forceUnmountCurrentAndReconcile(current$$1, workInProgress, nextChildren, renderExpirationTime);
        } else {
          reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime);
        }

        workInProgress.memoizedState = instance.state;

        if (hasContext) {
          invalidateContextProvider(workInProgress, Component, true);
        }

        return workInProgress.child;
      }

      function pushHostRootContext(workInProgress) {
        var root = workInProgress.stateNode;

        if (root.pendingContext) {
          pushTopLevelContextObject(workInProgress, root.pendingContext, root.pendingContext !== root.context);
        } else if (root.context) {
          pushTopLevelContextObject(workInProgress, root.context, false);
        }

        pushHostContainer(workInProgress, root.containerInfo);
      }

      function updateHostRoot(current$$1, workInProgress, renderExpirationTime) {
        pushHostRootContext(workInProgress);
        var updateQueue = workInProgress.updateQueue;

        (function () {
          if (!(updateQueue !== null)) {
            throw ReactError(Error("If the root does not have an updateQueue, we should have already bailed out. This error is likely caused by a bug in React. Please file an issue."));
          }
        })();

        var nextProps = workInProgress.pendingProps;
        var prevState = workInProgress.memoizedState;
        var prevChildren = prevState !== null ? prevState.element : null;
        processUpdateQueue(workInProgress, updateQueue, nextProps, null, renderExpirationTime);
        var nextState = workInProgress.memoizedState;
        var nextChildren = nextState.element;

        if (nextChildren === prevChildren) {
          resetHydrationState();
          return bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
        }

        var root = workInProgress.stateNode;

        if ((current$$1 === null || current$$1.child === null) && root.hydrate && enterHydrationState(workInProgress)) {
          workInProgress.effectTag |= Placement;
          workInProgress.child = mountChildFibers(workInProgress, null, nextChildren, renderExpirationTime);
        } else {
          reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime);
          resetHydrationState();
        }

        return workInProgress.child;
      }

      function updateHostComponent(current$$1, workInProgress, renderExpirationTime) {
        pushHostContext(workInProgress);

        if (current$$1 === null) {
          tryToClaimNextHydratableInstance(workInProgress);
        }

        var type = workInProgress.type;
        var nextProps = workInProgress.pendingProps;
        var prevProps = current$$1 !== null ? current$$1.memoizedProps : null;
        var nextChildren = nextProps.children;
        var isDirectTextChild = shouldSetTextContent(type, nextProps);

        if (isDirectTextChild) {
          nextChildren = null;
        } else if (prevProps !== null && shouldSetTextContent(type, prevProps)) {
          workInProgress.effectTag |= ContentReset;
        }

        markRef(current$$1, workInProgress);

        if (workInProgress.mode & ConcurrentMode && renderExpirationTime !== Never && shouldDeprioritizeSubtree(type, nextProps)) {
          if (enableSchedulerTracing) {
            markSpawnedWork(Never);
          }

          workInProgress.expirationTime = workInProgress.childExpirationTime = Never;
          return null;
        }

        reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime);
        return workInProgress.child;
      }

      function updateHostText(current$$1, workInProgress) {
        if (current$$1 === null) {
          tryToClaimNextHydratableInstance(workInProgress);
        }

        return null;
      }

      function mountLazyComponent(_current, workInProgress, elementType, updateExpirationTime, renderExpirationTime) {
        if (_current !== null) {
          _current.alternate = null;
          workInProgress.alternate = null;
          workInProgress.effectTag |= Placement;
        }

        var props = workInProgress.pendingProps;
        cancelWorkTimer(workInProgress);
        var Component = readLazyComponentType(elementType);
        workInProgress.type = Component;
        var resolvedTag = workInProgress.tag = resolveLazyComponentTag(Component);
        startWorkTimer(workInProgress);
        var resolvedProps = resolveDefaultProps(Component, props);
        var child = void 0;

        switch (resolvedTag) {
          case FunctionComponent:
            {
              {
                validateFunctionComponentInDev(workInProgress, Component);
                workInProgress.type = Component = resolveFunctionForHotReloading(Component);
              }
              child = updateFunctionComponent(null, workInProgress, Component, resolvedProps, renderExpirationTime);
              break;
            }

          case ClassComponent:
            {
              {
                workInProgress.type = Component = resolveClassForHotReloading(Component);
              }
              child = updateClassComponent(null, workInProgress, Component, resolvedProps, renderExpirationTime);
              break;
            }

          case ForwardRef:
            {
              {
                workInProgress.type = Component = resolveForwardRefForHotReloading(Component);
              }
              child = updateForwardRef(null, workInProgress, Component, resolvedProps, renderExpirationTime);
              break;
            }

          case MemoComponent:
            {
              {
                if (workInProgress.type !== workInProgress.elementType) {
                  var outerPropTypes = Component.propTypes;

                  if (outerPropTypes) {
                    checkPropTypes(outerPropTypes, resolvedProps, "prop", getComponentName(Component), getCurrentFiberStackInDev);
                  }
                }
              }
              child = updateMemoComponent(null, workInProgress, Component, resolveDefaultProps(Component.type, resolvedProps), updateExpirationTime, renderExpirationTime);
              break;
            }

          default:
            {
              var hint = "";
              {
                if (Component !== null && typeof Component === "object" && Component.$$typeof === REACT_LAZY_TYPE) {
                  hint = " Did you wrap a component in React.lazy() more than once?";
                }
              }

              (function () {
                {
                  throw ReactError(Error("Element type is invalid. Received a promise that resolves to: " + Component + ". Lazy element type must resolve to a class or function." + hint));
                }
              })();
            }
        }

        return child;
      }

      function mountIncompleteClassComponent(_current, workInProgress, Component, nextProps, renderExpirationTime) {
        if (_current !== null) {
          _current.alternate = null;
          workInProgress.alternate = null;
          workInProgress.effectTag |= Placement;
        }

        workInProgress.tag = ClassComponent;
        var hasContext = void 0;

        if (isContextProvider(Component)) {
          hasContext = true;
          pushContextProvider(workInProgress);
        } else {
          hasContext = false;
        }

        prepareToReadContext(workInProgress, renderExpirationTime);
        constructClassInstance(workInProgress, Component, nextProps, renderExpirationTime);
        mountClassInstance(workInProgress, Component, nextProps, renderExpirationTime);
        return finishClassComponent(null, workInProgress, Component, true, hasContext, renderExpirationTime);
      }

      function mountIndeterminateComponent(_current, workInProgress, Component, renderExpirationTime) {
        if (_current !== null) {
          _current.alternate = null;
          workInProgress.alternate = null;
          workInProgress.effectTag |= Placement;
        }

        var props = workInProgress.pendingProps;
        var context = void 0;

        if (!disableLegacyContext) {
          var unmaskedContext = getUnmaskedContext(workInProgress, Component, false);
          context = getMaskedContext(workInProgress, unmaskedContext);
        }

        prepareToReadContext(workInProgress, renderExpirationTime);
        var value = void 0;
        {
          if (Component.prototype && typeof Component.prototype.render === "function") {
            var componentName = getComponentName(Component) || "Unknown";

            if (!didWarnAboutBadClass[componentName]) {
              warningWithoutStack$1(false, "The <%s /> component appears to have a render method, but doesn't extend React.Component. " + "This is likely to cause errors. Change %s to extend React.Component instead.", componentName, componentName);
              didWarnAboutBadClass[componentName] = true;
            }
          }

          if (workInProgress.mode & StrictMode) {
            ReactStrictModeWarnings.recordLegacyContextWarning(workInProgress, null);
          }

          ReactCurrentOwner$3.current = workInProgress;
          value = renderWithHooks(null, workInProgress, Component, props, context, renderExpirationTime);
        }
        workInProgress.effectTag |= PerformedWork;

        if (typeof value === "object" && value !== null && typeof value.render === "function" && value.$$typeof === undefined) {
          {
            var _componentName = getComponentName(Component) || "Unknown";

            if (!didWarnAboutModulePatternComponent[_componentName]) {
              warningWithoutStack$1(false, "The <%s /> component appears to be a function component that returns a class instance. " + "Change %s to a class that extends React.Component instead. " + "If you can't use a class try assigning the prototype on the function as a workaround. " + "`%s.prototype = React.Component.prototype`. Don't use an arrow function since it " + "cannot be called with `new` by React.", _componentName, _componentName, _componentName);
              didWarnAboutModulePatternComponent[_componentName] = true;
            }
          }
          workInProgress.tag = ClassComponent;
          resetHooks();
          var hasContext = false;

          if (isContextProvider(Component)) {
            hasContext = true;
            pushContextProvider(workInProgress);
          } else {
            hasContext = false;
          }

          workInProgress.memoizedState = value.state !== null && value.state !== undefined ? value.state : null;
          var getDerivedStateFromProps = Component.getDerivedStateFromProps;

          if (typeof getDerivedStateFromProps === "function") {
            applyDerivedStateFromProps(workInProgress, Component, getDerivedStateFromProps, props);
          }

          adoptClassInstance(workInProgress, value);
          mountClassInstance(workInProgress, Component, props, renderExpirationTime);
          return finishClassComponent(null, workInProgress, Component, true, hasContext, renderExpirationTime);
        } else {
          workInProgress.tag = FunctionComponent;
          {
            if (disableLegacyContext && Component.contextTypes) {
              warningWithoutStack$1(false, "%s uses the legacy contextTypes API which is no longer supported. " + "Use React.createContext() with React.useContext() instead.", getComponentName(Component) || "Unknown");
            }

            if (debugRenderPhaseSideEffects || debugRenderPhaseSideEffectsForStrictMode && workInProgress.mode & StrictMode) {
              if (workInProgress.memoizedState !== null) {
                value = renderWithHooks(null, workInProgress, Component, props, context, renderExpirationTime);
              }
            }
          }
          reconcileChildren(null, workInProgress, value, renderExpirationTime);
          {
            validateFunctionComponentInDev(workInProgress, Component);
          }
          return workInProgress.child;
        }
      }

      function validateFunctionComponentInDev(workInProgress, Component) {
        if (Component) {
          !!Component.childContextTypes ? warningWithoutStack$1(false, "%s(...): childContextTypes cannot be defined on a function component.", Component.displayName || Component.name || "Component") : void 0;
        }

        if (workInProgress.ref !== null) {
          var info = "";
          var ownerName = getCurrentFiberOwnerNameInDevOrNull();

          if (ownerName) {
            info += "\n\nCheck the render method of `" + ownerName + "`.";
          }

          var warningKey = ownerName || workInProgress._debugID || "";
          var debugSource = workInProgress._debugSource;

          if (debugSource) {
            warningKey = debugSource.fileName + ":" + debugSource.lineNumber;
          }

          if (!didWarnAboutFunctionRefs[warningKey]) {
            didWarnAboutFunctionRefs[warningKey] = true;
            warning$1(false, "Function components cannot be given refs. " + "Attempts to access this ref will fail. " + "Did you mean to use React.forwardRef()?%s", info);
          }
        }

        if (warnAboutDefaultPropsOnFunctionComponents && Component.defaultProps !== undefined) {
          var componentName = getComponentName(Component) || "Unknown";

          if (!didWarnAboutDefaultPropsOnFunctionComponent[componentName]) {
            warningWithoutStack$1(false, "%s: Support for defaultProps will be removed from function components " + "in a future major release. Use JavaScript default parameters instead.", componentName);
            didWarnAboutDefaultPropsOnFunctionComponent[componentName] = true;
          }
        }

        if (typeof Component.getDerivedStateFromProps === "function") {
          var _componentName2 = getComponentName(Component) || "Unknown";

          if (!didWarnAboutGetDerivedStateOnFunctionComponent[_componentName2]) {
            warningWithoutStack$1(false, "%s: Function components do not support getDerivedStateFromProps.", _componentName2);
            didWarnAboutGetDerivedStateOnFunctionComponent[_componentName2] = true;
          }
        }

        if (typeof Component.contextType === "object" && Component.contextType !== null) {
          var _componentName3 = getComponentName(Component) || "Unknown";

          if (!didWarnAboutContextTypeOnFunctionComponent[_componentName3]) {
            warningWithoutStack$1(false, "%s: Function components do not support contextType.", _componentName3);
            didWarnAboutContextTypeOnFunctionComponent[_componentName3] = true;
          }
        }
      }

      var SUSPENDED_MARKER = {};

      function shouldRemainOnFallback(suspenseContext, current$$1, workInProgress) {
        return hasSuspenseContext(suspenseContext, ForceSuspenseFallback) && (current$$1 === null || current$$1.memoizedState !== null);
      }

      function updateSuspenseComponent(current$$1, workInProgress, renderExpirationTime) {
        var mode = workInProgress.mode;
        var nextProps = workInProgress.pendingProps;
        {
          if (shouldSuspend(workInProgress)) {
            workInProgress.effectTag |= DidCapture;
          }
        }
        var suspenseContext = suspenseStackCursor.current;
        var nextState = null;
        var nextDidTimeout = false;

        if ((workInProgress.effectTag & DidCapture) !== NoEffect || shouldRemainOnFallback(suspenseContext, current$$1, workInProgress)) {
          nextState = SUSPENDED_MARKER;
          nextDidTimeout = true;
          workInProgress.effectTag &= ~DidCapture;
        } else {
          if (current$$1 === null || current$$1.memoizedState !== null) {
            if (nextProps.fallback !== undefined && nextProps.unstable_avoidThisFallback !== true) {
              suspenseContext = addSubtreeSuspenseContext(suspenseContext, InvisibleParentSuspenseContext);
            }
          }
        }

        suspenseContext = setDefaultShallowSuspenseContext(suspenseContext);
        pushSuspenseContext(workInProgress, suspenseContext);
        {
          if ("maxDuration" in nextProps) {
            if (!didWarnAboutMaxDuration) {
              didWarnAboutMaxDuration = true;
              warning$1(false, "maxDuration has been removed from React. " + "Remove the maxDuration prop.");
            }
          }
        }
        var child = void 0;
        var next = void 0;

        if (current$$1 === null) {
          if (enableSuspenseServerRenderer) {
            if (nextProps.fallback !== undefined) {
              tryToClaimNextHydratableInstance(workInProgress);

              if (workInProgress.tag === DehydratedSuspenseComponent) {
                popSuspenseContext(workInProgress);
                return updateDehydratedSuspenseComponent(null, workInProgress, renderExpirationTime);
              }
            }
          }

          if (nextDidTimeout) {
            var nextFallbackChildren = nextProps.fallback;
            var primaryChildFragment = createFiberFromFragment(null, mode, NoWork, null);
            primaryChildFragment.return = workInProgress;

            if ((workInProgress.mode & BatchedMode) === NoMode) {
              var progressedState = workInProgress.memoizedState;
              var progressedPrimaryChild = progressedState !== null ? workInProgress.child.child : workInProgress.child;
              primaryChildFragment.child = progressedPrimaryChild;
              var progressedChild = progressedPrimaryChild;

              while (progressedChild !== null) {
                progressedChild.return = primaryChildFragment;
                progressedChild = progressedChild.sibling;
              }
            }

            var fallbackChildFragment = createFiberFromFragment(nextFallbackChildren, mode, renderExpirationTime, null);
            fallbackChildFragment.return = workInProgress;
            primaryChildFragment.sibling = fallbackChildFragment;
            child = primaryChildFragment;
            next = fallbackChildFragment;
          } else {
            var nextPrimaryChildren = nextProps.children;
            child = next = mountChildFibers(workInProgress, null, nextPrimaryChildren, renderExpirationTime);
          }
        } else {
          var prevState = current$$1.memoizedState;
          var prevDidTimeout = prevState !== null;

          if (prevDidTimeout) {
            var currentPrimaryChildFragment = current$$1.child;
            var currentFallbackChildFragment = currentPrimaryChildFragment.sibling;

            if (nextDidTimeout) {
              var _nextFallbackChildren = nextProps.fallback;

              var _primaryChildFragment = createWorkInProgress(currentPrimaryChildFragment, currentPrimaryChildFragment.pendingProps, NoWork);

              _primaryChildFragment.return = workInProgress;

              if ((workInProgress.mode & BatchedMode) === NoMode) {
                var _progressedState = workInProgress.memoizedState;

                var _progressedPrimaryChild = _progressedState !== null ? workInProgress.child.child : workInProgress.child;

                if (_progressedPrimaryChild !== currentPrimaryChildFragment.child) {
                  _primaryChildFragment.child = _progressedPrimaryChild;
                  var _progressedChild = _progressedPrimaryChild;

                  while (_progressedChild !== null) {
                    _progressedChild.return = _primaryChildFragment;
                    _progressedChild = _progressedChild.sibling;
                  }
                }
              }

              if (enableProfilerTimer && workInProgress.mode & ProfileMode) {
                var treeBaseDuration = 0;
                var hiddenChild = _primaryChildFragment.child;

                while (hiddenChild !== null) {
                  treeBaseDuration += hiddenChild.treeBaseDuration;
                  hiddenChild = hiddenChild.sibling;
                }

                _primaryChildFragment.treeBaseDuration = treeBaseDuration;
              }

              var _fallbackChildFragment = createWorkInProgress(currentFallbackChildFragment, _nextFallbackChildren, currentFallbackChildFragment.expirationTime);

              _fallbackChildFragment.return = workInProgress;
              _primaryChildFragment.sibling = _fallbackChildFragment;
              child = _primaryChildFragment;
              _primaryChildFragment.childExpirationTime = NoWork;
              next = _fallbackChildFragment;
            } else {
              var _nextPrimaryChildren = nextProps.children;
              var currentPrimaryChild = currentPrimaryChildFragment.child;
              var primaryChild = reconcileChildFibers(workInProgress, currentPrimaryChild, _nextPrimaryChildren, renderExpirationTime);
              child = next = primaryChild;
            }
          } else {
            var _currentPrimaryChild = current$$1.child;

            if (nextDidTimeout) {
              var _nextFallbackChildren2 = nextProps.fallback;

              var _primaryChildFragment2 = createFiberFromFragment(null, mode, NoWork, null);

              _primaryChildFragment2.return = workInProgress;
              _primaryChildFragment2.child = _currentPrimaryChild;

              if (_currentPrimaryChild !== null) {
                _currentPrimaryChild.return = _primaryChildFragment2;
              }

              if ((workInProgress.mode & BatchedMode) === NoMode) {
                var _progressedState2 = workInProgress.memoizedState;

                var _progressedPrimaryChild2 = _progressedState2 !== null ? workInProgress.child.child : workInProgress.child;

                _primaryChildFragment2.child = _progressedPrimaryChild2;
                var _progressedChild2 = _progressedPrimaryChild2;

                while (_progressedChild2 !== null) {
                  _progressedChild2.return = _primaryChildFragment2;
                  _progressedChild2 = _progressedChild2.sibling;
                }
              }

              if (enableProfilerTimer && workInProgress.mode & ProfileMode) {
                var _treeBaseDuration = 0;
                var _hiddenChild = _primaryChildFragment2.child;

                while (_hiddenChild !== null) {
                  _treeBaseDuration += _hiddenChild.treeBaseDuration;
                  _hiddenChild = _hiddenChild.sibling;
                }

                _primaryChildFragment2.treeBaseDuration = _treeBaseDuration;
              }

              var _fallbackChildFragment2 = createFiberFromFragment(_nextFallbackChildren2, mode, renderExpirationTime, null);

              _fallbackChildFragment2.return = workInProgress;
              _primaryChildFragment2.sibling = _fallbackChildFragment2;
              _fallbackChildFragment2.effectTag |= Placement;
              child = _primaryChildFragment2;
              _primaryChildFragment2.childExpirationTime = NoWork;
              next = _fallbackChildFragment2;
            } else {
              var _nextPrimaryChildren2 = nextProps.children;
              next = child = reconcileChildFibers(workInProgress, _currentPrimaryChild, _nextPrimaryChildren2, renderExpirationTime);
            }
          }

          workInProgress.stateNode = current$$1.stateNode;
        }

        workInProgress.memoizedState = nextState;
        workInProgress.child = child;
        return next;
      }

      function retrySuspenseComponentWithoutHydrating(current$$1, workInProgress, renderExpirationTime) {
        current$$1.alternate = null;
        workInProgress.alternate = null;
        var returnFiber = workInProgress.return;

        (function () {
          if (!(returnFiber !== null)) {
            throw ReactError(Error("Suspense boundaries are never on the root. This is probably a bug in React."));
          }
        })();

        var last = returnFiber.lastEffect;

        if (last !== null) {
          last.nextEffect = current$$1;
          returnFiber.lastEffect = current$$1;
        } else {
          returnFiber.firstEffect = returnFiber.lastEffect = current$$1;
        }

        current$$1.nextEffect = null;
        current$$1.effectTag = Deletion;
        popSuspenseContext(workInProgress);
        workInProgress.tag = SuspenseComponent;
        workInProgress.stateNode = null;
        workInProgress.memoizedState = null;
        workInProgress.effectTag |= Placement;
        return updateSuspenseComponent(null, workInProgress, renderExpirationTime);
      }

      function updateDehydratedSuspenseComponent(current$$1, workInProgress, renderExpirationTime) {
        pushSuspenseContext(workInProgress, setDefaultShallowSuspenseContext(suspenseStackCursor.current));
        var suspenseInstance = workInProgress.stateNode;

        if (current$$1 === null) {
          if (isSuspenseInstanceFallback(suspenseInstance)) {
            var serverDisplayTime = requestCurrentTime();
            workInProgress.expirationTime = computeAsyncExpiration(serverDisplayTime);
          } else {
            workInProgress.expirationTime = Never;
          }

          return null;
        }

        if ((workInProgress.effectTag & DidCapture) !== NoEffect) {
          workInProgress.child = null;
          return null;
        }

        warnIfHydrating();

        if (isSuspenseInstanceFallback(suspenseInstance)) {
          return retrySuspenseComponentWithoutHydrating(current$$1, workInProgress, renderExpirationTime);
        }

        var hasContextChanged$$1 = current$$1.childExpirationTime >= renderExpirationTime;

        if (didReceiveUpdate || hasContextChanged$$1) {
          return retrySuspenseComponentWithoutHydrating(current$$1, workInProgress, renderExpirationTime);
        } else if (isSuspenseInstancePending(suspenseInstance)) {
          workInProgress.effectTag |= DidCapture;
          workInProgress.child = null;
          registerSuspenseInstanceRetry(suspenseInstance, retryTimedOutBoundary.bind(null, current$$1));
          return null;
        } else {
          reenterHydrationStateFromDehydratedSuspenseInstance(workInProgress);
          var nextProps = workInProgress.pendingProps;
          var nextChildren = nextProps.children;
          workInProgress.child = mountChildFibers(workInProgress, null, nextChildren, renderExpirationTime);
          return workInProgress.child;
        }
      }

      function propagateSuspenseContextChange(workInProgress, firstChild, renderExpirationTime) {
        var node = firstChild;

        while (node !== null) {
          if (node.tag === SuspenseComponent) {
            var state = node.memoizedState;

            if (state !== null) {
              if (node.expirationTime < renderExpirationTime) {
                node.expirationTime = renderExpirationTime;
              }

              var alternate = node.alternate;

              if (alternate !== null && alternate.expirationTime < renderExpirationTime) {
                alternate.expirationTime = renderExpirationTime;
              }

              scheduleWorkOnParentPath(node.return, renderExpirationTime);
            }
          } else if (node.child !== null) {
            node.child.return = node;
            node = node.child;
            continue;
          }

          if (node === workInProgress) {
            return;
          }

          while (node.sibling === null) {
            if (node.return === null || node.return === workInProgress) {
              return;
            }

            node = node.return;
          }

          node.sibling.return = node.return;
          node = node.sibling;
        }
      }

      function findLastContentRow(firstChild) {
        var row = firstChild;
        var lastContentRow = null;

        while (row !== null) {
          var currentRow = row.alternate;

          if (currentRow !== null && findFirstSuspended(currentRow) === null) {
            lastContentRow = row;
          }

          row = row.sibling;
        }

        return lastContentRow;
      }

      function validateRevealOrder(revealOrder) {
        {
          if (revealOrder !== undefined && revealOrder !== "forwards" && revealOrder !== "backwards" && revealOrder !== "together" && !didWarnAboutRevealOrder[revealOrder]) {
            didWarnAboutRevealOrder[revealOrder] = true;

            if (typeof revealOrder === "string") {
              switch (revealOrder.toLowerCase()) {
                case "together":
                case "forwards":
                case "backwards":
                  {
                    warning$1(false, '"%s" is not a valid value for revealOrder on <SuspenseList />. ' + 'Use lowercase "%s" instead.', revealOrder, revealOrder.toLowerCase());
                    break;
                  }

                case "forward":
                case "backward":
                  {
                    warning$1(false, '"%s" is not a valid value for revealOrder on <SuspenseList />. ' + 'React uses the -s suffix in the spelling. Use "%ss" instead.', revealOrder, revealOrder.toLowerCase());
                    break;
                  }

                default:
                  warning$1(false, '"%s" is not a supported revealOrder on <SuspenseList />. ' + 'Did you mean "together", "forwards" or "backwards"?', revealOrder);
                  break;
              }
            } else {
              warning$1(false, "%s is not a supported value for revealOrder on <SuspenseList />. " + 'Did you mean "together", "forwards" or "backwards"?', revealOrder);
            }
          }
        }
      }

      function validateTailOptions(tailMode, revealOrder) {
        {
          if (tailMode !== undefined && !didWarnAboutTailOptions[tailMode]) {
            if (tailMode !== "collapsed" && tailMode !== "hidden") {
              didWarnAboutTailOptions[tailMode] = true;
              warning$1(false, '"%s" is not a supported value for tail on <SuspenseList />. ' + 'Did you mean "collapsed" or "hidden"?', tailMode);
            } else if (revealOrder !== "forwards" && revealOrder !== "backwards") {
              didWarnAboutTailOptions[tailMode] = true;
              warning$1(false, '<SuspenseList tail="%s" /> is only valid if revealOrder is ' + '"forwards" or "backwards". ' + 'Did you mean to specify revealOrder="forwards"?', tailMode);
            }
          }
        }
      }

      function validateSuspenseListNestedChild(childSlot, index) {
        {
          var isArray = Array.isArray(childSlot);
          var isIterable = !isArray && typeof getIteratorFn(childSlot) === "function";

          if (isArray || isIterable) {
            var type = isArray ? "array" : "iterable";
            warning$1(false, "A nested %s was passed to row #%s in <SuspenseList />. Wrap it in " + "an additional SuspenseList to configure its revealOrder: " + "<SuspenseList revealOrder=...> ... " + "<SuspenseList revealOrder=...>{%s}</SuspenseList> ... " + "</SuspenseList>", type, index, type);
            return false;
          }
        }
        return true;
      }

      function validateSuspenseListChildren(children, revealOrder) {
        {
          if ((revealOrder === "forwards" || revealOrder === "backwards") && children !== undefined && children !== null && children !== false) {
            if (Array.isArray(children)) {
              for (var i = 0; i < children.length; i++) {
                if (!validateSuspenseListNestedChild(children[i], i)) {
                  return;
                }
              }
            } else {
              var iteratorFn = getIteratorFn(children);

              if (typeof iteratorFn === "function") {
                var childrenIterator = iteratorFn.call(children);

                if (childrenIterator) {
                  var step = childrenIterator.next();
                  var _i = 0;

                  for (; !step.done; step = childrenIterator.next()) {
                    if (!validateSuspenseListNestedChild(step.value, _i)) {
                      return;
                    }

                    _i++;
                  }
                }
              } else {
                warning$1(false, 'A single row was passed to a <SuspenseList revealOrder="%s" />. ' + "This is not useful since it needs multiple rows. " + "Did you mean to pass multiple children or an array?", revealOrder);
              }
            }
          }
        }
      }

      function initSuspenseListRenderState(workInProgress, isBackwards, tail, lastContentRow, tailMode) {
        var renderState = workInProgress.memoizedState;

        if (renderState === null) {
          workInProgress.memoizedState = {
            isBackwards: isBackwards,
            rendering: null,
            last: lastContentRow,
            tail: tail,
            tailExpiration: 0,
            tailMode: tailMode
          };
        } else {
          renderState.isBackwards = isBackwards;
          renderState.rendering = null;
          renderState.last = lastContentRow;
          renderState.tail = tail;
          renderState.tailExpiration = 0;
          renderState.tailMode = tailMode;
        }
      }

      function updateSuspenseListComponent(current$$1, workInProgress, renderExpirationTime) {
        var nextProps = workInProgress.pendingProps;
        var revealOrder = nextProps.revealOrder;
        var tailMode = nextProps.tail;
        var newChildren = nextProps.children;
        validateRevealOrder(revealOrder);
        validateTailOptions(tailMode, revealOrder);
        validateSuspenseListChildren(newChildren, revealOrder);
        reconcileChildren(current$$1, workInProgress, newChildren, renderExpirationTime);
        var suspenseContext = suspenseStackCursor.current;
        var shouldForceFallback = hasSuspenseContext(suspenseContext, ForceSuspenseFallback);

        if (shouldForceFallback) {
          suspenseContext = setShallowSuspenseContext(suspenseContext, ForceSuspenseFallback);
          workInProgress.effectTag |= DidCapture;
        } else {
          var didSuspendBefore = current$$1 !== null && (current$$1.effectTag & DidCapture) !== NoEffect;

          if (didSuspendBefore) {
            propagateSuspenseContextChange(workInProgress, workInProgress.child, renderExpirationTime);
          }

          suspenseContext = setDefaultShallowSuspenseContext(suspenseContext);
        }

        pushSuspenseContext(workInProgress, suspenseContext);

        if ((workInProgress.mode & BatchedMode) === NoMode) {
          workInProgress.memoizedState = null;
        } else {
          switch (revealOrder) {
            case "forwards":
              {
                var lastContentRow = findLastContentRow(workInProgress.child);
                var tail = void 0;

                if (lastContentRow === null) {
                  tail = workInProgress.child;
                  workInProgress.child = null;
                } else {
                  tail = lastContentRow.sibling;
                  lastContentRow.sibling = null;
                }

                initSuspenseListRenderState(workInProgress, false, tail, lastContentRow, tailMode);
                break;
              }

            case "backwards":
              {
                var _tail = null;
                var row = workInProgress.child;
                workInProgress.child = null;

                while (row !== null) {
                  var currentRow = row.alternate;

                  if (currentRow !== null && findFirstSuspended(currentRow) === null) {
                    workInProgress.child = row;
                    break;
                  }

                  var nextRow = row.sibling;
                  row.sibling = _tail;
                  _tail = row;
                  row = nextRow;
                }

                initSuspenseListRenderState(workInProgress, true, _tail, null, tailMode);
                break;
              }

            case "together":
              {
                initSuspenseListRenderState(workInProgress, false, null, null, undefined);
                break;
              }

            default:
              {
                workInProgress.memoizedState = null;
              }
          }
        }

        return workInProgress.child;
      }

      function updatePortalComponent(current$$1, workInProgress, renderExpirationTime) {
        pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
        var nextChildren = workInProgress.pendingProps;

        if (current$$1 === null) {
          workInProgress.child = reconcileChildFibers(workInProgress, null, nextChildren, renderExpirationTime);
        } else {
          reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime);
        }

        return workInProgress.child;
      }

      function updateContextProvider(current$$1, workInProgress, renderExpirationTime) {
        var providerType = workInProgress.type;
        var context = providerType._context;
        var newProps = workInProgress.pendingProps;
        var oldProps = workInProgress.memoizedProps;
        var newValue = newProps.value;
        {
          var providerPropTypes = workInProgress.type.propTypes;

          if (providerPropTypes) {
            checkPropTypes(providerPropTypes, newProps, "prop", "Context.Provider", getCurrentFiberStackInDev);
          }
        }
        pushProvider(workInProgress, newValue);

        if (oldProps !== null) {
          var oldValue = oldProps.value;
          var changedBits = calculateChangedBits(context, newValue, oldValue);

          if (changedBits === 0) {
            if (oldProps.children === newProps.children && !hasContextChanged()) {
              return bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
            }
          } else {
            propagateContextChange(workInProgress, context, changedBits, renderExpirationTime);
          }
        }

        var newChildren = newProps.children;
        reconcileChildren(current$$1, workInProgress, newChildren, renderExpirationTime);
        return workInProgress.child;
      }

      var hasWarnedAboutUsingContextAsConsumer = false;

      function updateContextConsumer(current$$1, workInProgress, renderExpirationTime) {
        var context = workInProgress.type;
        {
          if (context._context === undefined) {
            if (context !== context.Consumer) {
              if (!hasWarnedAboutUsingContextAsConsumer) {
                hasWarnedAboutUsingContextAsConsumer = true;
                warning$1(false, "Rendering <Context> directly is not supported and will be removed in " + "a future major release. Did you mean to render <Context.Consumer> instead?");
              }
            }
          } else {
            context = context._context;
          }
        }
        var newProps = workInProgress.pendingProps;
        var render = newProps.children;
        {
          !(typeof render === "function") ? warningWithoutStack$1(false, "A context consumer was rendered with multiple children, or a child " + "that isn't a function. A context consumer expects a single child " + "that is a function. If you did pass a function, make sure there " + "is no trailing or leading whitespace around it.") : void 0;
        }
        prepareToReadContext(workInProgress, renderExpirationTime);

        var newValue = _readContext(context, newProps.unstable_observedBits);

        var newChildren = void 0;
        {
          ReactCurrentOwner$3.current = workInProgress;
          setCurrentPhase("render");
          newChildren = render(newValue);
          setCurrentPhase(null);
        }
        workInProgress.effectTag |= PerformedWork;
        reconcileChildren(current$$1, workInProgress, newChildren, renderExpirationTime);
        return workInProgress.child;
      }

      function updateFundamentalComponent$1(current$$1, workInProgress, renderExpirationTime) {
        var fundamentalImpl = workInProgress.type.impl;

        if (fundamentalImpl.reconcileChildren === false) {
          return null;
        }

        var nextProps = workInProgress.pendingProps;
        var nextChildren = nextProps.children;
        reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime);
        return workInProgress.child;
      }

      function markWorkInProgressReceivedUpdate() {
        didReceiveUpdate = true;
      }

      function bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime) {
        cancelWorkTimer(workInProgress);

        if (current$$1 !== null) {
          workInProgress.dependencies = current$$1.dependencies;
        }

        if (enableProfilerTimer) {
          stopProfilerTimerIfRunning(workInProgress);
        }

        var childExpirationTime = workInProgress.childExpirationTime;

        if (childExpirationTime < renderExpirationTime) {
          return null;
        } else {
          cloneChildFibers(current$$1, workInProgress);
          return workInProgress.child;
        }
      }

      function remountFiber(current$$1, oldWorkInProgress, newWorkInProgress) {
        {
          var returnFiber = oldWorkInProgress.return;

          if (returnFiber === null) {
            throw new Error("Cannot swap the root fiber.");
          }

          current$$1.alternate = null;
          oldWorkInProgress.alternate = null;
          newWorkInProgress.index = oldWorkInProgress.index;
          newWorkInProgress.sibling = oldWorkInProgress.sibling;
          newWorkInProgress.return = oldWorkInProgress.return;
          newWorkInProgress.ref = oldWorkInProgress.ref;

          if (oldWorkInProgress === returnFiber.child) {
            returnFiber.child = newWorkInProgress;
          } else {
            var prevSibling = returnFiber.child;

            if (prevSibling === null) {
              throw new Error("Expected parent to have a child.");
            }

            while (prevSibling.sibling !== oldWorkInProgress) {
              prevSibling = prevSibling.sibling;

              if (prevSibling === null) {
                throw new Error("Expected to find the previous sibling.");
              }
            }

            prevSibling.sibling = newWorkInProgress;
          }

          var last = returnFiber.lastEffect;

          if (last !== null) {
            last.nextEffect = current$$1;
            returnFiber.lastEffect = current$$1;
          } else {
            returnFiber.firstEffect = returnFiber.lastEffect = current$$1;
          }

          current$$1.nextEffect = null;
          current$$1.effectTag = Deletion;
          newWorkInProgress.effectTag |= Placement;
          return newWorkInProgress;
        }
      }

      function beginWork$1(current$$1, workInProgress, renderExpirationTime) {
        var updateExpirationTime = workInProgress.expirationTime;
        {
          if (workInProgress._debugNeedsRemount && current$$1 !== null) {
            return remountFiber(current$$1, workInProgress, createFiberFromTypeAndProps(workInProgress.type, workInProgress.key, workInProgress.pendingProps, workInProgress._debugOwner || null, workInProgress.mode, workInProgress.expirationTime));
          }
        }

        if (current$$1 !== null) {
          var oldProps = current$$1.memoizedProps;
          var newProps = workInProgress.pendingProps;

          if (oldProps !== newProps || hasContextChanged() || workInProgress.type !== current$$1.type) {
            didReceiveUpdate = true;
          } else if (updateExpirationTime < renderExpirationTime) {
            didReceiveUpdate = false;

            switch (workInProgress.tag) {
              case HostRoot:
                pushHostRootContext(workInProgress);
                resetHydrationState();
                break;

              case HostComponent:
                pushHostContext(workInProgress);

                if (workInProgress.mode & ConcurrentMode && renderExpirationTime !== Never && shouldDeprioritizeSubtree(workInProgress.type, newProps)) {
                  if (enableSchedulerTracing) {
                    markSpawnedWork(Never);
                  }

                  workInProgress.expirationTime = workInProgress.childExpirationTime = Never;
                  return null;
                }

                break;

              case ClassComponent:
                {
                  var Component = workInProgress.type;

                  if (isContextProvider(Component)) {
                    pushContextProvider(workInProgress);
                  }

                  break;
                }

              case HostPortal:
                pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
                break;

              case ContextProvider:
                {
                  var newValue = workInProgress.memoizedProps.value;
                  pushProvider(workInProgress, newValue);
                  break;
                }

              case Profiler:
                if (enableProfilerTimer) {
                  workInProgress.effectTag |= Update;
                }

                break;

              case SuspenseComponent:
                {
                  var state = workInProgress.memoizedState;
                  var didTimeout = state !== null;

                  if (didTimeout) {
                    var primaryChildFragment = workInProgress.child;
                    var primaryChildExpirationTime = primaryChildFragment.childExpirationTime;

                    if (primaryChildExpirationTime !== NoWork && primaryChildExpirationTime >= renderExpirationTime) {
                      return updateSuspenseComponent(current$$1, workInProgress, renderExpirationTime);
                    } else {
                      pushSuspenseContext(workInProgress, setDefaultShallowSuspenseContext(suspenseStackCursor.current));
                      var child = bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);

                      if (child !== null) {
                        return child.sibling;
                      } else {
                        return null;
                      }
                    }
                  } else {
                    pushSuspenseContext(workInProgress, setDefaultShallowSuspenseContext(suspenseStackCursor.current));
                  }

                  break;
                }

              case DehydratedSuspenseComponent:
                {
                  if (enableSuspenseServerRenderer) {
                    pushSuspenseContext(workInProgress, setDefaultShallowSuspenseContext(suspenseStackCursor.current));
                    workInProgress.effectTag |= DidCapture;
                  }

                  break;
                }

              case SuspenseListComponent:
                {
                  var didSuspendBefore = (current$$1.effectTag & DidCapture) !== NoEffect;
                  var hasChildWork = workInProgress.childExpirationTime >= renderExpirationTime;

                  if (didSuspendBefore) {
                    if (hasChildWork) {
                      return updateSuspenseListComponent(current$$1, workInProgress, renderExpirationTime);
                    }

                    workInProgress.effectTag |= DidCapture;
                  }

                  var renderState = workInProgress.memoizedState;

                  if (renderState !== null) {
                    renderState.rendering = null;
                    renderState.tail = null;
                  }

                  pushSuspenseContext(workInProgress, suspenseStackCursor.current);

                  if (hasChildWork) {
                    break;
                  } else {
                    return null;
                  }
                }
            }

            return bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
          }
        } else {
          didReceiveUpdate = false;
        }

        workInProgress.expirationTime = NoWork;

        switch (workInProgress.tag) {
          case IndeterminateComponent:
            {
              return mountIndeterminateComponent(current$$1, workInProgress, workInProgress.type, renderExpirationTime);
            }

          case LazyComponent:
            {
              var elementType = workInProgress.elementType;
              return mountLazyComponent(current$$1, workInProgress, elementType, updateExpirationTime, renderExpirationTime);
            }

          case FunctionComponent:
            {
              var _Component = workInProgress.type;
              var unresolvedProps = workInProgress.pendingProps;
              var resolvedProps = workInProgress.elementType === _Component ? unresolvedProps : resolveDefaultProps(_Component, unresolvedProps);
              return updateFunctionComponent(current$$1, workInProgress, _Component, resolvedProps, renderExpirationTime);
            }

          case ClassComponent:
            {
              var _Component2 = workInProgress.type;
              var _unresolvedProps = workInProgress.pendingProps;

              var _resolvedProps = workInProgress.elementType === _Component2 ? _unresolvedProps : resolveDefaultProps(_Component2, _unresolvedProps);

              return updateClassComponent(current$$1, workInProgress, _Component2, _resolvedProps, renderExpirationTime);
            }

          case HostRoot:
            return updateHostRoot(current$$1, workInProgress, renderExpirationTime);

          case HostComponent:
            return updateHostComponent(current$$1, workInProgress, renderExpirationTime);

          case HostText:
            return updateHostText(current$$1, workInProgress);

          case SuspenseComponent:
            return updateSuspenseComponent(current$$1, workInProgress, renderExpirationTime);

          case HostPortal:
            return updatePortalComponent(current$$1, workInProgress, renderExpirationTime);

          case ForwardRef:
            {
              var type = workInProgress.type;
              var _unresolvedProps2 = workInProgress.pendingProps;

              var _resolvedProps2 = workInProgress.elementType === type ? _unresolvedProps2 : resolveDefaultProps(type, _unresolvedProps2);

              return updateForwardRef(current$$1, workInProgress, type, _resolvedProps2, renderExpirationTime);
            }

          case Fragment:
            return updateFragment(current$$1, workInProgress, renderExpirationTime);

          case Mode:
            return updateMode(current$$1, workInProgress, renderExpirationTime);

          case Profiler:
            return updateProfiler(current$$1, workInProgress, renderExpirationTime);

          case ContextProvider:
            return updateContextProvider(current$$1, workInProgress, renderExpirationTime);

          case ContextConsumer:
            return updateContextConsumer(current$$1, workInProgress, renderExpirationTime);

          case MemoComponent:
            {
              var _type2 = workInProgress.type;
              var _unresolvedProps3 = workInProgress.pendingProps;

              var _resolvedProps3 = resolveDefaultProps(_type2, _unresolvedProps3);

              {
                if (workInProgress.type !== workInProgress.elementType) {
                  var outerPropTypes = _type2.propTypes;

                  if (outerPropTypes) {
                    checkPropTypes(outerPropTypes, _resolvedProps3, "prop", getComponentName(_type2), getCurrentFiberStackInDev);
                  }
                }
              }
              _resolvedProps3 = resolveDefaultProps(_type2.type, _resolvedProps3);
              return updateMemoComponent(current$$1, workInProgress, _type2, _resolvedProps3, updateExpirationTime, renderExpirationTime);
            }

          case SimpleMemoComponent:
            {
              return updateSimpleMemoComponent(current$$1, workInProgress, workInProgress.type, workInProgress.pendingProps, updateExpirationTime, renderExpirationTime);
            }

          case IncompleteClassComponent:
            {
              var _Component3 = workInProgress.type;
              var _unresolvedProps4 = workInProgress.pendingProps;

              var _resolvedProps4 = workInProgress.elementType === _Component3 ? _unresolvedProps4 : resolveDefaultProps(_Component3, _unresolvedProps4);

              return mountIncompleteClassComponent(current$$1, workInProgress, _Component3, _resolvedProps4, renderExpirationTime);
            }

          case DehydratedSuspenseComponent:
            {
              if (enableSuspenseServerRenderer) {
                return updateDehydratedSuspenseComponent(current$$1, workInProgress, renderExpirationTime);
              }

              break;
            }

          case SuspenseListComponent:
            {
              return updateSuspenseListComponent(current$$1, workInProgress, renderExpirationTime);
            }

          case FundamentalComponent:
            {
              if (enableFundamentalAPI) {
                return updateFundamentalComponent$1(current$$1, workInProgress, renderExpirationTime);
              }

              break;
            }
        }

        (function () {
          {
            throw ReactError(Error("Unknown unit of work tag. This error is likely caused by a bug in React. Please file an issue."));
          }
        })();
      }

      function createFundamentalStateInstance(currentFiber, props, impl, state) {
        return {
          currentFiber: currentFiber,
          impl: impl,
          instance: null,
          prevProps: null,
          props: props,
          state: state
        };
      }

      var emptyObject$1 = {};
      var isArray$2 = Array.isArray;

      function markUpdate(workInProgress) {
        workInProgress.effectTag |= Update;
      }

      function markRef$1(workInProgress) {
        workInProgress.effectTag |= Ref;
      }

      var _appendAllChildren = void 0;

      var updateHostContainer = void 0;
      var updateHostComponent$1 = void 0;
      var updateHostText$1 = void 0;

      if (supportsMutation) {
        _appendAllChildren = function appendAllChildren(parent, workInProgress, needsVisibilityToggle, isHidden) {
          var node = workInProgress.child;

          while (node !== null) {
            if (node.tag === HostComponent || node.tag === HostText) {
              appendInitialChild(parent, node.stateNode);
            } else if (enableFundamentalAPI && node.tag === FundamentalComponent) {
              appendInitialChild(parent, node.stateNode.instance);
            } else if (node.tag === HostPortal) {} else if (node.child !== null) {
              node.child.return = node;
              node = node.child;
              continue;
            }

            if (node === workInProgress) {
              return;
            }

            while (node.sibling === null) {
              if (node.return === null || node.return === workInProgress) {
                return;
              }

              node = node.return;
            }

            node.sibling.return = node.return;
            node = node.sibling;
          }
        };

        updateHostContainer = function updateHostContainer(workInProgress) {};

        updateHostComponent$1 = function updateHostComponent$1(current, workInProgress, type, newProps, rootContainerInstance) {
          var oldProps = current.memoizedProps;

          if (oldProps === newProps) {
            return;
          }

          var instance = workInProgress.stateNode;
          var currentHostContext = getHostContext();
          var updatePayload = prepareUpdate(instance, type, oldProps, newProps, rootContainerInstance, currentHostContext);
          workInProgress.updateQueue = updatePayload;

          if (updatePayload) {
            markUpdate(workInProgress);
          }
        };

        updateHostText$1 = function updateHostText$1(current, workInProgress, oldText, newText) {
          if (oldText !== newText) {
            markUpdate(workInProgress);
          }
        };
      } else if (supportsPersistence) {
        _appendAllChildren = function appendAllChildren(parent, workInProgress, needsVisibilityToggle, isHidden) {
          var node = workInProgress.child;

          while (node !== null) {
            branches: if (node.tag === HostComponent) {
              var instance = node.stateNode;

              if (needsVisibilityToggle && isHidden) {
                var props = node.memoizedProps;
                var type = node.type;
                instance = cloneHiddenInstance(instance, type, props, node);
              }

              appendInitialChild(parent, instance);
            } else if (node.tag === HostText) {
              var _instance = node.stateNode;

              if (needsVisibilityToggle && isHidden) {
                var text = node.memoizedProps;
                _instance = cloneHiddenTextInstance(_instance, text, node);
              }

              appendInitialChild(parent, _instance);
            } else if (enableFundamentalAPI && node.tag === FundamentalComponent) {
              var _instance2 = node.stateNode.instance;

              if (needsVisibilityToggle && isHidden) {
                var _props = node.memoizedProps;
                var _type = node.type;
                _instance2 = cloneHiddenInstance(_instance2, _type, _props, node);
              }

              appendInitialChild(parent, _instance2);
            } else if (node.tag === HostPortal) {} else if (node.tag === SuspenseComponent) {
              if ((node.effectTag & Update) !== NoEffect) {
                var newIsHidden = node.memoizedState !== null;

                if (newIsHidden) {
                  var primaryChildParent = node.child;

                  if (primaryChildParent !== null) {
                    if (primaryChildParent.child !== null) {
                      primaryChildParent.child.return = primaryChildParent;

                      _appendAllChildren(parent, primaryChildParent, true, newIsHidden);
                    }

                    var fallbackChildParent = primaryChildParent.sibling;

                    if (fallbackChildParent !== null) {
                      fallbackChildParent.return = node;
                      node = fallbackChildParent;
                      continue;
                    }
                  }
                }
              }

              if (node.child !== null) {
                node.child.return = node;
                node = node.child;
                continue;
              }
            } else if (node.child !== null) {
              node.child.return = node;
              node = node.child;
              continue;
            }

            node = node;

            if (node === workInProgress) {
              return;
            }

            while (node.sibling === null) {
              if (node.return === null || node.return === workInProgress) {
                return;
              }

              node = node.return;
            }

            node.sibling.return = node.return;
            node = node.sibling;
          }
        };

        var appendAllChildrenToContainer = function appendAllChildrenToContainer(containerChildSet, workInProgress, needsVisibilityToggle, isHidden) {
          var node = workInProgress.child;

          while (node !== null) {
            branches: if (node.tag === HostComponent) {
              var instance = node.stateNode;

              if (needsVisibilityToggle && isHidden) {
                var props = node.memoizedProps;
                var type = node.type;
                instance = cloneHiddenInstance(instance, type, props, node);
              }

              appendChildToContainerChildSet(containerChildSet, instance);
            } else if (node.tag === HostText) {
              var _instance3 = node.stateNode;

              if (needsVisibilityToggle && isHidden) {
                var text = node.memoizedProps;
                _instance3 = cloneHiddenTextInstance(_instance3, text, node);
              }

              appendChildToContainerChildSet(containerChildSet, _instance3);
            } else if (enableFundamentalAPI && node.tag === FundamentalComponent) {
              var _instance4 = node.stateNode.instance;

              if (needsVisibilityToggle && isHidden) {
                var _props2 = node.memoizedProps;
                var _type2 = node.type;
                _instance4 = cloneHiddenInstance(_instance4, _type2, _props2, node);
              }

              appendChildToContainerChildSet(containerChildSet, _instance4);
            } else if (node.tag === HostPortal) {} else if (node.tag === SuspenseComponent) {
              if ((node.effectTag & Update) !== NoEffect) {
                var newIsHidden = node.memoizedState !== null;

                if (newIsHidden) {
                  var primaryChildParent = node.child;

                  if (primaryChildParent !== null) {
                    if (primaryChildParent.child !== null) {
                      primaryChildParent.child.return = primaryChildParent;
                      appendAllChildrenToContainer(containerChildSet, primaryChildParent, true, newIsHidden);
                    }

                    var fallbackChildParent = primaryChildParent.sibling;

                    if (fallbackChildParent !== null) {
                      fallbackChildParent.return = node;
                      node = fallbackChildParent;
                      continue;
                    }
                  }
                }
              }

              if (node.child !== null) {
                node.child.return = node;
                node = node.child;
                continue;
              }
            } else if (node.child !== null) {
              node.child.return = node;
              node = node.child;
              continue;
            }

            node = node;

            if (node === workInProgress) {
              return;
            }

            while (node.sibling === null) {
              if (node.return === null || node.return === workInProgress) {
                return;
              }

              node = node.return;
            }

            node.sibling.return = node.return;
            node = node.sibling;
          }
        };

        updateHostContainer = function updateHostContainer(workInProgress) {
          var portalOrRoot = workInProgress.stateNode;
          var childrenUnchanged = workInProgress.firstEffect === null;

          if (childrenUnchanged) {} else {
            var container = portalOrRoot.containerInfo;
            var newChildSet = createContainerChildSet(container);
            appendAllChildrenToContainer(newChildSet, workInProgress, false, false);
            portalOrRoot.pendingChildren = newChildSet;
            markUpdate(workInProgress);
            finalizeContainerChildren(container, newChildSet);
          }
        };

        updateHostComponent$1 = function updateHostComponent$1(current, workInProgress, type, newProps, rootContainerInstance) {
          var currentInstance = current.stateNode;
          var oldProps = current.memoizedProps;
          var childrenUnchanged = workInProgress.firstEffect === null;

          if (childrenUnchanged && oldProps === newProps) {
            workInProgress.stateNode = currentInstance;
            return;
          }

          var recyclableInstance = workInProgress.stateNode;
          var currentHostContext = getHostContext();
          var updatePayload = null;

          if (oldProps !== newProps) {
            updatePayload = prepareUpdate(recyclableInstance, type, oldProps, newProps, rootContainerInstance, currentHostContext);
          }

          if (childrenUnchanged && updatePayload === null) {
            workInProgress.stateNode = currentInstance;
            return;
          }

          var newInstance = cloneInstance(currentInstance, updatePayload, type, oldProps, newProps, workInProgress, childrenUnchanged, recyclableInstance);

          if (finalizeInitialChildren(newInstance, type, newProps, rootContainerInstance, currentHostContext)) {
            markUpdate(workInProgress);
          }

          workInProgress.stateNode = newInstance;

          if (childrenUnchanged) {
            markUpdate(workInProgress);
          } else {
            _appendAllChildren(newInstance, workInProgress, false, false);
          }
        };

        updateHostText$1 = function updateHostText$1(current, workInProgress, oldText, newText) {
          if (oldText !== newText) {
            var rootContainerInstance = getRootHostContainer();
            var currentHostContext = getHostContext();
            workInProgress.stateNode = createTextInstance(newText, rootContainerInstance, currentHostContext, workInProgress);
            markUpdate(workInProgress);
          }
        };
      } else {
        updateHostContainer = function updateHostContainer(workInProgress) {};

        updateHostComponent$1 = function updateHostComponent$1(current, workInProgress, type, newProps, rootContainerInstance) {};

        updateHostText$1 = function updateHostText$1(current, workInProgress, oldText, newText) {};
      }

      function cutOffTailIfNeeded(renderState, hasRenderedATailFallback) {
        switch (renderState.tailMode) {
          case "hidden":
            {
              var tailNode = renderState.tail;
              var lastTailNode = null;

              while (tailNode !== null) {
                if (tailNode.alternate !== null) {
                  lastTailNode = tailNode;
                }

                tailNode = tailNode.sibling;
              }

              if (lastTailNode === null) {
                renderState.tail = null;
              } else {
                lastTailNode.sibling = null;
              }

              break;
            }

          case "collapsed":
            {
              var _tailNode = renderState.tail;
              var _lastTailNode = null;

              while (_tailNode !== null) {
                if (_tailNode.alternate !== null) {
                  _lastTailNode = _tailNode;
                }

                _tailNode = _tailNode.sibling;
              }

              if (_lastTailNode === null) {
                if (!hasRenderedATailFallback && renderState.tail !== null) {
                  renderState.tail.sibling = null;
                } else {
                  renderState.tail = null;
                }
              } else {
                _lastTailNode.sibling = null;
              }

              break;
            }
        }
      }

      function completeWork(current, workInProgress, renderExpirationTime) {
        var newProps = workInProgress.pendingProps;

        switch (workInProgress.tag) {
          case IndeterminateComponent:
            break;

          case LazyComponent:
            break;

          case SimpleMemoComponent:
          case FunctionComponent:
            break;

          case ClassComponent:
            {
              var Component = workInProgress.type;

              if (isContextProvider(Component)) {
                popContext(workInProgress);
              }

              break;
            }

          case HostRoot:
            {
              popHostContainer(workInProgress);
              popTopLevelContextObject(workInProgress);
              var fiberRoot = workInProgress.stateNode;

              if (fiberRoot.pendingContext) {
                fiberRoot.context = fiberRoot.pendingContext;
                fiberRoot.pendingContext = null;
              }

              if (current === null || current.child === null) {
                popHydrationState(workInProgress);
                workInProgress.effectTag &= ~Placement;
              }

              updateHostContainer(workInProgress);
              break;
            }

          case HostComponent:
            {
              popHostContext(workInProgress);
              var rootContainerInstance = getRootHostContainer();
              var type = workInProgress.type;

              if (current !== null && workInProgress.stateNode != null) {
                updateHostComponent$1(current, workInProgress, type, newProps, rootContainerInstance);

                if (enableFlareAPI) {
                  var prevListeners = current.memoizedProps.listeners;
                  var nextListeners = newProps.listeners;
                  var instance = workInProgress.stateNode;

                  if (prevListeners !== nextListeners) {
                    updateEventListeners(nextListeners, instance, rootContainerInstance, workInProgress);
                  }
                }

                if (current.ref !== workInProgress.ref) {
                  markRef$1(workInProgress);
                }
              } else {
                if (!newProps) {
                  (function () {
                    if (!(workInProgress.stateNode !== null)) {
                      throw ReactError(Error("We must have new props for new mounts. This error is likely caused by a bug in React. Please file an issue."));
                    }
                  })();

                  break;
                }

                var currentHostContext = getHostContext();
                var wasHydrated = popHydrationState(workInProgress);

                if (wasHydrated) {
                  if (prepareToHydrateHostInstance(workInProgress, rootContainerInstance, currentHostContext)) {
                    markUpdate(workInProgress);
                  }

                  if (enableFlareAPI) {
                    var _instance5 = workInProgress.stateNode;
                    var listeners = newProps.listeners;

                    if (listeners != null) {
                      updateEventListeners(listeners, _instance5, rootContainerInstance, workInProgress);
                    }
                  }
                } else {
                  var _instance6 = createInstance(type, newProps, rootContainerInstance, currentHostContext, workInProgress);

                  _appendAllChildren(_instance6, workInProgress, false, false);

                  if (enableFlareAPI) {
                    var _listeners = newProps.listeners;

                    if (_listeners != null) {
                      updateEventListeners(_listeners, _instance6, rootContainerInstance, workInProgress);
                    }
                  }

                  if (finalizeInitialChildren(_instance6, type, newProps, rootContainerInstance, currentHostContext)) {
                    markUpdate(workInProgress);
                  }

                  workInProgress.stateNode = _instance6;
                }

                if (workInProgress.ref !== null) {
                  markRef$1(workInProgress);
                }
              }

              break;
            }

          case HostText:
            {
              var newText = newProps;

              if (current && workInProgress.stateNode != null) {
                var oldText = current.memoizedProps;
                updateHostText$1(current, workInProgress, oldText, newText);
              } else {
                if (typeof newText !== "string") {
                  (function () {
                    if (!(workInProgress.stateNode !== null)) {
                      throw ReactError(Error("We must have new props for new mounts. This error is likely caused by a bug in React. Please file an issue."));
                    }
                  })();
                }

                var _rootContainerInstance = getRootHostContainer();

                var _currentHostContext = getHostContext();

                var _wasHydrated = popHydrationState(workInProgress);

                if (_wasHydrated) {
                  if (prepareToHydrateHostTextInstance(workInProgress)) {
                    markUpdate(workInProgress);
                  }
                } else {
                  workInProgress.stateNode = createTextInstance(newText, _rootContainerInstance, _currentHostContext, workInProgress);
                }
              }

              break;
            }

          case ForwardRef:
            break;

          case SuspenseComponent:
            {
              popSuspenseContext(workInProgress);
              var nextState = workInProgress.memoizedState;

              if ((workInProgress.effectTag & DidCapture) !== NoEffect) {
                workInProgress.expirationTime = renderExpirationTime;
                return workInProgress;
              }

              var nextDidTimeout = nextState !== null;
              var prevDidTimeout = false;

              if (current === null) {
                popHydrationState(workInProgress);
              } else {
                var prevState = current.memoizedState;
                prevDidTimeout = prevState !== null;

                if (!nextDidTimeout && prevState !== null) {
                  var currentFallbackChild = current.child.sibling;

                  if (currentFallbackChild !== null) {
                    var first = workInProgress.firstEffect;

                    if (first !== null) {
                      workInProgress.firstEffect = currentFallbackChild;
                      currentFallbackChild.nextEffect = first;
                    } else {
                      workInProgress.firstEffect = workInProgress.lastEffect = currentFallbackChild;
                      currentFallbackChild.nextEffect = null;
                    }

                    currentFallbackChild.effectTag = Deletion;
                  }
                }
              }

              if (nextDidTimeout && !prevDidTimeout) {
                if ((workInProgress.mode & BatchedMode) !== NoMode) {
                  var hasInvisibleChildContext = current === null && workInProgress.memoizedProps.unstable_avoidThisFallback !== true;

                  if (hasInvisibleChildContext || hasSuspenseContext(suspenseStackCursor.current, InvisibleParentSuspenseContext)) {
                    renderDidSuspend();
                  } else {
                    renderDidSuspendDelayIfPossible();
                  }
                }
              }

              if (supportsPersistence) {
                if (nextDidTimeout) {
                  workInProgress.effectTag |= Update;
                }
              }

              if (supportsMutation) {
                if (nextDidTimeout || prevDidTimeout) {
                  workInProgress.effectTag |= Update;
                }
              }

              if (enableSuspenseCallback && workInProgress.updateQueue !== null && workInProgress.memoizedProps.suspenseCallback != null) {
                workInProgress.effectTag |= Update;
              }

              break;
            }

          case Fragment:
            break;

          case Mode:
            break;

          case Profiler:
            break;

          case HostPortal:
            popHostContainer(workInProgress);
            updateHostContainer(workInProgress);
            break;

          case ContextProvider:
            popProvider(workInProgress);
            break;

          case ContextConsumer:
            break;

          case MemoComponent:
            break;

          case IncompleteClassComponent:
            {
              var _Component = workInProgress.type;

              if (isContextProvider(_Component)) {
                popContext(workInProgress);
              }

              break;
            }

          case DehydratedSuspenseComponent:
            {
              if (enableSuspenseServerRenderer) {
                popSuspenseContext(workInProgress);

                if (current === null) {
                  var _wasHydrated2 = popHydrationState(workInProgress);

                  (function () {
                    if (!_wasHydrated2) {
                      throw ReactError(Error("A dehydrated suspense component was completed without a hydrated node. This is probably a bug in React."));
                    }
                  })();

                  if (enableSchedulerTracing) {
                    markSpawnedWork(Never);
                  }

                  skipPastDehydratedSuspenseInstance(workInProgress);
                } else {
                  resetHydrationState();

                  if ((workInProgress.effectTag & DidCapture) === NoEffect) {
                    current.alternate = null;
                    workInProgress.alternate = null;
                    workInProgress.tag = SuspenseComponent;
                    workInProgress.memoizedState = null;
                    workInProgress.stateNode = null;
                  }
                }
              }

              break;
            }

          case SuspenseListComponent:
            {
              popSuspenseContext(workInProgress);
              var renderState = workInProgress.memoizedState;

              if (renderState === null) {
                break;
              }

              var didSuspendAlready = (workInProgress.effectTag & DidCapture) !== NoEffect;
              var renderedTail = renderState.rendering;

              if (renderedTail === null) {
                if (!didSuspendAlready) {
                  var cannotBeSuspended = renderHasNotSuspendedYet() && (current === null || (current.effectTag & DidCapture) === NoEffect);

                  if (!cannotBeSuspended) {
                    var row = workInProgress.child;

                    while (row !== null) {
                      var suspended = findFirstSuspended(row);

                      if (suspended !== null) {
                        didSuspendAlready = true;
                        workInProgress.effectTag |= DidCapture;
                        cutOffTailIfNeeded(renderState, false);
                        var newThennables = suspended.updateQueue;

                        if (newThennables !== null) {
                          workInProgress.updateQueue = newThennables;
                          workInProgress.effectTag |= Update;
                        }

                        workInProgress.firstEffect = workInProgress.lastEffect = null;
                        resetChildFibers(workInProgress, renderExpirationTime);
                        pushSuspenseContext(workInProgress, setShallowSuspenseContext(suspenseStackCursor.current, ForceSuspenseFallback));
                        return workInProgress.child;
                      }

                      row = row.sibling;
                    }
                  }
                } else {
                  cutOffTailIfNeeded(renderState, false);
                }
              } else {
                if (!didSuspendAlready) {
                  var _suspended = findFirstSuspended(renderedTail);

                  if (_suspended !== null) {
                    workInProgress.effectTag |= DidCapture;
                    didSuspendAlready = true;
                    cutOffTailIfNeeded(renderState, true);

                    if (renderState.tail === null && renderState.tailMode === "hidden") {
                      var _newThennables = _suspended.updateQueue;

                      if (_newThennables !== null) {
                        workInProgress.updateQueue = _newThennables;
                        workInProgress.effectTag |= Update;
                      }

                      var lastEffect = workInProgress.lastEffect = renderState.lastEffect;

                      if (lastEffect !== null) {
                        lastEffect.nextEffect = null;
                      }

                      return null;
                    }
                  } else if (now() > renderState.tailExpiration && renderExpirationTime > Never) {
                    workInProgress.effectTag |= DidCapture;
                    didSuspendAlready = true;
                    cutOffTailIfNeeded(renderState, false);
                    var nextPriority = renderExpirationTime - 1;
                    workInProgress.expirationTime = workInProgress.childExpirationTime = nextPriority;

                    if (enableSchedulerTracing) {
                      markSpawnedWork(nextPriority);
                    }
                  }
                }

                if (renderState.isBackwards) {
                  renderedTail.sibling = workInProgress.child;
                  workInProgress.child = renderedTail;
                } else {
                  var previousSibling = renderState.last;

                  if (previousSibling !== null) {
                    previousSibling.sibling = renderedTail;
                  } else {
                    workInProgress.child = renderedTail;
                  }

                  renderState.last = renderedTail;
                }
              }

              if (renderState.tail !== null) {
                if (renderState.tailExpiration === 0) {
                  var TAIL_EXPIRATION_TIMEOUT_MS = 500;
                  renderState.tailExpiration = now() + TAIL_EXPIRATION_TIMEOUT_MS;
                }

                var next = renderState.tail;
                renderState.rendering = next;
                renderState.tail = next.sibling;
                renderState.lastEffect = workInProgress.lastEffect;
                next.sibling = null;
                var suspenseContext = suspenseStackCursor.current;

                if (didSuspendAlready) {
                  suspenseContext = setShallowSuspenseContext(suspenseContext, ForceSuspenseFallback);
                } else {
                  suspenseContext = setDefaultShallowSuspenseContext(suspenseContext);
                }

                pushSuspenseContext(workInProgress, suspenseContext);
                return next;
              }

              break;
            }

          case FundamentalComponent:
            {
              if (enableFundamentalAPI) {
                var fundamentalImpl = workInProgress.type.impl;
                var fundamentalInstance = workInProgress.stateNode;

                if (fundamentalInstance === null) {
                  var getInitialState = fundamentalImpl.getInitialState;
                  var fundamentalState = void 0;

                  if (getInitialState !== undefined) {
                    fundamentalState = getInitialState(newProps);
                  }

                  fundamentalInstance = workInProgress.stateNode = createFundamentalStateInstance(workInProgress, newProps, fundamentalImpl, fundamentalState || {});

                  var _instance7 = getFundamentalComponentInstance(fundamentalInstance);

                  fundamentalInstance.instance = _instance7;

                  if (fundamentalImpl.reconcileChildren === false) {
                    return null;
                  }

                  _appendAllChildren(_instance7, workInProgress, false, false);

                  mountFundamentalComponent(fundamentalInstance);
                } else {
                  var prevProps = fundamentalInstance.props;
                  fundamentalInstance.prevProps = prevProps;
                  fundamentalInstance.props = newProps;
                  fundamentalInstance.currentFiber = workInProgress;

                  if (supportsPersistence) {
                    var _instance8 = cloneFundamentalInstance(fundamentalInstance);

                    fundamentalInstance.instance = _instance8;

                    _appendAllChildren(_instance8, workInProgress, false, false);
                  }

                  var shouldUpdate = shouldUpdateFundamentalComponent(fundamentalInstance);

                  if (shouldUpdate) {
                    markUpdate(workInProgress);
                  }
                }
              }

              break;
            }

          default:
            (function () {
              {
                throw ReactError(Error("Unknown unit of work tag. This error is likely caused by a bug in React. Please file an issue."));
              }
            })();

        }

        return null;
      }

      function mountEventResponder(responder, responderProps, instance, rootContainerInstance, fiber, respondersMap) {
        var responderState = emptyObject$1;
        var getInitialState = responder.getInitialState;

        if (getInitialState !== null) {
          responderState = getInitialState(responderProps);
        }

        var responderInstance = createResponderInstance(responder, responderProps, responderState, instance, fiber);
        mountResponderInstance(responder, responderInstance, responderProps, responderState, instance, rootContainerInstance);
        respondersMap.set(responder, responderInstance);
      }

      function updateEventListener(listener, fiber, visistedResponders, respondersMap, instance, rootContainerInstance) {
        var responder = void 0;
        var props = void 0;

        if (listener) {
          responder = listener.responder;
          props = listener.props;
        }

        (function () {
          if (!(responder && responder.$$typeof === REACT_RESPONDER_TYPE)) {
            throw ReactError(Error("An invalid value was used as an event listener. Expect one or many event listeners created via React.unstable_useResponer()."));
          }
        })();

        var listenerProps = props;

        if (visistedResponders.has(responder)) {
          {
            warning$1(false, 'Duplicate event responder "%s" found in event listeners. ' + "Event listeners passed to elements cannot use the same event responder more than once.", responder.displayName);
          }
          return;
        }

        visistedResponders.add(responder);
        var responderInstance = respondersMap.get(responder);

        if (responderInstance === undefined) {
          mountEventResponder(responder, listenerProps, instance, rootContainerInstance, fiber, respondersMap);
        } else {
          responderInstance.props = listenerProps;
          responderInstance.fiber = fiber;
        }
      }

      function updateEventListeners(listeners, instance, rootContainerInstance, fiber) {
        var visistedResponders = new Set();
        var dependencies = fiber.dependencies;

        if (listeners != null) {
          if (dependencies === null) {
            dependencies = fiber.dependencies = {
              expirationTime: NoWork,
              firstContext: null,
              responders: new Map()
            };
          }

          var respondersMap = dependencies.responders;

          if (respondersMap === null) {
            respondersMap = new Map();
          }

          if (isArray$2(listeners)) {
            for (var i = 0, length = listeners.length; i < length; i++) {
              var listener = listeners[i];
              updateEventListener(listener, fiber, visistedResponders, respondersMap, instance, rootContainerInstance);
            }
          } else {
            updateEventListener(listeners, fiber, visistedResponders, respondersMap, instance, rootContainerInstance);
          }
        }

        if (dependencies !== null) {
          var _respondersMap = dependencies.responders;

          if (_respondersMap !== null) {
            var mountedResponders = Array.from(_respondersMap.keys());

            for (var _i = 0, _length = mountedResponders.length; _i < _length; _i++) {
              var mountedResponder = mountedResponders[_i];

              if (!visistedResponders.has(mountedResponder)) {
                var responderInstance = _respondersMap.get(mountedResponder);

                unmountResponderInstance(responderInstance);

                _respondersMap.delete(mountedResponder);
              }
            }
          }
        }
      }

      function unwindWork(workInProgress, renderExpirationTime) {
        switch (workInProgress.tag) {
          case ClassComponent:
            {
              var Component = workInProgress.type;

              if (isContextProvider(Component)) {
                popContext(workInProgress);
              }

              var effectTag = workInProgress.effectTag;

              if (effectTag & ShouldCapture) {
                workInProgress.effectTag = effectTag & ~ShouldCapture | DidCapture;
                return workInProgress;
              }

              return null;
            }

          case HostRoot:
            {
              popHostContainer(workInProgress);
              popTopLevelContextObject(workInProgress);
              var _effectTag = workInProgress.effectTag;

              (function () {
                if (!((_effectTag & DidCapture) === NoEffect)) {
                  throw ReactError(Error("The root failed to unmount after an error. This is likely a bug in React. Please file an issue."));
                }
              })();

              workInProgress.effectTag = _effectTag & ~ShouldCapture | DidCapture;
              return workInProgress;
            }

          case HostComponent:
            {
              popHostContext(workInProgress);
              return null;
            }

          case SuspenseComponent:
            {
              popSuspenseContext(workInProgress);
              var _effectTag2 = workInProgress.effectTag;

              if (_effectTag2 & ShouldCapture) {
                workInProgress.effectTag = _effectTag2 & ~ShouldCapture | DidCapture;
                return workInProgress;
              }

              return null;
            }

          case DehydratedSuspenseComponent:
            {
              if (enableSuspenseServerRenderer) {
                popSuspenseContext(workInProgress);

                if (workInProgress.alternate === null) {} else {
                  resetHydrationState();
                }

                var _effectTag3 = workInProgress.effectTag;

                if (_effectTag3 & ShouldCapture) {
                  workInProgress.effectTag = _effectTag3 & ~ShouldCapture | DidCapture;
                  return workInProgress;
                }
              }

              return null;
            }

          case SuspenseListComponent:
            {
              popSuspenseContext(workInProgress);
              return null;
            }

          case HostPortal:
            popHostContainer(workInProgress);
            return null;

          case ContextProvider:
            popProvider(workInProgress);
            return null;

          default:
            return null;
        }
      }

      function unwindInterruptedWork(interruptedWork) {
        switch (interruptedWork.tag) {
          case ClassComponent:
            {
              var childContextTypes = interruptedWork.type.childContextTypes;

              if (childContextTypes !== null && childContextTypes !== undefined) {
                popContext(interruptedWork);
              }

              break;
            }

          case HostRoot:
            {
              popHostContainer(interruptedWork);
              popTopLevelContextObject(interruptedWork);
              break;
            }

          case HostComponent:
            {
              popHostContext(interruptedWork);
              break;
            }

          case HostPortal:
            popHostContainer(interruptedWork);
            break;

          case SuspenseComponent:
            popSuspenseContext(interruptedWork);
            break;

          case DehydratedSuspenseComponent:
            if (enableSuspenseServerRenderer) {
              popSuspenseContext(interruptedWork);
            }

            break;

          case SuspenseListComponent:
            popSuspenseContext(interruptedWork);
            break;

          case ContextProvider:
            popProvider(interruptedWork);
            break;

          default:
            break;
        }
      }

      function createCapturedValue(value, source) {
        return {
          value: value,
          source: source,
          stack: getStackByFiberInDevAndProd(source)
        };
      }

      (function () {
        if (!(typeof ReactNativePrivateInterface.ReactFiberErrorDialog.showErrorDialog === "function")) {
          throw ReactError(Error("Expected ReactFiberErrorDialog.showErrorDialog to be a function."));
        }
      })();

      function showErrorDialog(capturedError) {
        return ReactNativePrivateInterface.ReactFiberErrorDialog.showErrorDialog(capturedError);
      }

      function logCapturedError(capturedError) {
        var logError = showErrorDialog(capturedError);

        if (logError === false) {
          return;
        }

        var error = capturedError.error;
        {
          var componentName = capturedError.componentName,
              componentStack = capturedError.componentStack,
              errorBoundaryName = capturedError.errorBoundaryName,
              errorBoundaryFound = capturedError.errorBoundaryFound,
              willRetry = capturedError.willRetry;

          if (error != null && error._suppressLogging) {
            if (errorBoundaryFound && willRetry) {
              return;
            }

            console.error(error);
          }

          var componentNameMessage = componentName ? "The above error occurred in the <" + componentName + "> component:" : "The above error occurred in one of your React components:";
          var errorBoundaryMessage = void 0;

          if (errorBoundaryFound && errorBoundaryName) {
            if (willRetry) {
              errorBoundaryMessage = "React will try to recreate this component tree from scratch " + ("using the error boundary you provided, " + errorBoundaryName + ".");
            } else {
              errorBoundaryMessage = "This error was initially handled by the error boundary " + errorBoundaryName + ".\n" + "Recreating the tree from scratch failed so React will unmount the tree.";
            }
          } else {
            errorBoundaryMessage = "Consider adding an error boundary to your tree to customize error handling behavior.\n" + "Visit https://fb.me/react-error-boundaries to learn more about error boundaries.";
          }

          var combinedMessage = "" + componentNameMessage + componentStack + "\n\n" + ("" + errorBoundaryMessage);
          console.error(combinedMessage);
        }
      }

      var didWarnAboutUndefinedSnapshotBeforeUpdate = null;
      {
        didWarnAboutUndefinedSnapshotBeforeUpdate = new Set();
      }
      var PossiblyWeakSet$1 = typeof WeakSet === "function" ? WeakSet : Set;

      function logError(boundary, errorInfo) {
        var source = errorInfo.source;
        var stack = errorInfo.stack;

        if (stack === null && source !== null) {
          stack = getStackByFiberInDevAndProd(source);
        }

        var capturedError = {
          componentName: source !== null ? getComponentName(source.type) : null,
          componentStack: stack !== null ? stack : "",
          error: errorInfo.value,
          errorBoundary: null,
          errorBoundaryName: null,
          errorBoundaryFound: false,
          willRetry: false
        };

        if (boundary !== null && boundary.tag === ClassComponent) {
          capturedError.errorBoundary = boundary.stateNode;
          capturedError.errorBoundaryName = getComponentName(boundary.type);
          capturedError.errorBoundaryFound = true;
          capturedError.willRetry = true;
        }

        try {
          logCapturedError(capturedError);
        } catch (e) {
          setTimeout(function () {
            throw e;
          });
        }
      }

      var callComponentWillUnmountWithTimer = function callComponentWillUnmountWithTimer(current$$1, instance) {
        startPhaseTimer(current$$1, "componentWillUnmount");
        instance.props = current$$1.memoizedProps;
        instance.state = current$$1.memoizedState;
        instance.componentWillUnmount();
        stopPhaseTimer();
      };

      function safelyCallComponentWillUnmount(current$$1, instance) {
        {
          invokeGuardedCallback(null, callComponentWillUnmountWithTimer, null, current$$1, instance);

          if (hasCaughtError()) {
            var unmountError = clearCaughtError();
            captureCommitPhaseError(current$$1, unmountError);
          }
        }
      }

      function safelyDetachRef(current$$1) {
        var ref = current$$1.ref;

        if (ref !== null) {
          if (typeof ref === "function") {
            {
              invokeGuardedCallback(null, ref, null, null);

              if (hasCaughtError()) {
                var refError = clearCaughtError();
                captureCommitPhaseError(current$$1, refError);
              }
            }
          } else {
            ref.current = null;
          }
        }
      }

      function safelyCallDestroy(current$$1, destroy) {
        {
          invokeGuardedCallback(null, destroy, null);

          if (hasCaughtError()) {
            var error = clearCaughtError();
            captureCommitPhaseError(current$$1, error);
          }
        }
      }

      function commitBeforeMutationLifeCycles(current$$1, finishedWork) {
        switch (finishedWork.tag) {
          case FunctionComponent:
          case ForwardRef:
          case SimpleMemoComponent:
            {
              commitHookEffectList(UnmountSnapshot, NoEffect$1, finishedWork);
              return;
            }

          case ClassComponent:
            {
              if (finishedWork.effectTag & Snapshot) {
                if (current$$1 !== null) {
                  var prevProps = current$$1.memoizedProps;
                  var prevState = current$$1.memoizedState;
                  startPhaseTimer(finishedWork, "getSnapshotBeforeUpdate");
                  var instance = finishedWork.stateNode;
                  {
                    if (finishedWork.type === finishedWork.elementType && !didWarnAboutReassigningProps) {
                      !(instance.props === finishedWork.memoizedProps) ? warning$1(false, "Expected %s props to match memoized props before " + "getSnapshotBeforeUpdate. " + "This might either be because of a bug in React, or because " + "a component reassigns its own `this.props`. " + "Please file an issue.", getComponentName(finishedWork.type) || "instance") : void 0;
                      !(instance.state === finishedWork.memoizedState) ? warning$1(false, "Expected %s state to match memoized state before " + "getSnapshotBeforeUpdate. " + "This might either be because of a bug in React, or because " + "a component reassigns its own `this.props`. " + "Please file an issue.", getComponentName(finishedWork.type) || "instance") : void 0;
                    }
                  }
                  var snapshot = instance.getSnapshotBeforeUpdate(finishedWork.elementType === finishedWork.type ? prevProps : resolveDefaultProps(finishedWork.type, prevProps), prevState);
                  {
                    var didWarnSet = didWarnAboutUndefinedSnapshotBeforeUpdate;

                    if (snapshot === undefined && !didWarnSet.has(finishedWork.type)) {
                      didWarnSet.add(finishedWork.type);
                      warningWithoutStack$1(false, "%s.getSnapshotBeforeUpdate(): A snapshot value (or null) " + "must be returned. You have returned undefined.", getComponentName(finishedWork.type));
                    }
                  }
                  instance.__reactInternalSnapshotBeforeUpdate = snapshot;
                  stopPhaseTimer();
                }
              }

              return;
            }

          case HostRoot:
          case HostComponent:
          case HostText:
          case HostPortal:
          case IncompleteClassComponent:
            return;

          default:
            {
              (function () {
                {
                  throw ReactError(Error("This unit of work tag should not have side-effects. This error is likely caused by a bug in React. Please file an issue."));
                }
              })();
            }
        }
      }

      function commitHookEffectList(unmountTag, mountTag, finishedWork) {
        var updateQueue = finishedWork.updateQueue;
        var lastEffect = updateQueue !== null ? updateQueue.lastEffect : null;

        if (lastEffect !== null) {
          var firstEffect = lastEffect.next;
          var effect = firstEffect;

          do {
            if ((effect.tag & unmountTag) !== NoEffect$1) {
              var destroy = effect.destroy;
              effect.destroy = undefined;

              if (destroy !== undefined) {
                destroy();
              }
            }

            if ((effect.tag & mountTag) !== NoEffect$1) {
              var create = effect.create;
              effect.destroy = create();
              {
                var _destroy = effect.destroy;

                if (_destroy !== undefined && typeof _destroy !== "function") {
                  var addendum = void 0;

                  if (_destroy === null) {
                    addendum = " You returned null. If your effect does not require clean " + "up, return undefined (or nothing).";
                  } else if (typeof _destroy.then === "function") {
                    addendum = "\n\nIt looks like you wrote useEffect(async () => ...) or returned a Promise. " + "Instead, write the async function inside your effect " + "and call it immediately:\n\n" + "useEffect(() => {\n" + "  async function fetchData() {\n" + "    // You can await here\n" + "    const response = await MyAPI.getData(someId);\n" + "    // ...\n" + "  }\n" + "  fetchData();\n" + "}, [someId]); // Or [] if effect doesn't need props or state\n\n" + "Learn more about data fetching with Hooks: https://fb.me/react-hooks-data-fetching";
                  } else {
                    addendum = " You returned: " + _destroy;
                  }

                  warningWithoutStack$1(false, "An effect function must not return anything besides a function, " + "which is used for clean-up.%s%s", addendum, getStackByFiberInDevAndProd(finishedWork));
                }
              }
            }

            effect = effect.next;
          } while (effect !== firstEffect);
        }
      }

      function commitPassiveHookEffects(finishedWork) {
        if ((finishedWork.effectTag & Passive) !== NoEffect) {
          switch (finishedWork.tag) {
            case FunctionComponent:
            case ForwardRef:
            case SimpleMemoComponent:
              {
                commitHookEffectList(UnmountPassive, NoEffect$1, finishedWork);
                commitHookEffectList(NoEffect$1, MountPassive, finishedWork);
                break;
              }

            default:
              break;
          }
        }
      }

      function commitLifeCycles(finishedRoot, current$$1, finishedWork, committedExpirationTime) {
        switch (finishedWork.tag) {
          case FunctionComponent:
          case ForwardRef:
          case SimpleMemoComponent:
            {
              commitHookEffectList(UnmountLayout, MountLayout, finishedWork);
              break;
            }

          case ClassComponent:
            {
              var instance = finishedWork.stateNode;

              if (finishedWork.effectTag & Update) {
                if (current$$1 === null) {
                  startPhaseTimer(finishedWork, "componentDidMount");
                  {
                    if (finishedWork.type === finishedWork.elementType && !didWarnAboutReassigningProps) {
                      !(instance.props === finishedWork.memoizedProps) ? warning$1(false, "Expected %s props to match memoized props before " + "componentDidMount. " + "This might either be because of a bug in React, or because " + "a component reassigns its own `this.props`. " + "Please file an issue.", getComponentName(finishedWork.type) || "instance") : void 0;
                      !(instance.state === finishedWork.memoizedState) ? warning$1(false, "Expected %s state to match memoized state before " + "componentDidMount. " + "This might either be because of a bug in React, or because " + "a component reassigns its own `this.props`. " + "Please file an issue.", getComponentName(finishedWork.type) || "instance") : void 0;
                    }
                  }
                  instance.componentDidMount();
                  stopPhaseTimer();
                } else {
                  var prevProps = finishedWork.elementType === finishedWork.type ? current$$1.memoizedProps : resolveDefaultProps(finishedWork.type, current$$1.memoizedProps);
                  var prevState = current$$1.memoizedState;
                  startPhaseTimer(finishedWork, "componentDidUpdate");
                  {
                    if (finishedWork.type === finishedWork.elementType && !didWarnAboutReassigningProps) {
                      !(instance.props === finishedWork.memoizedProps) ? warning$1(false, "Expected %s props to match memoized props before " + "componentDidUpdate. " + "This might either be because of a bug in React, or because " + "a component reassigns its own `this.props`. " + "Please file an issue.", getComponentName(finishedWork.type) || "instance") : void 0;
                      !(instance.state === finishedWork.memoizedState) ? warning$1(false, "Expected %s state to match memoized state before " + "componentDidUpdate. " + "This might either be because of a bug in React, or because " + "a component reassigns its own `this.props`. " + "Please file an issue.", getComponentName(finishedWork.type) || "instance") : void 0;
                    }
                  }
                  instance.componentDidUpdate(prevProps, prevState, instance.__reactInternalSnapshotBeforeUpdate);
                  stopPhaseTimer();
                }
              }

              var updateQueue = finishedWork.updateQueue;

              if (updateQueue !== null) {
                {
                  if (finishedWork.type === finishedWork.elementType && !didWarnAboutReassigningProps) {
                    !(instance.props === finishedWork.memoizedProps) ? warning$1(false, "Expected %s props to match memoized props before " + "processing the update queue. " + "This might either be because of a bug in React, or because " + "a component reassigns its own `this.props`. " + "Please file an issue.", getComponentName(finishedWork.type) || "instance") : void 0;
                    !(instance.state === finishedWork.memoizedState) ? warning$1(false, "Expected %s state to match memoized state before " + "processing the update queue. " + "This might either be because of a bug in React, or because " + "a component reassigns its own `this.props`. " + "Please file an issue.", getComponentName(finishedWork.type) || "instance") : void 0;
                  }
                }
                commitUpdateQueue(finishedWork, updateQueue, instance, committedExpirationTime);
              }

              return;
            }

          case HostRoot:
            {
              var _updateQueue = finishedWork.updateQueue;

              if (_updateQueue !== null) {
                var _instance = null;

                if (finishedWork.child !== null) {
                  switch (finishedWork.child.tag) {
                    case HostComponent:
                      _instance = getPublicInstance(finishedWork.child.stateNode);
                      break;

                    case ClassComponent:
                      _instance = finishedWork.child.stateNode;
                      break;
                  }
                }

                commitUpdateQueue(finishedWork, _updateQueue, _instance, committedExpirationTime);
              }

              return;
            }

          case HostComponent:
            {
              var _instance2 = finishedWork.stateNode;

              if (current$$1 === null && finishedWork.effectTag & Update) {
                var type = finishedWork.type;
                var props = finishedWork.memoizedProps;
              }

              return;
            }

          case HostText:
            {
              return;
            }

          case HostPortal:
            {
              return;
            }

          case Profiler:
            {
              if (enableProfilerTimer) {
                var onRender = finishedWork.memoizedProps.onRender;

                if (typeof onRender === "function") {
                  if (enableSchedulerTracing) {
                    onRender(finishedWork.memoizedProps.id, current$$1 === null ? "mount" : "update", finishedWork.actualDuration, finishedWork.treeBaseDuration, finishedWork.actualStartTime, getCommitTime(), finishedRoot.memoizedInteractions);
                  } else {
                    onRender(finishedWork.memoizedProps.id, current$$1 === null ? "mount" : "update", finishedWork.actualDuration, finishedWork.treeBaseDuration, finishedWork.actualStartTime, getCommitTime());
                  }
                }
              }

              return;
            }

          case SuspenseComponent:
          case SuspenseListComponent:
          case IncompleteClassComponent:
          case FundamentalComponent:
            return;

          default:
            {
              (function () {
                {
                  throw ReactError(Error("This unit of work tag should not have side-effects. This error is likely caused by a bug in React. Please file an issue."));
                }
              })();
            }
        }
      }

      function hideOrUnhideAllChildren(finishedWork, isHidden) {
        if (supportsMutation) {
          var node = finishedWork;

          while (true) {
            if (node.tag === HostComponent) {
              var instance = node.stateNode;

              if (isHidden) {
                hideInstance(instance);
              } else {
                unhideInstance(node.stateNode, node.memoizedProps);
              }
            } else if (node.tag === HostText) {
              var _instance3 = node.stateNode;

              if (isHidden) {
                hideTextInstance(_instance3);
              } else {
                unhideTextInstance(_instance3, node.memoizedProps);
              }
            } else if (node.tag === SuspenseComponent && node.memoizedState !== null) {
              var fallbackChildFragment = node.child.sibling;
              fallbackChildFragment.return = node;
              node = fallbackChildFragment;
              continue;
            } else if (node.child !== null) {
              node.child.return = node;
              node = node.child;
              continue;
            }

            if (node === finishedWork) {
              return;
            }

            while (node.sibling === null) {
              if (node.return === null || node.return === finishedWork) {
                return;
              }

              node = node.return;
            }

            node.sibling.return = node.return;
            node = node.sibling;
          }
        }
      }

      function commitAttachRef(finishedWork) {
        var ref = finishedWork.ref;

        if (ref !== null) {
          var instance = finishedWork.stateNode;
          var instanceToUse = void 0;

          switch (finishedWork.tag) {
            case HostComponent:
              instanceToUse = getPublicInstance(instance);
              break;

            default:
              instanceToUse = instance;
          }

          if (typeof ref === "function") {
            ref(instanceToUse);
          } else {
            {
              if (!ref.hasOwnProperty("current")) {
                warningWithoutStack$1(false, "Unexpected ref object provided for %s. " + "Use either a ref-setter function or React.createRef().%s", getComponentName(finishedWork.type), getStackByFiberInDevAndProd(finishedWork));
              }
            }
            ref.current = instanceToUse;
          }
        }
      }

      function commitDetachRef(current$$1) {
        var currentRef = current$$1.ref;

        if (currentRef !== null) {
          if (typeof currentRef === "function") {
            currentRef(null);
          } else {
            currentRef.current = null;
          }
        }
      }

      function commitUnmount(current$$1, renderPriorityLevel) {
        onCommitUnmount(current$$1);

        switch (current$$1.tag) {
          case FunctionComponent:
          case ForwardRef:
          case MemoComponent:
          case SimpleMemoComponent:
            {
              var updateQueue = current$$1.updateQueue;

              if (updateQueue !== null) {
                var lastEffect = updateQueue.lastEffect;

                if (lastEffect !== null) {
                  var firstEffect = lastEffect.next;
                  var priorityLevel = renderPriorityLevel > NormalPriority ? NormalPriority : renderPriorityLevel;
                  runWithPriority(priorityLevel, function () {
                    var effect = firstEffect;

                    do {
                      var destroy = effect.destroy;

                      if (destroy !== undefined) {
                        safelyCallDestroy(current$$1, destroy);
                      }

                      effect = effect.next;
                    } while (effect !== firstEffect);
                  });
                }
              }

              break;
            }

          case ClassComponent:
            {
              safelyDetachRef(current$$1);
              var instance = current$$1.stateNode;

              if (typeof instance.componentWillUnmount === "function") {
                safelyCallComponentWillUnmount(current$$1, instance);
              }

              return;
            }

          case HostComponent:
            {
              if (enableFlareAPI) {
                var dependencies = current$$1.dependencies;

                if (dependencies !== null) {
                  var respondersMap = dependencies.responders;

                  if (respondersMap !== null) {
                    var responderInstances = Array.from(respondersMap.values());

                    for (var i = 0, length = responderInstances.length; i < length; i++) {
                      var responderInstance = responderInstances[i];
                      unmountResponderInstance(responderInstance);
                    }

                    dependencies.responders = null;
                  }
                }
              }

              safelyDetachRef(current$$1);
              return;
            }

          case HostPortal:
            {
              if (supportsMutation) {
                unmountHostComponents(current$$1, renderPriorityLevel);
              } else if (supportsPersistence) {
                emptyPortalContainer(current$$1);
              }

              return;
            }

          case FundamentalComponent:
            {
              if (enableFundamentalAPI) {
                var fundamentalInstance = current$$1.stateNode;

                if (fundamentalInstance !== null) {
                  unmountFundamentalComponent(fundamentalInstance);
                  current$$1.stateNode = null;
                }
              }
            }
        }
      }

      function commitNestedUnmounts(root, renderPriorityLevel) {
        var node = root;

        while (true) {
          commitUnmount(node, renderPriorityLevel);

          if (node.child !== null && (!supportsMutation || node.tag !== HostPortal)) {
            node.child.return = node;
            node = node.child;
            continue;
          }

          if (node === root) {
            return;
          }

          while (node.sibling === null) {
            if (node.return === null || node.return === root) {
              return;
            }

            node = node.return;
          }

          node.sibling.return = node.return;
          node = node.sibling;
        }
      }

      function detachFiber(current$$1) {
        var alternate = current$$1.alternate;
        current$$1.return = null;
        current$$1.child = null;
        current$$1.memoizedState = null;
        current$$1.updateQueue = null;
        current$$1.dependencies = null;
        current$$1.alternate = null;
        current$$1.firstEffect = null;
        current$$1.lastEffect = null;
        current$$1.pendingProps = null;
        current$$1.memoizedProps = null;

        if (alternate !== null) {
          detachFiber(alternate);
        }
      }

      function emptyPortalContainer(current$$1) {
        if (!supportsPersistence) {
          return;
        }

        var portal = current$$1.stateNode;
        var containerInfo = portal.containerInfo;
        var emptyChildSet = createContainerChildSet(containerInfo);
        replaceContainerChildren(containerInfo, emptyChildSet);
      }

      function commitContainer(finishedWork) {
        if (!supportsPersistence) {
          return;
        }

        switch (finishedWork.tag) {
          case ClassComponent:
          case HostComponent:
          case HostText:
          case FundamentalComponent:
            {
              return;
            }

          case HostRoot:
          case HostPortal:
            {
              var portalOrRoot = finishedWork.stateNode;
              var containerInfo = portalOrRoot.containerInfo,
                  _pendingChildren = portalOrRoot.pendingChildren;
              replaceContainerChildren(containerInfo, _pendingChildren);
              return;
            }

          default:
            {
              (function () {
                {
                  throw ReactError(Error("This unit of work tag should not have side-effects. This error is likely caused by a bug in React. Please file an issue."));
                }
              })();
            }
        }
      }

      function getHostParentFiber(fiber) {
        var parent = fiber.return;

        while (parent !== null) {
          if (isHostParent(parent)) {
            return parent;
          }

          parent = parent.return;
        }

        (function () {
          {
            throw ReactError(Error("Expected to find a host parent. This error is likely caused by a bug in React. Please file an issue."));
          }
        })();
      }

      function isHostParent(fiber) {
        return fiber.tag === HostComponent || fiber.tag === HostRoot || fiber.tag === HostPortal;
      }

      function getHostSibling(fiber) {
        var node = fiber;

        siblings: while (true) {
          while (node.sibling === null) {
            if (node.return === null || isHostParent(node.return)) {
              return null;
            }

            node = node.return;
          }

          node.sibling.return = node.return;
          node = node.sibling;

          while (node.tag !== HostComponent && node.tag !== HostText && node.tag !== DehydratedSuspenseComponent) {
            if (node.effectTag & Placement) {
              continue siblings;
            }

            if (node.child === null || node.tag === HostPortal) {
              continue siblings;
            } else {
              node.child.return = node;
              node = node.child;
            }
          }

          if (!(node.effectTag & Placement)) {
            return node.stateNode;
          }
        }
      }

      function commitPlacement(finishedWork) {
        if (!supportsMutation) {
          return;
        }

        var parentFiber = getHostParentFiber(finishedWork);
        var parent = void 0;
        var isContainer = void 0;
        var parentStateNode = parentFiber.stateNode;

        switch (parentFiber.tag) {
          case HostComponent:
            parent = parentStateNode;
            isContainer = false;
            break;

          case HostRoot:
            parent = parentStateNode.containerInfo;
            isContainer = true;
            break;

          case HostPortal:
            parent = parentStateNode.containerInfo;
            isContainer = true;
            break;

          case FundamentalComponent:
            if (enableFundamentalAPI) {
              parent = parentStateNode.instance;
              isContainer = false;
            }

          default:
            (function () {
              {
                throw ReactError(Error("Invalid host parent fiber. This error is likely caused by a bug in React. Please file an issue."));
              }
            })();

        }

        if (parentFiber.effectTag & ContentReset) {
          parentFiber.effectTag &= ~ContentReset;
        }

        var before = getHostSibling(finishedWork);
        var node = finishedWork;

        while (true) {
          var isHost = node.tag === HostComponent || node.tag === HostText;

          if (isHost || enableFundamentalAPI && node.tag === FundamentalComponent) {
            var stateNode = isHost ? node.stateNode : node.stateNode.instance;

            if (before) {
              if (isContainer) {
                insertInContainerBefore(parent, stateNode, before);
              } else {
                insertBefore(parent, stateNode, before);
              }
            } else {
              if (isContainer) {
                appendChildToContainer(parent, stateNode);
              } else {
                appendChild(parent, stateNode);
              }
            }
          } else if (node.tag === HostPortal) {} else if (node.child !== null) {
            node.child.return = node;
            node = node.child;
            continue;
          }

          if (node === finishedWork) {
            return;
          }

          while (node.sibling === null) {
            if (node.return === null || node.return === finishedWork) {
              return;
            }

            node = node.return;
          }

          node.sibling.return = node.return;
          node = node.sibling;
        }
      }

      function unmountHostComponents(current$$1, renderPriorityLevel) {
        var node = current$$1;
        var currentParentIsValid = false;
        var currentParent = void 0;
        var currentParentIsContainer = void 0;

        while (true) {
          if (!currentParentIsValid) {
            var parent = node.return;

            findParent: while (true) {
              (function () {
                if (!(parent !== null)) {
                  throw ReactError(Error("Expected to find a host parent. This error is likely caused by a bug in React. Please file an issue."));
                }
              })();

              var parentStateNode = parent.stateNode;

              switch (parent.tag) {
                case HostComponent:
                  currentParent = parentStateNode;
                  currentParentIsContainer = false;
                  break findParent;

                case HostRoot:
                  currentParent = parentStateNode.containerInfo;
                  currentParentIsContainer = true;
                  break findParent;

                case HostPortal:
                  currentParent = parentStateNode.containerInfo;
                  currentParentIsContainer = true;
                  break findParent;

                case FundamentalComponent:
                  if (enableFundamentalAPI) {
                    currentParent = parentStateNode.instance;
                    currentParentIsContainer = false;
                  }

              }

              parent = parent.return;
            }

            currentParentIsValid = true;
          }

          if (node.tag === HostComponent || node.tag === HostText) {
            commitNestedUnmounts(node, renderPriorityLevel);

            if (currentParentIsContainer) {
              removeChildFromContainer(currentParent, node.stateNode);
            } else {
              removeChild(currentParent, node.stateNode);
            }
          } else if (enableFundamentalAPI && node.tag === FundamentalComponent) {
            var fundamentalNode = node.stateNode.instance;
            commitNestedUnmounts(node, renderPriorityLevel);

            if (currentParentIsContainer) {
              removeChildFromContainer(currentParent, fundamentalNode);
            } else {
              removeChild(currentParent, fundamentalNode);
            }
          } else if (enableSuspenseServerRenderer && node.tag === DehydratedSuspenseComponent) {
            if (currentParentIsContainer) {
              clearSuspenseBoundaryFromContainer(currentParent, node.stateNode);
            } else {
              clearSuspenseBoundary(currentParent, node.stateNode);
            }
          } else if (node.tag === HostPortal) {
            if (node.child !== null) {
              currentParent = node.stateNode.containerInfo;
              currentParentIsContainer = true;
              node.child.return = node;
              node = node.child;
              continue;
            }
          } else {
            commitUnmount(node, renderPriorityLevel);

            if (node.child !== null) {
              node.child.return = node;
              node = node.child;
              continue;
            }
          }

          if (node === current$$1) {
            return;
          }

          while (node.sibling === null) {
            if (node.return === null || node.return === current$$1) {
              return;
            }

            node = node.return;

            if (node.tag === HostPortal) {
              currentParentIsValid = false;
            }
          }

          node.sibling.return = node.return;
          node = node.sibling;
        }
      }

      function commitDeletion(current$$1, renderPriorityLevel) {
        if (supportsMutation) {
          unmountHostComponents(current$$1, renderPriorityLevel);
        } else {
          commitNestedUnmounts(current$$1, renderPriorityLevel);
        }

        detachFiber(current$$1);
      }

      function commitWork(current$$1, finishedWork) {
        if (!supportsMutation) {
          switch (finishedWork.tag) {
            case FunctionComponent:
            case ForwardRef:
            case MemoComponent:
            case SimpleMemoComponent:
              {
                commitHookEffectList(UnmountMutation, MountMutation, finishedWork);
                return;
              }

            case Profiler:
              {
                return;
              }

            case SuspenseComponent:
              {
                commitSuspenseComponent(finishedWork);
                attachSuspenseRetryListeners(finishedWork);
                return;
              }

            case SuspenseListComponent:
              {
                attachSuspenseRetryListeners(finishedWork);
                return;
              }
          }

          commitContainer(finishedWork);
          return;
        }

        switch (finishedWork.tag) {
          case FunctionComponent:
          case ForwardRef:
          case MemoComponent:
          case SimpleMemoComponent:
            {
              commitHookEffectList(UnmountMutation, MountMutation, finishedWork);
              return;
            }

          case ClassComponent:
            {
              return;
            }

          case HostComponent:
            {
              var instance = finishedWork.stateNode;

              if (instance != null) {
                var newProps = finishedWork.memoizedProps;
                var oldProps = current$$1 !== null ? current$$1.memoizedProps : newProps;
                var type = finishedWork.type;
                var updatePayload = finishedWork.updateQueue;
                finishedWork.updateQueue = null;

                if (updatePayload !== null) {
                  commitUpdate(instance, updatePayload, type, oldProps, newProps, finishedWork);
                }
              }

              return;
            }

          case HostText:
            {
              (function () {
                if (!(finishedWork.stateNode !== null)) {
                  throw ReactError(Error("This should have a text node initialized. This error is likely caused by a bug in React. Please file an issue."));
                }
              })();

              var textInstance = finishedWork.stateNode;
              var newText = finishedWork.memoizedProps;
              var oldText = current$$1 !== null ? current$$1.memoizedProps : newText;
              commitTextUpdate(textInstance, oldText, newText);
              return;
            }

          case HostRoot:
            {
              return;
            }

          case Profiler:
            {
              return;
            }

          case SuspenseComponent:
            {
              commitSuspenseComponent(finishedWork);
              attachSuspenseRetryListeners(finishedWork);
              return;
            }

          case SuspenseListComponent:
            {
              attachSuspenseRetryListeners(finishedWork);
              return;
            }

          case IncompleteClassComponent:
            {
              return;
            }

          case FundamentalComponent:
            {
              if (enableFundamentalAPI) {
                var fundamentalInstance = finishedWork.stateNode;
                updateFundamentalComponent(fundamentalInstance);
              }

              return;
            }

          default:
            {
              (function () {
                {
                  throw ReactError(Error("This unit of work tag should not have side-effects. This error is likely caused by a bug in React. Please file an issue."));
                }
              })();
            }
        }
      }

      function commitSuspenseComponent(finishedWork) {
        var newState = finishedWork.memoizedState;
        var newDidTimeout = void 0;
        var primaryChildParent = finishedWork;

        if (newState === null) {
          newDidTimeout = false;
        } else {
          newDidTimeout = true;
          primaryChildParent = finishedWork.child;
          markCommitTimeOfFallback();
        }

        if (supportsMutation && primaryChildParent !== null) {
          hideOrUnhideAllChildren(primaryChildParent, newDidTimeout);
        }

        if (enableSuspenseCallback && newState !== null) {
          var suspenseCallback = finishedWork.memoizedProps.suspenseCallback;

          if (typeof suspenseCallback === "function") {
            var thenables = finishedWork.updateQueue;

            if (thenables !== null) {
              suspenseCallback(new Set(thenables));
            }
          } else {
            if (suspenseCallback !== undefined) {
              warning$1(false, "Unexpected type for suspenseCallback.");
            }
          }
        }
      }

      function attachSuspenseRetryListeners(finishedWork) {
        var thenables = finishedWork.updateQueue;

        if (thenables !== null) {
          finishedWork.updateQueue = null;
          var retryCache = finishedWork.stateNode;

          if (retryCache === null) {
            retryCache = finishedWork.stateNode = new PossiblyWeakSet$1();
          }

          thenables.forEach(function (thenable) {
            var retry = resolveRetryThenable.bind(null, finishedWork, thenable);

            if (!retryCache.has(thenable)) {
              if (enableSchedulerTracing) {
                retry = tracing.unstable_wrap(retry);
              }

              retryCache.add(thenable);
              thenable.then(retry, retry);
            }
          });
        }
      }

      function commitResetTextContent(current$$1) {
        if (!supportsMutation) {
          return;
        }

        resetTextContent(current$$1.stateNode);
      }

      var PossiblyWeakSet = typeof WeakSet === "function" ? WeakSet : Set;
      var PossiblyWeakMap = typeof WeakMap === "function" ? WeakMap : Map;

      function createRootErrorUpdate(fiber, errorInfo, expirationTime) {
        var update = createUpdate(expirationTime, null);
        update.tag = CaptureUpdate;
        update.payload = {
          element: null
        };
        var error = errorInfo.value;

        update.callback = function () {
          onUncaughtError(error);
          logError(fiber, errorInfo);
        };

        return update;
      }

      function createClassErrorUpdate(fiber, errorInfo, expirationTime) {
        var update = createUpdate(expirationTime, null);
        update.tag = CaptureUpdate;
        var getDerivedStateFromError = fiber.type.getDerivedStateFromError;

        if (typeof getDerivedStateFromError === "function") {
          var error = errorInfo.value;

          update.payload = function () {
            logError(fiber, errorInfo);
            return getDerivedStateFromError(error);
          };
        }

        var inst = fiber.stateNode;

        if (inst !== null && typeof inst.componentDidCatch === "function") {
          update.callback = function callback() {
            {
              markFailedErrorBoundaryForHotReloading(fiber);
            }

            if (typeof getDerivedStateFromError !== "function") {
              markLegacyErrorBoundaryAsFailed(this);
              logError(fiber, errorInfo);
            }

            var error = errorInfo.value;
            var stack = errorInfo.stack;
            this.componentDidCatch(error, {
              componentStack: stack !== null ? stack : ""
            });
            {
              if (typeof getDerivedStateFromError !== "function") {
                !(fiber.expirationTime === Sync) ? warningWithoutStack$1(false, "%s: Error boundaries should implement getDerivedStateFromError(). " + "In that method, return a state update to display an error message or fallback UI.", getComponentName(fiber.type) || "Unknown") : void 0;
              }
            }
          };
        } else {
          update.callback = function () {
            markFailedErrorBoundaryForHotReloading(fiber);
          };
        }

        return update;
      }

      function attachPingListener(root, renderExpirationTime, thenable) {
        var pingCache = root.pingCache;
        var threadIDs = void 0;

        if (pingCache === null) {
          pingCache = root.pingCache = new PossiblyWeakMap();
          threadIDs = new Set();
          pingCache.set(thenable, threadIDs);
        } else {
          threadIDs = pingCache.get(thenable);

          if (threadIDs === undefined) {
            threadIDs = new Set();
            pingCache.set(thenable, threadIDs);
          }
        }

        if (!threadIDs.has(renderExpirationTime)) {
          threadIDs.add(renderExpirationTime);
          var ping = pingSuspendedRoot.bind(null, root, thenable, renderExpirationTime);

          if (enableSchedulerTracing) {
            ping = tracing.unstable_wrap(ping);
          }

          thenable.then(ping, ping);
        }
      }

      function throwException(root, returnFiber, sourceFiber, value, renderExpirationTime) {
        sourceFiber.effectTag |= Incomplete;
        sourceFiber.firstEffect = sourceFiber.lastEffect = null;

        if (value !== null && typeof value === "object" && typeof value.then === "function") {
          var thenable = value;
          checkForWrongSuspensePriorityInDEV(sourceFiber);
          var hasInvisibleParentBoundary = hasSuspenseContext(suspenseStackCursor.current, InvisibleParentSuspenseContext);
          var _workInProgress = returnFiber;

          do {
            if (_workInProgress.tag === SuspenseComponent && shouldCaptureSuspense(_workInProgress, hasInvisibleParentBoundary)) {
              var thenables = _workInProgress.updateQueue;

              if (thenables === null) {
                var updateQueue = new Set();
                updateQueue.add(thenable);
                _workInProgress.updateQueue = updateQueue;
              } else {
                thenables.add(thenable);
              }

              if ((_workInProgress.mode & BatchedMode) === NoMode) {
                _workInProgress.effectTag |= DidCapture;
                sourceFiber.effectTag &= ~(LifecycleEffectMask | Incomplete);

                if (sourceFiber.tag === ClassComponent) {
                  var currentSourceFiber = sourceFiber.alternate;

                  if (currentSourceFiber === null) {
                    sourceFiber.tag = IncompleteClassComponent;
                  } else {
                    var update = createUpdate(Sync, null);
                    update.tag = ForceUpdate;
                    enqueueUpdate(sourceFiber, update);
                  }
                }

                sourceFiber.expirationTime = Sync;
                return;
              }

              attachPingListener(root, renderExpirationTime, thenable);
              _workInProgress.effectTag |= ShouldCapture;
              _workInProgress.expirationTime = renderExpirationTime;
              return;
            } else if (enableSuspenseServerRenderer && _workInProgress.tag === DehydratedSuspenseComponent) {
              attachPingListener(root, renderExpirationTime, thenable);
              var retryCache = _workInProgress.memoizedState;

              if (retryCache === null) {
                retryCache = _workInProgress.memoizedState = new PossiblyWeakSet();
                var current$$1 = _workInProgress.alternate;

                (function () {
                  if (!current$$1) {
                    throw ReactError(Error("A dehydrated suspense boundary must commit before trying to render. This is probably a bug in React."));
                  }
                })();

                current$$1.memoizedState = retryCache;
              }

              if (!retryCache.has(thenable)) {
                retryCache.add(thenable);
                var retry = resolveRetryThenable.bind(null, _workInProgress, thenable);

                if (enableSchedulerTracing) {
                  retry = tracing.unstable_wrap(retry);
                }

                thenable.then(retry, retry);
              }

              _workInProgress.effectTag |= ShouldCapture;
              _workInProgress.expirationTime = renderExpirationTime;
              return;
            }

            _workInProgress = _workInProgress.return;
          } while (_workInProgress !== null);

          value = new Error((getComponentName(sourceFiber.type) || "A React component") + " suspended while rendering, but no fallback UI was specified.\n" + "\n" + "Add a <Suspense fallback=...> component higher in the tree to " + "provide a loading indicator or placeholder to display." + getStackByFiberInDevAndProd(sourceFiber));
        }

        renderDidError();
        value = createCapturedValue(value, sourceFiber);
        var workInProgress = returnFiber;

        do {
          switch (workInProgress.tag) {
            case HostRoot:
              {
                var _errorInfo = value;
                workInProgress.effectTag |= ShouldCapture;
                workInProgress.expirationTime = renderExpirationTime;

                var _update = createRootErrorUpdate(workInProgress, _errorInfo, renderExpirationTime);

                enqueueCapturedUpdate(workInProgress, _update);
                return;
              }

            case ClassComponent:
              var errorInfo = value;
              var ctor = workInProgress.type;
              var instance = workInProgress.stateNode;

              if ((workInProgress.effectTag & DidCapture) === NoEffect && (typeof ctor.getDerivedStateFromError === "function" || instance !== null && typeof instance.componentDidCatch === "function" && !isAlreadyFailedLegacyErrorBoundary(instance))) {
                workInProgress.effectTag |= ShouldCapture;
                workInProgress.expirationTime = renderExpirationTime;

                var _update2 = createClassErrorUpdate(workInProgress, errorInfo, renderExpirationTime);

                enqueueCapturedUpdate(workInProgress, _update2);
                return;
              }

              break;

            default:
              break;
          }

          workInProgress = workInProgress.return;
        } while (workInProgress !== null);
      }

      var ceil = Math.ceil;
      var ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
      var ReactCurrentOwner$2 = ReactSharedInternals.ReactCurrentOwner;
      var IsSomeRendererActing = ReactSharedInternals.IsSomeRendererActing;
      var NoContext = 0;
      var BatchedContext = 1;
      var EventContext = 2;
      var DiscreteEventContext = 4;
      var LegacyUnbatchedContext = 8;
      var RenderContext = 16;
      var CommitContext = 32;
      var RootIncomplete = 0;
      var RootErrored = 1;
      var RootSuspended = 2;
      var RootSuspendedWithDelay = 3;
      var RootCompleted = 4;
      var executionContext = NoContext;
      var workInProgressRoot = null;
      var workInProgress = null;
      var renderExpirationTime = NoWork;
      var workInProgressRootExitStatus = RootIncomplete;
      var workInProgressRootLatestProcessedExpirationTime = Sync;
      var workInProgressRootLatestSuspenseTimeout = Sync;
      var workInProgressRootCanSuspendUsingConfig = null;
      var workInProgressRootHasPendingPing = false;
      var globalMostRecentFallbackTime = 0;
      var FALLBACK_THROTTLE_MS = 500;
      var nextEffect = null;
      var hasUncaughtError = false;
      var firstUncaughtError = null;
      var legacyErrorBoundariesThatAlreadyFailed = null;
      var rootDoesHavePassiveEffects = false;
      var rootWithPendingPassiveEffects = null;
      var pendingPassiveEffectsRenderPriority = NoPriority;
      var pendingPassiveEffectsExpirationTime = NoWork;
      var rootsWithPendingDiscreteUpdates = null;
      var NESTED_UPDATE_LIMIT = 50;
      var nestedUpdateCount = 0;
      var rootWithNestedUpdates = null;
      var NESTED_PASSIVE_UPDATE_LIMIT = 50;
      var nestedPassiveUpdateCount = 0;
      var interruptedBy = null;
      var spawnedWorkDuringRender = null;
      var currentEventTime = NoWork;

      function requestCurrentTime() {
        if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
          return msToExpirationTime(now());
        }

        if (currentEventTime !== NoWork) {
          return currentEventTime;
        }

        currentEventTime = msToExpirationTime(now());
        return currentEventTime;
      }

      function computeExpirationForFiber(currentTime, fiber, suspenseConfig) {
        var mode = fiber.mode;

        if ((mode & BatchedMode) === NoMode) {
          return Sync;
        }

        var priorityLevel = getCurrentPriorityLevel();

        if ((mode & ConcurrentMode) === NoMode) {
          return priorityLevel === ImmediatePriority ? Sync : Batched;
        }

        if ((executionContext & RenderContext) !== NoContext) {
          return renderExpirationTime;
        }

        var expirationTime = void 0;

        if (suspenseConfig !== null) {
          expirationTime = computeSuspenseExpiration(currentTime, suspenseConfig.timeoutMs | 0 || LOW_PRIORITY_EXPIRATION);
        } else {
          switch (priorityLevel) {
            case ImmediatePriority:
              expirationTime = Sync;
              break;

            case UserBlockingPriority:
              expirationTime = computeInteractiveExpiration(currentTime);
              break;

            case NormalPriority:
            case LowPriority:
              expirationTime = computeAsyncExpiration(currentTime);
              break;

            case IdlePriority:
              expirationTime = Never;
              break;

            default:
              (function () {
                {
                  throw ReactError(Error("Expected a valid priority level"));
                }
              })();

          }
        }

        if (workInProgressRoot !== null && expirationTime === renderExpirationTime) {
          expirationTime -= 1;
        }

        return expirationTime;
      }

      function scheduleUpdateOnFiber(fiber, expirationTime) {
        checkForNestedUpdates();
        warnAboutInvalidUpdatesOnClassComponentsInDEV(fiber);
        var root = markUpdateTimeFromFiberToRoot(fiber, expirationTime);

        if (root === null) {
          warnAboutUpdateOnUnmountedFiberInDEV(fiber);
          return;
        }

        root.pingTime = NoWork;
        checkForInterruption(fiber, expirationTime);
        recordScheduleUpdate();
        var priorityLevel = getCurrentPriorityLevel();

        if (expirationTime === Sync) {
          if ((executionContext & LegacyUnbatchedContext) !== NoContext && (executionContext & (RenderContext | CommitContext)) === NoContext) {
            schedulePendingInteractions(root, expirationTime);
            var callback = renderRoot(root, Sync, true);

            while (callback !== null) {
              callback = callback(true);
            }
          } else {
            scheduleCallbackForRoot(root, ImmediatePriority, Sync);

            if (executionContext === NoContext) {
              flushSyncCallbackQueue();
            }
          }
        } else {
          scheduleCallbackForRoot(root, priorityLevel, expirationTime);
        }

        if ((executionContext & DiscreteEventContext) !== NoContext && (priorityLevel === UserBlockingPriority || priorityLevel === ImmediatePriority)) {
          if (rootsWithPendingDiscreteUpdates === null) {
            rootsWithPendingDiscreteUpdates = new Map([[root, expirationTime]]);
          } else {
            var lastDiscreteTime = rootsWithPendingDiscreteUpdates.get(root);

            if (lastDiscreteTime === undefined || lastDiscreteTime > expirationTime) {
              rootsWithPendingDiscreteUpdates.set(root, expirationTime);
            }
          }
        }
      }

      var scheduleWork = scheduleUpdateOnFiber;

      function markUpdateTimeFromFiberToRoot(fiber, expirationTime) {
        if (fiber.expirationTime < expirationTime) {
          fiber.expirationTime = expirationTime;
        }

        var alternate = fiber.alternate;

        if (alternate !== null && alternate.expirationTime < expirationTime) {
          alternate.expirationTime = expirationTime;
        }

        var node = fiber.return;
        var root = null;

        if (node === null && fiber.tag === HostRoot) {
          root = fiber.stateNode;
        } else {
          while (node !== null) {
            alternate = node.alternate;

            if (node.childExpirationTime < expirationTime) {
              node.childExpirationTime = expirationTime;

              if (alternate !== null && alternate.childExpirationTime < expirationTime) {
                alternate.childExpirationTime = expirationTime;
              }
            } else if (alternate !== null && alternate.childExpirationTime < expirationTime) {
              alternate.childExpirationTime = expirationTime;
            }

            if (node.return === null && node.tag === HostRoot) {
              root = node.stateNode;
              break;
            }

            node = node.return;
          }
        }

        if (root !== null) {
          var firstPendingTime = root.firstPendingTime;

          if (expirationTime > firstPendingTime) {
            root.firstPendingTime = expirationTime;
          }

          var lastPendingTime = root.lastPendingTime;

          if (lastPendingTime === NoWork || expirationTime < lastPendingTime) {
            root.lastPendingTime = expirationTime;
          }
        }

        return root;
      }

      function scheduleCallbackForRoot(root, priorityLevel, expirationTime) {
        var existingCallbackExpirationTime = root.callbackExpirationTime;

        if (existingCallbackExpirationTime < expirationTime) {
          var existingCallbackNode = root.callbackNode;

          if (existingCallbackNode !== null) {
            cancelCallback(existingCallbackNode);
          }

          root.callbackExpirationTime = expirationTime;

          if (expirationTime === Sync) {
            root.callbackNode = scheduleSyncCallback(runRootCallback.bind(null, root, renderRoot.bind(null, root, expirationTime)));
          } else {
            var options = null;

            if (!disableSchedulerTimeoutBasedOnReactExpirationTime && expirationTime !== Never) {
              var timeout = expirationTimeToMs(expirationTime) - now();
              options = {
                timeout: timeout
              };
            }

            root.callbackNode = scheduleCallback(priorityLevel, runRootCallback.bind(null, root, renderRoot.bind(null, root, expirationTime)), options);

            if (enableUserTimingAPI && expirationTime !== Sync && (executionContext & (RenderContext | CommitContext)) === NoContext) {
              startRequestCallbackTimer();
            }
          }
        }

        schedulePendingInteractions(root, expirationTime);
      }

      function runRootCallback(root, callback, isSync) {
        var prevCallbackNode = root.callbackNode;
        var continuation = null;

        try {
          continuation = callback(isSync);

          if (continuation !== null) {
            return runRootCallback.bind(null, root, continuation);
          } else {
            return null;
          }
        } finally {
          if (continuation === null && prevCallbackNode === root.callbackNode) {
            root.callbackNode = null;
            root.callbackExpirationTime = NoWork;
          }
        }
      }

      function flushDiscreteUpdates() {
        if ((executionContext & (BatchedContext | RenderContext | CommitContext)) !== NoContext) {
          if (true && (executionContext & RenderContext) !== NoContext) {
            warning$1(false, "unstable_flushDiscreteUpdates: Cannot flush updates when React is " + "already rendering.");
          }

          return;
        }

        flushPendingDiscreteUpdates();

        if (!revertPassiveEffectsChange) {
          flushPassiveEffects();
        }
      }

      function resolveLocksOnRoot(root, expirationTime) {
        var firstBatch = root.firstBatch;

        if (firstBatch !== null && firstBatch._defer && firstBatch._expirationTime >= expirationTime) {
          scheduleCallback(NormalPriority, function () {
            firstBatch._onComplete();

            return null;
          });
          return true;
        } else {
          return false;
        }
      }

      function flushPendingDiscreteUpdates() {
        if (rootsWithPendingDiscreteUpdates !== null) {
          var roots = rootsWithPendingDiscreteUpdates;
          rootsWithPendingDiscreteUpdates = null;
          roots.forEach(function (expirationTime, root) {
            scheduleSyncCallback(renderRoot.bind(null, root, expirationTime));
          });
          flushSyncCallbackQueue();
        }
      }

      function batchedUpdates$1(fn, a) {
        var prevExecutionContext = executionContext;
        executionContext |= BatchedContext;

        try {
          return fn(a);
        } finally {
          executionContext = prevExecutionContext;

          if (executionContext === NoContext) {
            flushSyncCallbackQueue();
          }
        }
      }

      function batchedEventUpdates$1(fn, a) {
        var prevExecutionContext = executionContext;
        executionContext |= EventContext;

        try {
          return fn(a);
        } finally {
          executionContext = prevExecutionContext;

          if (executionContext === NoContext) {
            flushSyncCallbackQueue();
          }
        }
      }

      function discreteUpdates$1(fn, a, b, c) {
        var prevExecutionContext = executionContext;
        executionContext |= DiscreteEventContext;

        try {
          return runWithPriority(UserBlockingPriority, fn.bind(null, a, b, c));
        } finally {
          executionContext = prevExecutionContext;

          if (executionContext === NoContext) {
            flushSyncCallbackQueue();
          }
        }
      }

      function flushSync(fn, a) {
        if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
          (function () {
            {
              throw ReactError(Error("flushSync was called from inside a lifecycle method. It cannot be called when React is already rendering."));
            }
          })();
        }

        var prevExecutionContext = executionContext;
        executionContext |= BatchedContext;

        try {
          return runWithPriority(ImmediatePriority, fn.bind(null, a));
        } finally {
          executionContext = prevExecutionContext;
          flushSyncCallbackQueue();
        }
      }

      function prepareFreshStack(root, expirationTime) {
        root.finishedWork = null;
        root.finishedExpirationTime = NoWork;
        var timeoutHandle = root.timeoutHandle;

        if (timeoutHandle !== noTimeout) {
          root.timeoutHandle = noTimeout;
          cancelTimeout(timeoutHandle);
        }

        if (workInProgress !== null) {
          var interruptedWork = workInProgress.return;

          while (interruptedWork !== null) {
            unwindInterruptedWork(interruptedWork);
            interruptedWork = interruptedWork.return;
          }
        }

        workInProgressRoot = root;
        workInProgress = createWorkInProgress(root.current, null, expirationTime);
        renderExpirationTime = expirationTime;
        workInProgressRootExitStatus = RootIncomplete;
        workInProgressRootLatestProcessedExpirationTime = Sync;
        workInProgressRootLatestSuspenseTimeout = Sync;
        workInProgressRootCanSuspendUsingConfig = null;
        workInProgressRootHasPendingPing = false;

        if (enableSchedulerTracing) {
          spawnedWorkDuringRender = null;
        }

        {
          ReactStrictModeWarnings.discardPendingWarnings();
          componentsThatTriggeredHighPriSuspend = null;
        }
      }

      function renderRoot(root, expirationTime, isSync) {
        (function () {
          if (!((executionContext & (RenderContext | CommitContext)) === NoContext)) {
            throw ReactError(Error("Should not already be working."));
          }
        })();

        if (enableUserTimingAPI && expirationTime !== Sync) {
          var didExpire = isSync;
          stopRequestCallbackTimer(didExpire);
        }

        if (root.firstPendingTime < expirationTime) {
          return null;
        }

        if (isSync && root.finishedExpirationTime === expirationTime) {
          return commitRoot.bind(null, root);
        }

        flushPassiveEffects();

        if (root !== workInProgressRoot || expirationTime !== renderExpirationTime) {
          prepareFreshStack(root, expirationTime);
          startWorkOnPendingInteractions(root, expirationTime);
        } else if (workInProgressRootExitStatus === RootSuspendedWithDelay) {
          if (workInProgressRootHasPendingPing) {
            prepareFreshStack(root, expirationTime);
          } else {
            var lastPendingTime = root.lastPendingTime;

            if (lastPendingTime < expirationTime) {
              return renderRoot.bind(null, root, lastPendingTime);
            }
          }
        }

        if (workInProgress !== null) {
          var prevExecutionContext = executionContext;
          executionContext |= RenderContext;
          var prevDispatcher = ReactCurrentDispatcher.current;

          if (prevDispatcher === null) {
            prevDispatcher = ContextOnlyDispatcher;
          }

          ReactCurrentDispatcher.current = ContextOnlyDispatcher;
          var prevInteractions = null;

          if (enableSchedulerTracing) {
            prevInteractions = tracing.__interactionsRef.current;
            tracing.__interactionsRef.current = root.memoizedInteractions;
          }

          startWorkLoopTimer(workInProgress);

          if (isSync) {
            if (expirationTime !== Sync) {
              var currentTime = requestCurrentTime();

              if (currentTime < expirationTime) {
                executionContext = prevExecutionContext;
                resetContextDependencies();
                ReactCurrentDispatcher.current = prevDispatcher;

                if (enableSchedulerTracing) {
                  tracing.__interactionsRef.current = prevInteractions;
                }

                return renderRoot.bind(null, root, currentTime);
              }
            }
          } else {
            currentEventTime = NoWork;
          }

          do {
            try {
              if (isSync) {
                workLoopSync();
              } else {
                workLoop();
              }

              break;
            } catch (thrownValue) {
              resetContextDependencies();
              resetHooks();
              var sourceFiber = workInProgress;

              if (sourceFiber === null || sourceFiber.return === null) {
                prepareFreshStack(root, expirationTime);
                executionContext = prevExecutionContext;
                throw thrownValue;
              }

              if (enableProfilerTimer && sourceFiber.mode & ProfileMode) {
                stopProfilerTimerIfRunningAndRecordDelta(sourceFiber, true);
              }

              var returnFiber = sourceFiber.return;
              throwException(root, returnFiber, sourceFiber, thrownValue, renderExpirationTime);
              workInProgress = completeUnitOfWork(sourceFiber);
            }
          } while (true);

          executionContext = prevExecutionContext;
          resetContextDependencies();
          ReactCurrentDispatcher.current = prevDispatcher;

          if (enableSchedulerTracing) {
            tracing.__interactionsRef.current = prevInteractions;
          }

          if (workInProgress !== null) {
            stopInterruptedWorkLoopTimer();

            if (expirationTime !== Sync) {
              startRequestCallbackTimer();
            }

            return renderRoot.bind(null, root, expirationTime);
          }
        }

        stopFinishedWorkLoopTimer();
        root.finishedWork = root.current.alternate;
        root.finishedExpirationTime = expirationTime;
        var isLocked = resolveLocksOnRoot(root, expirationTime);

        if (isLocked) {
          return null;
        }

        workInProgressRoot = null;

        switch (workInProgressRootExitStatus) {
          case RootIncomplete:
            {
              (function () {
                {
                  throw ReactError(Error("Should have a work-in-progress."));
                }
              })();
            }

          case RootErrored:
            {
              var _lastPendingTime = root.lastPendingTime;

              if (_lastPendingTime < expirationTime) {
                return renderRoot.bind(null, root, _lastPendingTime);
              }

              if (!isSync) {
                prepareFreshStack(root, expirationTime);
                scheduleSyncCallback(renderRoot.bind(null, root, expirationTime));
                return null;
              }

              return commitRoot.bind(null, root);
            }

          case RootSuspended:
            {
              flushSuspensePriorityWarningInDEV();
              var hasNotProcessedNewUpdates = workInProgressRootLatestProcessedExpirationTime === Sync;

              if (hasNotProcessedNewUpdates && !isSync && !(true && flushSuspenseFallbacksInTests && IsThisRendererActing.current)) {
                var msUntilTimeout = globalMostRecentFallbackTime + FALLBACK_THROTTLE_MS - now();

                if (msUntilTimeout > 10) {
                  if (workInProgressRootHasPendingPing) {
                    prepareFreshStack(root, expirationTime);
                    return renderRoot.bind(null, root, expirationTime);
                  }

                  var _lastPendingTime2 = root.lastPendingTime;

                  if (_lastPendingTime2 < expirationTime) {
                    return renderRoot.bind(null, root, _lastPendingTime2);
                  }

                  root.timeoutHandle = scheduleTimeout(commitRoot.bind(null, root), msUntilTimeout);
                  return null;
                }
              }

              return commitRoot.bind(null, root);
            }

          case RootSuspendedWithDelay:
            {
              flushSuspensePriorityWarningInDEV();

              if (!isSync && !(true && flushSuspenseFallbacksInTests && IsThisRendererActing.current)) {
                if (workInProgressRootHasPendingPing) {
                  prepareFreshStack(root, expirationTime);
                  return renderRoot.bind(null, root, expirationTime);
                }

                var _lastPendingTime3 = root.lastPendingTime;

                if (_lastPendingTime3 < expirationTime) {
                  return renderRoot.bind(null, root, _lastPendingTime3);
                }

                var _msUntilTimeout = void 0;

                if (workInProgressRootLatestSuspenseTimeout !== Sync) {
                  _msUntilTimeout = expirationTimeToMs(workInProgressRootLatestSuspenseTimeout) - now();
                } else if (workInProgressRootLatestProcessedExpirationTime === Sync) {
                  _msUntilTimeout = 0;
                } else {
                  var eventTimeMs = inferTimeFromExpirationTime(workInProgressRootLatestProcessedExpirationTime);
                  var currentTimeMs = now();
                  var timeUntilExpirationMs = expirationTimeToMs(expirationTime) - currentTimeMs;
                  var timeElapsed = currentTimeMs - eventTimeMs;

                  if (timeElapsed < 0) {
                    timeElapsed = 0;
                  }

                  _msUntilTimeout = jnd(timeElapsed) - timeElapsed;

                  if (timeUntilExpirationMs < _msUntilTimeout) {
                    _msUntilTimeout = timeUntilExpirationMs;
                  }
                }

                if (_msUntilTimeout > 10) {
                  root.timeoutHandle = scheduleTimeout(commitRoot.bind(null, root), _msUntilTimeout);
                  return null;
                }
              }

              return commitRoot.bind(null, root);
            }

          case RootCompleted:
            {
              if (!isSync && !(true && flushSuspenseFallbacksInTests && IsThisRendererActing.current) && workInProgressRootLatestProcessedExpirationTime !== Sync && workInProgressRootCanSuspendUsingConfig !== null) {
                var _msUntilTimeout2 = computeMsUntilSuspenseLoadingDelay(workInProgressRootLatestProcessedExpirationTime, expirationTime, workInProgressRootCanSuspendUsingConfig);

                if (_msUntilTimeout2 > 10) {
                  root.timeoutHandle = scheduleTimeout(commitRoot.bind(null, root), _msUntilTimeout2);
                  return null;
                }
              }

              return commitRoot.bind(null, root);
            }

          default:
            {
              (function () {
                {
                  throw ReactError(Error("Unknown root exit status."));
                }
              })();
            }
        }
      }

      function markCommitTimeOfFallback() {
        globalMostRecentFallbackTime = now();
      }

      function markRenderEventTimeAndConfig(expirationTime, suspenseConfig) {
        if (expirationTime < workInProgressRootLatestProcessedExpirationTime && expirationTime > Never) {
          workInProgressRootLatestProcessedExpirationTime = expirationTime;
        }

        if (suspenseConfig !== null) {
          if (expirationTime < workInProgressRootLatestSuspenseTimeout && expirationTime > Never) {
            workInProgressRootLatestSuspenseTimeout = expirationTime;
            workInProgressRootCanSuspendUsingConfig = suspenseConfig;
          }
        }
      }

      function renderDidSuspend() {
        if (workInProgressRootExitStatus === RootIncomplete) {
          workInProgressRootExitStatus = RootSuspended;
        }
      }

      function renderDidSuspendDelayIfPossible() {
        if (workInProgressRootExitStatus === RootIncomplete || workInProgressRootExitStatus === RootSuspended) {
          workInProgressRootExitStatus = RootSuspendedWithDelay;
        }
      }

      function renderDidError() {
        if (workInProgressRootExitStatus !== RootCompleted) {
          workInProgressRootExitStatus = RootErrored;
        }
      }

      function renderHasNotSuspendedYet() {
        return workInProgressRootExitStatus === RootIncomplete;
      }

      function inferTimeFromExpirationTime(expirationTime) {
        var earliestExpirationTimeMs = expirationTimeToMs(expirationTime);
        return earliestExpirationTimeMs - LOW_PRIORITY_EXPIRATION;
      }

      function inferTimeFromExpirationTimeWithSuspenseConfig(expirationTime, suspenseConfig) {
        var earliestExpirationTimeMs = expirationTimeToMs(expirationTime);
        return earliestExpirationTimeMs - (suspenseConfig.timeoutMs | 0 || LOW_PRIORITY_EXPIRATION);
      }

      function workLoopSync() {
        while (workInProgress !== null) {
          workInProgress = performUnitOfWork(workInProgress);
        }
      }

      function workLoop() {
        while (workInProgress !== null && !shouldYield()) {
          workInProgress = performUnitOfWork(workInProgress);
        }
      }

      function performUnitOfWork(unitOfWork) {
        var current$$1 = unitOfWork.alternate;
        startWorkTimer(unitOfWork);
        setCurrentFiber(unitOfWork);
        var next = void 0;

        if (enableProfilerTimer && (unitOfWork.mode & ProfileMode) !== NoMode) {
          startProfilerTimer(unitOfWork);
          next = beginWork$$1(current$$1, unitOfWork, renderExpirationTime);
          stopProfilerTimerIfRunningAndRecordDelta(unitOfWork, true);
        } else {
          next = beginWork$$1(current$$1, unitOfWork, renderExpirationTime);
        }

        resetCurrentFiber();
        unitOfWork.memoizedProps = unitOfWork.pendingProps;

        if (next === null) {
          next = completeUnitOfWork(unitOfWork);
        }

        ReactCurrentOwner$2.current = null;
        return next;
      }

      function completeUnitOfWork(unitOfWork) {
        workInProgress = unitOfWork;

        do {
          var current$$1 = workInProgress.alternate;
          var returnFiber = workInProgress.return;

          if ((workInProgress.effectTag & Incomplete) === NoEffect) {
            setCurrentFiber(workInProgress);
            var next = void 0;

            if (!enableProfilerTimer || (workInProgress.mode & ProfileMode) === NoMode) {
              next = completeWork(current$$1, workInProgress, renderExpirationTime);
            } else {
              startProfilerTimer(workInProgress);
              next = completeWork(current$$1, workInProgress, renderExpirationTime);
              stopProfilerTimerIfRunningAndRecordDelta(workInProgress, false);
            }

            stopWorkTimer(workInProgress);
            resetCurrentFiber();
            resetChildExpirationTime(workInProgress);

            if (next !== null) {
              return next;
            }

            if (returnFiber !== null && (returnFiber.effectTag & Incomplete) === NoEffect) {
              if (returnFiber.firstEffect === null) {
                returnFiber.firstEffect = workInProgress.firstEffect;
              }

              if (workInProgress.lastEffect !== null) {
                if (returnFiber.lastEffect !== null) {
                  returnFiber.lastEffect.nextEffect = workInProgress.firstEffect;
                }

                returnFiber.lastEffect = workInProgress.lastEffect;
              }

              var effectTag = workInProgress.effectTag;

              if (effectTag > PerformedWork) {
                if (returnFiber.lastEffect !== null) {
                  returnFiber.lastEffect.nextEffect = workInProgress;
                } else {
                  returnFiber.firstEffect = workInProgress;
                }

                returnFiber.lastEffect = workInProgress;
              }
            }
          } else {
            var _next = unwindWork(workInProgress, renderExpirationTime);

            if (enableProfilerTimer && (workInProgress.mode & ProfileMode) !== NoMode) {
              stopProfilerTimerIfRunningAndRecordDelta(workInProgress, false);
              var actualDuration = workInProgress.actualDuration;
              var child = workInProgress.child;

              while (child !== null) {
                actualDuration += child.actualDuration;
                child = child.sibling;
              }

              workInProgress.actualDuration = actualDuration;
            }

            if (_next !== null) {
              stopFailedWorkTimer(workInProgress);
              _next.effectTag &= HostEffectMask;
              return _next;
            }

            stopWorkTimer(workInProgress);

            if (returnFiber !== null) {
              returnFiber.firstEffect = returnFiber.lastEffect = null;
              returnFiber.effectTag |= Incomplete;
            }
          }

          var siblingFiber = workInProgress.sibling;

          if (siblingFiber !== null) {
            return siblingFiber;
          }

          workInProgress = returnFiber;
        } while (workInProgress !== null);

        if (workInProgressRootExitStatus === RootIncomplete) {
          workInProgressRootExitStatus = RootCompleted;
        }

        return null;
      }

      function resetChildExpirationTime(completedWork) {
        if (renderExpirationTime !== Never && completedWork.childExpirationTime === Never) {
          return;
        }

        var newChildExpirationTime = NoWork;

        if (enableProfilerTimer && (completedWork.mode & ProfileMode) !== NoMode) {
          var actualDuration = completedWork.actualDuration;
          var treeBaseDuration = completedWork.selfBaseDuration;
          var shouldBubbleActualDurations = completedWork.alternate === null || completedWork.child !== completedWork.alternate.child;
          var child = completedWork.child;

          while (child !== null) {
            var childUpdateExpirationTime = child.expirationTime;
            var childChildExpirationTime = child.childExpirationTime;

            if (childUpdateExpirationTime > newChildExpirationTime) {
              newChildExpirationTime = childUpdateExpirationTime;
            }

            if (childChildExpirationTime > newChildExpirationTime) {
              newChildExpirationTime = childChildExpirationTime;
            }

            if (shouldBubbleActualDurations) {
              actualDuration += child.actualDuration;
            }

            treeBaseDuration += child.treeBaseDuration;
            child = child.sibling;
          }

          completedWork.actualDuration = actualDuration;
          completedWork.treeBaseDuration = treeBaseDuration;
        } else {
          var _child = completedWork.child;

          while (_child !== null) {
            var _childUpdateExpirationTime = _child.expirationTime;
            var _childChildExpirationTime = _child.childExpirationTime;

            if (_childUpdateExpirationTime > newChildExpirationTime) {
              newChildExpirationTime = _childUpdateExpirationTime;
            }

            if (_childChildExpirationTime > newChildExpirationTime) {
              newChildExpirationTime = _childChildExpirationTime;
            }

            _child = _child.sibling;
          }
        }

        completedWork.childExpirationTime = newChildExpirationTime;
      }

      function commitRoot(root) {
        var renderPriorityLevel = getCurrentPriorityLevel();
        runWithPriority(ImmediatePriority, commitRootImpl.bind(null, root, renderPriorityLevel));

        if (rootWithPendingPassiveEffects !== null) {
          scheduleCallback(NormalPriority, function () {
            flushPassiveEffects();
            return null;
          });
        }

        return null;
      }

      function commitRootImpl(root, renderPriorityLevel) {
        flushPassiveEffects();
        flushRenderPhaseStrictModeWarningsInDEV();

        (function () {
          if (!((executionContext & (RenderContext | CommitContext)) === NoContext)) {
            throw ReactError(Error("Should not already be working."));
          }
        })();

        var finishedWork = root.finishedWork;
        var expirationTime = root.finishedExpirationTime;

        if (finishedWork === null) {
          return null;
        }

        root.finishedWork = null;
        root.finishedExpirationTime = NoWork;

        (function () {
          if (!(finishedWork !== root.current)) {
            throw ReactError(Error("Cannot commit the same tree as before. This error is likely caused by a bug in React. Please file an issue."));
          }
        })();

        root.callbackNode = null;
        root.callbackExpirationTime = NoWork;
        startCommitTimer();
        var updateExpirationTimeBeforeCommit = finishedWork.expirationTime;
        var childExpirationTimeBeforeCommit = finishedWork.childExpirationTime;
        var firstPendingTimeBeforeCommit = childExpirationTimeBeforeCommit > updateExpirationTimeBeforeCommit ? childExpirationTimeBeforeCommit : updateExpirationTimeBeforeCommit;
        root.firstPendingTime = firstPendingTimeBeforeCommit;

        if (firstPendingTimeBeforeCommit < root.lastPendingTime) {
          root.lastPendingTime = firstPendingTimeBeforeCommit;
        }

        if (root === workInProgressRoot) {
          workInProgressRoot = null;
          workInProgress = null;
          renderExpirationTime = NoWork;
        } else {}

        var firstEffect = void 0;

        if (finishedWork.effectTag > PerformedWork) {
          if (finishedWork.lastEffect !== null) {
            finishedWork.lastEffect.nextEffect = finishedWork;
            firstEffect = finishedWork.firstEffect;
          } else {
            firstEffect = finishedWork;
          }
        } else {
          firstEffect = finishedWork.firstEffect;
        }

        if (firstEffect !== null) {
          var prevExecutionContext = executionContext;
          executionContext |= CommitContext;
          var prevInteractions = null;

          if (enableSchedulerTracing) {
            prevInteractions = tracing.__interactionsRef.current;
            tracing.__interactionsRef.current = root.memoizedInteractions;
          }

          ReactCurrentOwner$2.current = null;
          startCommitSnapshotEffectsTimer();
          prepareForCommit(root.containerInfo);
          nextEffect = firstEffect;

          do {
            {
              invokeGuardedCallback(null, commitBeforeMutationEffects, null);

              if (hasCaughtError()) {
                (function () {
                  if (!(nextEffect !== null)) {
                    throw ReactError(Error("Should be working on an effect."));
                  }
                })();

                var error = clearCaughtError();
                captureCommitPhaseError(nextEffect, error);
                nextEffect = nextEffect.nextEffect;
              }
            }
          } while (nextEffect !== null);

          stopCommitSnapshotEffectsTimer();

          if (enableProfilerTimer) {
            recordCommitTime();
          }

          startCommitHostEffectsTimer();
          nextEffect = firstEffect;

          do {
            {
              invokeGuardedCallback(null, commitMutationEffects, null, renderPriorityLevel);

              if (hasCaughtError()) {
                (function () {
                  if (!(nextEffect !== null)) {
                    throw ReactError(Error("Should be working on an effect."));
                  }
                })();

                var _error = clearCaughtError();

                captureCommitPhaseError(nextEffect, _error);
                nextEffect = nextEffect.nextEffect;
              }
            }
          } while (nextEffect !== null);

          stopCommitHostEffectsTimer();
          resetAfterCommit(root.containerInfo);
          root.current = finishedWork;
          startCommitLifeCyclesTimer();
          nextEffect = firstEffect;

          do {
            {
              invokeGuardedCallback(null, commitLayoutEffects, null, root, expirationTime);

              if (hasCaughtError()) {
                (function () {
                  if (!(nextEffect !== null)) {
                    throw ReactError(Error("Should be working on an effect."));
                  }
                })();

                var _error2 = clearCaughtError();

                captureCommitPhaseError(nextEffect, _error2);
                nextEffect = nextEffect.nextEffect;
              }
            }
          } while (nextEffect !== null);

          stopCommitLifeCyclesTimer();
          nextEffect = null;
          requestPaint();

          if (enableSchedulerTracing) {
            tracing.__interactionsRef.current = prevInteractions;
          }

          executionContext = prevExecutionContext;
        } else {
          root.current = finishedWork;
          startCommitSnapshotEffectsTimer();
          stopCommitSnapshotEffectsTimer();

          if (enableProfilerTimer) {
            recordCommitTime();
          }

          startCommitHostEffectsTimer();
          stopCommitHostEffectsTimer();
          startCommitLifeCyclesTimer();
          stopCommitLifeCyclesTimer();
        }

        stopCommitTimer();
        var rootDidHavePassiveEffects = rootDoesHavePassiveEffects;

        if (rootDoesHavePassiveEffects) {
          rootDoesHavePassiveEffects = false;
          rootWithPendingPassiveEffects = root;
          pendingPassiveEffectsExpirationTime = expirationTime;
          pendingPassiveEffectsRenderPriority = renderPriorityLevel;
        } else {
          nextEffect = firstEffect;

          while (nextEffect !== null) {
            var nextNextEffect = nextEffect.nextEffect;
            nextEffect.nextEffect = null;
            nextEffect = nextNextEffect;
          }
        }

        var remainingExpirationTime = root.firstPendingTime;

        if (remainingExpirationTime !== NoWork) {
          var currentTime = requestCurrentTime();
          var priorityLevel = inferPriorityFromExpirationTime(currentTime, remainingExpirationTime);

          if (enableSchedulerTracing) {
            if (spawnedWorkDuringRender !== null) {
              var expirationTimes = spawnedWorkDuringRender;
              spawnedWorkDuringRender = null;

              for (var i = 0; i < expirationTimes.length; i++) {
                scheduleInteractions(root, expirationTimes[i], root.memoizedInteractions);
              }
            }
          }

          scheduleCallbackForRoot(root, priorityLevel, remainingExpirationTime);
        } else {
          legacyErrorBoundariesThatAlreadyFailed = null;
        }

        if (enableSchedulerTracing) {
          if (!rootDidHavePassiveEffects) {
            finishPendingInteractions(root, expirationTime);
          }
        }

        onCommitRoot(finishedWork.stateNode, expirationTime);

        if (remainingExpirationTime === Sync) {
          if (root === rootWithNestedUpdates) {
            nestedUpdateCount++;
          } else {
            nestedUpdateCount = 0;
            rootWithNestedUpdates = root;
          }
        } else {
          nestedUpdateCount = 0;
        }

        if (hasUncaughtError) {
          hasUncaughtError = false;
          var _error3 = firstUncaughtError;
          firstUncaughtError = null;
          throw _error3;
        }

        if ((executionContext & LegacyUnbatchedContext) !== NoContext) {
          return null;
        }

        flushSyncCallbackQueue();
        return null;
      }

      function commitBeforeMutationEffects() {
        while (nextEffect !== null) {
          if ((nextEffect.effectTag & Snapshot) !== NoEffect) {
            setCurrentFiber(nextEffect);
            recordEffect();
            var current$$1 = nextEffect.alternate;
            commitBeforeMutationLifeCycles(current$$1, nextEffect);
            resetCurrentFiber();
          }

          nextEffect = nextEffect.nextEffect;
        }
      }

      function commitMutationEffects(renderPriorityLevel) {
        while (nextEffect !== null) {
          setCurrentFiber(nextEffect);
          var effectTag = nextEffect.effectTag;

          if (effectTag & ContentReset) {
            commitResetTextContent(nextEffect);
          }

          if (effectTag & Ref) {
            var current$$1 = nextEffect.alternate;

            if (current$$1 !== null) {
              commitDetachRef(current$$1);
            }
          }

          var primaryEffectTag = effectTag & (Placement | Update | Deletion);

          switch (primaryEffectTag) {
            case Placement:
              {
                commitPlacement(nextEffect);
                nextEffect.effectTag &= ~Placement;
                break;
              }

            case PlacementAndUpdate:
              {
                commitPlacement(nextEffect);
                nextEffect.effectTag &= ~Placement;
                var _current = nextEffect.alternate;
                commitWork(_current, nextEffect);
                break;
              }

            case Update:
              {
                var _current2 = nextEffect.alternate;
                commitWork(_current2, nextEffect);
                break;
              }

            case Deletion:
              {
                commitDeletion(nextEffect, renderPriorityLevel);
                break;
              }
          }

          recordEffect();
          resetCurrentFiber();
          nextEffect = nextEffect.nextEffect;
        }
      }

      function commitLayoutEffects(root, committedExpirationTime) {
        while (nextEffect !== null) {
          setCurrentFiber(nextEffect);
          var effectTag = nextEffect.effectTag;

          if (effectTag & (Update | Callback)) {
            recordEffect();
            var current$$1 = nextEffect.alternate;
            commitLifeCycles(root, current$$1, nextEffect, committedExpirationTime);
          }

          if (effectTag & Ref) {
            recordEffect();
            commitAttachRef(nextEffect);
          }

          if (effectTag & Passive) {
            rootDoesHavePassiveEffects = true;
          }

          resetCurrentFiber();
          nextEffect = nextEffect.nextEffect;
        }
      }

      function flushPassiveEffects() {
        if (rootWithPendingPassiveEffects === null) {
          return false;
        }

        var root = rootWithPendingPassiveEffects;
        var expirationTime = pendingPassiveEffectsExpirationTime;
        var renderPriorityLevel = pendingPassiveEffectsRenderPriority;
        rootWithPendingPassiveEffects = null;
        pendingPassiveEffectsExpirationTime = NoWork;
        pendingPassiveEffectsRenderPriority = NoPriority;
        var priorityLevel = renderPriorityLevel > NormalPriority ? NormalPriority : renderPriorityLevel;
        return runWithPriority(priorityLevel, flushPassiveEffectsImpl.bind(null, root, expirationTime));
      }

      function flushPassiveEffectsImpl(root, expirationTime) {
        var prevInteractions = null;

        if (enableSchedulerTracing) {
          prevInteractions = tracing.__interactionsRef.current;
          tracing.__interactionsRef.current = root.memoizedInteractions;
        }

        (function () {
          if (!((executionContext & (RenderContext | CommitContext)) === NoContext)) {
            throw ReactError(Error("Cannot flush passive effects while already rendering."));
          }
        })();

        var prevExecutionContext = executionContext;
        executionContext |= CommitContext;
        var effect = root.current.firstEffect;

        while (effect !== null) {
          {
            setCurrentFiber(effect);
            invokeGuardedCallback(null, commitPassiveHookEffects, null, effect);

            if (hasCaughtError()) {
              (function () {
                if (!(effect !== null)) {
                  throw ReactError(Error("Should be working on an effect."));
                }
              })();

              var error = clearCaughtError();
              captureCommitPhaseError(effect, error);
            }

            resetCurrentFiber();
          }
          var nextNextEffect = effect.nextEffect;
          effect.nextEffect = null;
          effect = nextNextEffect;
        }

        if (enableSchedulerTracing) {
          tracing.__interactionsRef.current = prevInteractions;
          finishPendingInteractions(root, expirationTime);
        }

        executionContext = prevExecutionContext;
        flushSyncCallbackQueue();
        nestedPassiveUpdateCount = rootWithPendingPassiveEffects === null ? 0 : nestedPassiveUpdateCount + 1;
        return true;
      }

      function isAlreadyFailedLegacyErrorBoundary(instance) {
        return legacyErrorBoundariesThatAlreadyFailed !== null && legacyErrorBoundariesThatAlreadyFailed.has(instance);
      }

      function markLegacyErrorBoundaryAsFailed(instance) {
        if (legacyErrorBoundariesThatAlreadyFailed === null) {
          legacyErrorBoundariesThatAlreadyFailed = new Set([instance]);
        } else {
          legacyErrorBoundariesThatAlreadyFailed.add(instance);
        }
      }

      function prepareToThrowUncaughtError(error) {
        if (!hasUncaughtError) {
          hasUncaughtError = true;
          firstUncaughtError = error;
        }
      }

      var onUncaughtError = prepareToThrowUncaughtError;

      function captureCommitPhaseErrorOnRoot(rootFiber, sourceFiber, error) {
        var errorInfo = createCapturedValue(error, sourceFiber);
        var update = createRootErrorUpdate(rootFiber, errorInfo, Sync);
        enqueueUpdate(rootFiber, update);
        var root = markUpdateTimeFromFiberToRoot(rootFiber, Sync);

        if (root !== null) {
          scheduleCallbackForRoot(root, ImmediatePriority, Sync);
        }
      }

      function captureCommitPhaseError(sourceFiber, error) {
        if (sourceFiber.tag === HostRoot) {
          captureCommitPhaseErrorOnRoot(sourceFiber, sourceFiber, error);
          return;
        }

        var fiber = sourceFiber.return;

        while (fiber !== null) {
          if (fiber.tag === HostRoot) {
            captureCommitPhaseErrorOnRoot(fiber, sourceFiber, error);
            return;
          } else if (fiber.tag === ClassComponent) {
            var ctor = fiber.type;
            var instance = fiber.stateNode;

            if (typeof ctor.getDerivedStateFromError === "function" || typeof instance.componentDidCatch === "function" && !isAlreadyFailedLegacyErrorBoundary(instance)) {
              var errorInfo = createCapturedValue(error, sourceFiber);
              var update = createClassErrorUpdate(fiber, errorInfo, Sync);
              enqueueUpdate(fiber, update);
              var root = markUpdateTimeFromFiberToRoot(fiber, Sync);

              if (root !== null) {
                scheduleCallbackForRoot(root, ImmediatePriority, Sync);
              }

              return;
            }
          }

          fiber = fiber.return;
        }
      }

      function pingSuspendedRoot(root, thenable, suspendedTime) {
        var pingCache = root.pingCache;

        if (pingCache !== null) {
          pingCache.delete(thenable);
        }

        if (workInProgressRoot === root && renderExpirationTime === suspendedTime) {
          if (workInProgressRootExitStatus === RootSuspendedWithDelay || workInProgressRootExitStatus === RootSuspended && workInProgressRootLatestProcessedExpirationTime === Sync && now() - globalMostRecentFallbackTime < FALLBACK_THROTTLE_MS) {
            prepareFreshStack(root, renderExpirationTime);
          } else {
            workInProgressRootHasPendingPing = true;
          }

          return;
        }

        var lastPendingTime = root.lastPendingTime;

        if (lastPendingTime < suspendedTime) {
          return;
        }

        var pingTime = root.pingTime;

        if (pingTime !== NoWork && pingTime < suspendedTime) {
          return;
        }

        root.pingTime = suspendedTime;

        if (root.finishedExpirationTime === suspendedTime) {
          root.finishedExpirationTime = NoWork;
          root.finishedWork = null;
        }

        var currentTime = requestCurrentTime();
        var priorityLevel = inferPriorityFromExpirationTime(currentTime, suspendedTime);
        scheduleCallbackForRoot(root, priorityLevel, suspendedTime);
      }

      function retryTimedOutBoundary(boundaryFiber) {
        var currentTime = requestCurrentTime();
        var suspenseConfig = null;
        var retryTime = computeExpirationForFiber(currentTime, boundaryFiber, suspenseConfig);
        var priorityLevel = inferPriorityFromExpirationTime(currentTime, retryTime);
        var root = markUpdateTimeFromFiberToRoot(boundaryFiber, retryTime);

        if (root !== null) {
          scheduleCallbackForRoot(root, priorityLevel, retryTime);
        }
      }

      function resolveRetryThenable(boundaryFiber, thenable) {
        var retryCache = void 0;

        if (enableSuspenseServerRenderer) {
          switch (boundaryFiber.tag) {
            case SuspenseComponent:
              retryCache = boundaryFiber.stateNode;
              break;

            case DehydratedSuspenseComponent:
              retryCache = boundaryFiber.memoizedState;
              break;

            default:
              (function () {
                {
                  throw ReactError(Error("Pinged unknown suspense boundary type. This is probably a bug in React."));
                }
              })();

          }
        } else {
          retryCache = boundaryFiber.stateNode;
        }

        if (retryCache !== null) {
          retryCache.delete(thenable);
        }

        retryTimedOutBoundary(boundaryFiber);
      }

      function jnd(timeElapsed) {
        return timeElapsed < 120 ? 120 : timeElapsed < 480 ? 480 : timeElapsed < 1080 ? 1080 : timeElapsed < 1920 ? 1920 : timeElapsed < 3000 ? 3000 : timeElapsed < 4320 ? 4320 : ceil(timeElapsed / 1960) * 1960;
      }

      function computeMsUntilSuspenseLoadingDelay(mostRecentEventTime, committedExpirationTime, suspenseConfig) {
        var busyMinDurationMs = suspenseConfig.busyMinDurationMs | 0;

        if (busyMinDurationMs <= 0) {
          return 0;
        }

        var busyDelayMs = suspenseConfig.busyDelayMs | 0;
        var currentTimeMs = now();
        var eventTimeMs = inferTimeFromExpirationTimeWithSuspenseConfig(mostRecentEventTime, suspenseConfig);
        var timeElapsed = currentTimeMs - eventTimeMs;

        if (timeElapsed <= busyDelayMs) {
          return 0;
        }

        var msUntilTimeout = busyDelayMs + busyMinDurationMs - timeElapsed;
        return msUntilTimeout;
      }

      function checkForNestedUpdates() {
        if (nestedUpdateCount > NESTED_UPDATE_LIMIT) {
          nestedUpdateCount = 0;
          rootWithNestedUpdates = null;

          (function () {
            {
              throw ReactError(Error("Maximum update depth exceeded. This can happen when a component repeatedly calls setState inside componentWillUpdate or componentDidUpdate. React limits the number of nested updates to prevent infinite loops."));
            }
          })();
        }

        {
          if (nestedPassiveUpdateCount > NESTED_PASSIVE_UPDATE_LIMIT) {
            nestedPassiveUpdateCount = 0;
            warning$1(false, "Maximum update depth exceeded. This can happen when a component " + "calls setState inside useEffect, but useEffect either doesn't " + "have a dependency array, or one of the dependencies changes on " + "every render.");
          }
        }
      }

      function flushRenderPhaseStrictModeWarningsInDEV() {
        {
          ReactStrictModeWarnings.flushLegacyContextWarning();

          if (warnAboutDeprecatedLifecycles) {
            ReactStrictModeWarnings.flushPendingUnsafeLifecycleWarnings();
          }
        }
      }

      function stopFinishedWorkLoopTimer() {
        var didCompleteRoot = true;
        stopWorkLoopTimer(interruptedBy, didCompleteRoot);
        interruptedBy = null;
      }

      function stopInterruptedWorkLoopTimer() {
        var didCompleteRoot = false;
        stopWorkLoopTimer(interruptedBy, didCompleteRoot);
        interruptedBy = null;
      }

      function checkForInterruption(fiberThatReceivedUpdate, updateExpirationTime) {
        if (enableUserTimingAPI && workInProgressRoot !== null && updateExpirationTime > renderExpirationTime) {
          interruptedBy = fiberThatReceivedUpdate;
        }
      }

      var didWarnStateUpdateForUnmountedComponent = null;

      function warnAboutUpdateOnUnmountedFiberInDEV(fiber) {
        {
          var tag = fiber.tag;

          if (tag !== HostRoot && tag !== ClassComponent && tag !== FunctionComponent && tag !== ForwardRef && tag !== MemoComponent && tag !== SimpleMemoComponent) {
            return;
          }

          var componentName = getComponentName(fiber.type) || "ReactComponent";

          if (didWarnStateUpdateForUnmountedComponent !== null) {
            if (didWarnStateUpdateForUnmountedComponent.has(componentName)) {
              return;
            }

            didWarnStateUpdateForUnmountedComponent.add(componentName);
          } else {
            didWarnStateUpdateForUnmountedComponent = new Set([componentName]);
          }

          warningWithoutStack$1(false, "Can't perform a React state update on an unmounted component. This " + "is a no-op, but it indicates a memory leak in your application. To " + "fix, cancel all subscriptions and asynchronous tasks in %s.%s", tag === ClassComponent ? "the componentWillUnmount method" : "a useEffect cleanup function", getStackByFiberInDevAndProd(fiber));
        }
      }

      var beginWork$$1 = void 0;

      if (true && replayFailedUnitOfWorkWithInvokeGuardedCallback) {
        var dummyFiber = null;

        beginWork$$1 = function beginWork$$1(current$$1, unitOfWork, expirationTime) {
          var originalWorkInProgressCopy = assignFiberPropertiesInDEV(dummyFiber, unitOfWork);

          try {
            return beginWork$1(current$$1, unitOfWork, expirationTime);
          } catch (originalError) {
            if (originalError !== null && typeof originalError === "object" && typeof originalError.then === "function") {
              throw originalError;
            }

            resetContextDependencies();
            resetHooks();
            unwindInterruptedWork(unitOfWork);
            assignFiberPropertiesInDEV(unitOfWork, originalWorkInProgressCopy);

            if (enableProfilerTimer && unitOfWork.mode & ProfileMode) {
              startProfilerTimer(unitOfWork);
            }

            invokeGuardedCallback(null, beginWork$1, null, current$$1, unitOfWork, expirationTime);

            if (hasCaughtError()) {
              var replayError = clearCaughtError();
              throw replayError;
            } else {
              throw originalError;
            }
          }
        };
      } else {
        beginWork$$1 = beginWork$1;
      }

      var didWarnAboutUpdateInRender = false;
      var didWarnAboutUpdateInGetChildContext = false;

      function warnAboutInvalidUpdatesOnClassComponentsInDEV(fiber) {
        {
          if (fiber.tag === ClassComponent) {
            switch (phase) {
              case "getChildContext":
                if (didWarnAboutUpdateInGetChildContext) {
                  return;
                }

                warningWithoutStack$1(false, "setState(...): Cannot call setState() inside getChildContext()");
                didWarnAboutUpdateInGetChildContext = true;
                break;

              case "render":
                if (didWarnAboutUpdateInRender) {
                  return;
                }

                warningWithoutStack$1(false, "Cannot update during an existing state transition (such as " + "within `render`). Render methods should be a pure function of " + "props and state.");
                didWarnAboutUpdateInRender = true;
                break;
            }
          }
        }
      }

      var IsThisRendererActing = {
        current: false
      };

      function warnIfNotScopedWithMatchingAct(fiber) {
        {
          if (warnsIfNotActing === true && IsSomeRendererActing.current === true && IsThisRendererActing.current !== true) {
            warningWithoutStack$1(false, "It looks like you're using the wrong act() around your test interactions.\n" + "Be sure to use the matching version of act() corresponding to your renderer:\n\n" + "// for react-dom:\n" + "import {act} from 'react-dom/test-utils';\n" + "// ...\n" + "act(() => ...);\n\n" + "// for react-test-renderer:\n" + "import TestRenderer from 'react-test-renderer';\n" + "const {act} = TestRenderer;\n" + "// ...\n" + "act(() => ...);" + "%s", getStackByFiberInDevAndProd(fiber));
          }
        }
      }

      function warnIfNotCurrentlyActingEffectsInDEV(fiber) {
        {
          if (warnsIfNotActing === true && (fiber.mode & StrictMode) !== NoMode && IsSomeRendererActing.current === false && IsThisRendererActing.current === false) {
            warningWithoutStack$1(false, "An update to %s ran an effect, but was not wrapped in act(...).\n\n" + "When testing, code that causes React state updates should be " + "wrapped into act(...):\n\n" + "act(() => {\n" + "  /* fire events that update state */\n" + "});\n" + "/* assert on the output */\n\n" + "This ensures that you're testing the behavior the user would see " + "in the browser." + " Learn more at https://fb.me/react-wrap-tests-with-act" + "%s", getComponentName(fiber.type), getStackByFiberInDevAndProd(fiber));
          }
        }
      }

      function warnIfNotCurrentlyActingUpdatesInDEV(fiber) {
        {
          if (warnsIfNotActing === true && executionContext === NoContext && IsSomeRendererActing.current === false && IsThisRendererActing.current === false) {
            warningWithoutStack$1(false, "An update to %s inside a test was not wrapped in act(...).\n\n" + "When testing, code that causes React state updates should be " + "wrapped into act(...):\n\n" + "act(() => {\n" + "  /* fire events that update state */\n" + "});\n" + "/* assert on the output */\n\n" + "This ensures that you're testing the behavior the user would see " + "in the browser." + " Learn more at https://fb.me/react-wrap-tests-with-act" + "%s", getComponentName(fiber.type), getStackByFiberInDevAndProd(fiber));
          }
        }
      }

      var warnIfNotCurrentlyActingUpdatesInDev = warnIfNotCurrentlyActingUpdatesInDEV;
      var didWarnAboutUnmockedScheduler = false;

      function warnIfUnmockedScheduler(fiber) {
        {
          if (didWarnAboutUnmockedScheduler === false && Scheduler.unstable_flushAllWithoutAsserting === undefined) {
            if (fiber.mode & BatchedMode || fiber.mode & ConcurrentMode) {
              didWarnAboutUnmockedScheduler = true;
              warningWithoutStack$1(false, 'In Concurrent or Sync modes, the "scheduler" module needs to be mocked ' + "to guarantee consistent behaviour across tests and browsers. " + "For example, with jest: \n" + "jest.mock('scheduler', () => require('scheduler/unstable_mock'));\n\n" + "For more info, visit https://fb.me/react-mock-scheduler");
            } else if (warnAboutUnmockedScheduler === true) {
              didWarnAboutUnmockedScheduler = true;
              warningWithoutStack$1(false, 'Starting from React v17, the "scheduler" module will need to be mocked ' + "to guarantee consistent behaviour across tests and browsers. " + "For example, with jest: \n" + "jest.mock('scheduler', () => require('scheduler/unstable_mock'));\n\n" + "For more info, visit https://fb.me/react-mock-scheduler");
            }
          }
        }
      }

      var componentsThatTriggeredHighPriSuspend = null;

      function checkForWrongSuspensePriorityInDEV(sourceFiber) {
        {
          var currentPriorityLevel = getCurrentPriorityLevel();

          if ((sourceFiber.mode & ConcurrentMode) !== NoEffect && (currentPriorityLevel === UserBlockingPriority || currentPriorityLevel === ImmediatePriority)) {
            var workInProgressNode = sourceFiber;

            while (workInProgressNode !== null) {
              var current$$1 = workInProgressNode.alternate;

              if (current$$1 !== null) {
                switch (workInProgressNode.tag) {
                  case ClassComponent:
                    var updateQueue = current$$1.updateQueue;

                    if (updateQueue !== null) {
                      var update = updateQueue.firstUpdate;

                      while (update !== null) {
                        var priorityLevel = update.priority;

                        if (priorityLevel === UserBlockingPriority || priorityLevel === ImmediatePriority) {
                          if (componentsThatTriggeredHighPriSuspend === null) {
                            componentsThatTriggeredHighPriSuspend = new Set([getComponentName(workInProgressNode.type)]);
                          } else {
                            componentsThatTriggeredHighPriSuspend.add(getComponentName(workInProgressNode.type));
                          }

                          break;
                        }

                        update = update.next;
                      }
                    }

                    break;

                  case FunctionComponent:
                  case ForwardRef:
                  case SimpleMemoComponent:
                    if (workInProgressNode.memoizedState !== null && workInProgressNode.memoizedState.baseUpdate !== null) {
                      var _update = workInProgressNode.memoizedState.baseUpdate;

                      while (_update !== null) {
                        var priority = _update.priority;

                        if (priority === UserBlockingPriority || priority === ImmediatePriority) {
                          if (componentsThatTriggeredHighPriSuspend === null) {
                            componentsThatTriggeredHighPriSuspend = new Set([getComponentName(workInProgressNode.type)]);
                          } else {
                            componentsThatTriggeredHighPriSuspend.add(getComponentName(workInProgressNode.type));
                          }

                          break;
                        }

                        if (_update.next === workInProgressNode.memoizedState.baseUpdate) {
                          break;
                        }

                        _update = _update.next;
                      }
                    }

                    break;

                  default:
                    break;
                }
              }

              workInProgressNode = workInProgressNode.return;
            }
          }
        }
      }

      function flushSuspensePriorityWarningInDEV() {
        {
          if (componentsThatTriggeredHighPriSuspend !== null) {
            var componentNames = [];
            componentsThatTriggeredHighPriSuspend.forEach(function (name) {
              return componentNames.push(name);
            });
            componentsThatTriggeredHighPriSuspend = null;

            if (componentNames.length > 0) {
              warningWithoutStack$1(false, "%s triggered a user-blocking update that suspended." + "\n\n" + "The fix is to split the update into multiple parts: a user-blocking " + "update to provide immediate feedback, and another update that " + "triggers the bulk of the changes." + "\n\n" + "Refer to the documentation for useSuspenseTransition to learn how " + "to implement this pattern.", componentNames.sort().join(", "));
            }
          }
        }
      }

      function computeThreadID(root, expirationTime) {
        return expirationTime * 1000 + root.interactionThreadID;
      }

      function markSpawnedWork(expirationTime) {
        if (!enableSchedulerTracing) {
          return;
        }

        if (spawnedWorkDuringRender === null) {
          spawnedWorkDuringRender = [expirationTime];
        } else {
          spawnedWorkDuringRender.push(expirationTime);
        }
      }

      function scheduleInteractions(root, expirationTime, interactions) {
        if (!enableSchedulerTracing) {
          return;
        }

        if (interactions.size > 0) {
          var pendingInteractionMap = root.pendingInteractionMap;
          var pendingInteractions = pendingInteractionMap.get(expirationTime);

          if (pendingInteractions != null) {
            interactions.forEach(function (interaction) {
              if (!pendingInteractions.has(interaction)) {
                interaction.__count++;
              }

              pendingInteractions.add(interaction);
            });
          } else {
            pendingInteractionMap.set(expirationTime, new Set(interactions));
            interactions.forEach(function (interaction) {
              interaction.__count++;
            });
          }

          var subscriber = tracing.__subscriberRef.current;

          if (subscriber !== null) {
            var threadID = computeThreadID(root, expirationTime);
            subscriber.onWorkScheduled(interactions, threadID);
          }
        }
      }

      function schedulePendingInteractions(root, expirationTime) {
        if (!enableSchedulerTracing) {
          return;
        }

        scheduleInteractions(root, expirationTime, tracing.__interactionsRef.current);
      }

      function startWorkOnPendingInteractions(root, expirationTime) {
        if (!enableSchedulerTracing) {
          return;
        }

        var interactions = new Set();
        root.pendingInteractionMap.forEach(function (scheduledInteractions, scheduledExpirationTime) {
          if (scheduledExpirationTime >= expirationTime) {
            scheduledInteractions.forEach(function (interaction) {
              return interactions.add(interaction);
            });
          }
        });
        root.memoizedInteractions = interactions;

        if (interactions.size > 0) {
          var subscriber = tracing.__subscriberRef.current;

          if (subscriber !== null) {
            var threadID = computeThreadID(root, expirationTime);

            try {
              subscriber.onWorkStarted(interactions, threadID);
            } catch (error) {
              scheduleCallback(ImmediatePriority, function () {
                throw error;
              });
            }
          }
        }
      }

      function finishPendingInteractions(root, committedExpirationTime) {
        if (!enableSchedulerTracing) {
          return;
        }

        var earliestRemainingTimeAfterCommit = root.firstPendingTime;
        var subscriber = void 0;

        try {
          subscriber = tracing.__subscriberRef.current;

          if (subscriber !== null && root.memoizedInteractions.size > 0) {
            var threadID = computeThreadID(root, committedExpirationTime);
            subscriber.onWorkStopped(root.memoizedInteractions, threadID);
          }
        } catch (error) {
          scheduleCallback(ImmediatePriority, function () {
            throw error;
          });
        } finally {
          var pendingInteractionMap = root.pendingInteractionMap;
          pendingInteractionMap.forEach(function (scheduledInteractions, scheduledExpirationTime) {
            if (scheduledExpirationTime > earliestRemainingTimeAfterCommit) {
              pendingInteractionMap.delete(scheduledExpirationTime);
              scheduledInteractions.forEach(function (interaction) {
                interaction.__count--;

                if (subscriber !== null && interaction.__count === 0) {
                  try {
                    subscriber.onInteractionScheduledWorkCompleted(interaction);
                  } catch (error) {
                    scheduleCallback(ImmediatePriority, function () {
                      throw error;
                    });
                  }
                }
              });
            }
          });
        }
      }

      var onCommitFiberRoot = null;
      var onCommitFiberUnmount = null;
      var hasLoggedError = false;
      var isDevToolsPresent = typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined";

      function injectInternals(internals) {
        if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ === "undefined") {
          return false;
        }

        var hook = __REACT_DEVTOOLS_GLOBAL_HOOK__;

        if (hook.isDisabled) {
          return true;
        }

        if (!hook.supportsFiber) {
          {
            warningWithoutStack$1(false, "The installed version of React DevTools is too old and will not work " + "with the current version of React. Please update React DevTools. " + "https://fb.me/react-devtools");
          }
          return true;
        }

        try {
          var rendererID = hook.inject(internals);

          onCommitFiberRoot = function onCommitFiberRoot(root, expirationTime) {
            try {
              var didError = (root.current.effectTag & DidCapture) === DidCapture;

              if (enableProfilerTimer) {
                var currentTime = requestCurrentTime();
                var priorityLevel = inferPriorityFromExpirationTime(currentTime, expirationTime);
                hook.onCommitFiberRoot(rendererID, root, priorityLevel, didError);
              } else {
                hook.onCommitFiberRoot(rendererID, root, undefined, didError);
              }
            } catch (err) {
              if (true && !hasLoggedError) {
                hasLoggedError = true;
                warningWithoutStack$1(false, "React DevTools encountered an error: %s", err);
              }
            }
          };

          onCommitFiberUnmount = function onCommitFiberUnmount(fiber) {
            try {
              hook.onCommitFiberUnmount(rendererID, fiber);
            } catch (err) {
              if (true && !hasLoggedError) {
                hasLoggedError = true;
                warningWithoutStack$1(false, "React DevTools encountered an error: %s", err);
              }
            }
          };
        } catch (err) {
          {
            warningWithoutStack$1(false, "React DevTools encountered an error: %s.", err);
          }
        }

        return true;
      }

      function onCommitRoot(root, expirationTime) {
        if (typeof onCommitFiberRoot === "function") {
          onCommitFiberRoot(root, expirationTime);
        }
      }

      function onCommitUnmount(fiber) {
        if (typeof onCommitFiberUnmount === "function") {
          onCommitFiberUnmount(fiber);
        }
      }

      var hasBadMapPolyfill = void 0;
      {
        hasBadMapPolyfill = false;

        try {
          var nonExtensibleObject = Object.preventExtensions({});
          var testMap = new Map([[nonExtensibleObject, null]]);
          var testSet = new Set([nonExtensibleObject]);
          testMap.set(0, 0);
          testSet.add(0);
        } catch (e) {
          hasBadMapPolyfill = true;
        }
      }
      var debugCounter = void 0;
      {
        debugCounter = 1;
      }

      function FiberNode(tag, pendingProps, key, mode) {
        this.tag = tag;
        this.key = key;
        this.elementType = null;
        this.type = null;
        this.stateNode = null;
        this.return = null;
        this.child = null;
        this.sibling = null;
        this.index = 0;
        this.ref = null;
        this.pendingProps = pendingProps;
        this.memoizedProps = null;
        this.updateQueue = null;
        this.memoizedState = null;
        this.dependencies = null;
        this.mode = mode;
        this.effectTag = NoEffect;
        this.nextEffect = null;
        this.firstEffect = null;
        this.lastEffect = null;
        this.expirationTime = NoWork;
        this.childExpirationTime = NoWork;
        this.alternate = null;

        if (enableProfilerTimer) {
          this.actualDuration = Number.NaN;
          this.actualStartTime = Number.NaN;
          this.selfBaseDuration = Number.NaN;
          this.treeBaseDuration = Number.NaN;
          this.actualDuration = 0;
          this.actualStartTime = -1;
          this.selfBaseDuration = 0;
          this.treeBaseDuration = 0;
        }

        {
          this._debugID = debugCounter++;
          this._debugSource = null;
          this._debugOwner = null;
          this._debugIsCurrentlyTiming = false;
          this._debugNeedsRemount = false;
          this._debugHookTypes = null;

          if (!hasBadMapPolyfill && typeof Object.preventExtensions === "function") {
            Object.preventExtensions(this);
          }
        }
      }

      var createFiber = function createFiber(tag, pendingProps, key, mode) {
        return new FiberNode(tag, pendingProps, key, mode);
      };

      function shouldConstruct(Component) {
        var prototype = Component.prototype;
        return !!(prototype && prototype.isReactComponent);
      }

      function isSimpleFunctionComponent(type) {
        return typeof type === "function" && !shouldConstruct(type) && type.defaultProps === undefined;
      }

      function resolveLazyComponentTag(Component) {
        if (typeof Component === "function") {
          return shouldConstruct(Component) ? ClassComponent : FunctionComponent;
        } else if (Component !== undefined && Component !== null) {
          var $$typeof = Component.$$typeof;

          if ($$typeof === REACT_FORWARD_REF_TYPE) {
            return ForwardRef;
          }

          if ($$typeof === REACT_MEMO_TYPE) {
            return MemoComponent;
          }
        }

        return IndeterminateComponent;
      }

      function createWorkInProgress(current, pendingProps, expirationTime) {
        var workInProgress = current.alternate;

        if (workInProgress === null) {
          workInProgress = createFiber(current.tag, pendingProps, current.key, current.mode);
          workInProgress.elementType = current.elementType;
          workInProgress.type = current.type;
          workInProgress.stateNode = current.stateNode;
          {
            workInProgress._debugID = current._debugID;
            workInProgress._debugSource = current._debugSource;
            workInProgress._debugOwner = current._debugOwner;
            workInProgress._debugHookTypes = current._debugHookTypes;
          }
          workInProgress.alternate = current;
          current.alternate = workInProgress;
        } else {
          workInProgress.pendingProps = pendingProps;
          workInProgress.effectTag = NoEffect;
          workInProgress.nextEffect = null;
          workInProgress.firstEffect = null;
          workInProgress.lastEffect = null;

          if (enableProfilerTimer) {
            workInProgress.actualDuration = 0;
            workInProgress.actualStartTime = -1;
          }
        }

        workInProgress.childExpirationTime = current.childExpirationTime;
        workInProgress.expirationTime = current.expirationTime;
        workInProgress.child = current.child;
        workInProgress.memoizedProps = current.memoizedProps;
        workInProgress.memoizedState = current.memoizedState;
        workInProgress.updateQueue = current.updateQueue;
        var currentDependencies = current.dependencies;
        workInProgress.dependencies = currentDependencies === null ? null : {
          expirationTime: currentDependencies.expirationTime,
          firstContext: currentDependencies.firstContext,
          responders: currentDependencies.responders
        };
        workInProgress.sibling = current.sibling;
        workInProgress.index = current.index;
        workInProgress.ref = current.ref;

        if (enableProfilerTimer) {
          workInProgress.selfBaseDuration = current.selfBaseDuration;
          workInProgress.treeBaseDuration = current.treeBaseDuration;
        }

        {
          workInProgress._debugNeedsRemount = current._debugNeedsRemount;

          switch (workInProgress.tag) {
            case IndeterminateComponent:
            case FunctionComponent:
            case SimpleMemoComponent:
              workInProgress.type = resolveFunctionForHotReloading(current.type);
              break;

            case ClassComponent:
              workInProgress.type = resolveClassForHotReloading(current.type);
              break;

            case ForwardRef:
              workInProgress.type = resolveForwardRefForHotReloading(current.type);
              break;

            default:
              break;
          }
        }
        return workInProgress;
      }

      function resetWorkInProgress(workInProgress, renderExpirationTime) {
        workInProgress.effectTag &= Placement;
        workInProgress.nextEffect = null;
        workInProgress.firstEffect = null;
        workInProgress.lastEffect = null;
        var current = workInProgress.alternate;

        if (current === null) {
          workInProgress.childExpirationTime = NoWork;
          workInProgress.expirationTime = renderExpirationTime;
          workInProgress.child = null;
          workInProgress.memoizedProps = null;
          workInProgress.memoizedState = null;
          workInProgress.updateQueue = null;
          workInProgress.dependencies = null;

          if (enableProfilerTimer) {
            workInProgress.selfBaseDuration = 0;
            workInProgress.treeBaseDuration = 0;
          }
        } else {
          workInProgress.childExpirationTime = current.childExpirationTime;
          workInProgress.expirationTime = current.expirationTime;
          workInProgress.child = current.child;
          workInProgress.memoizedProps = current.memoizedProps;
          workInProgress.memoizedState = current.memoizedState;
          workInProgress.updateQueue = current.updateQueue;
          var currentDependencies = current.dependencies;
          workInProgress.dependencies = currentDependencies === null ? null : {
            expirationTime: currentDependencies.expirationTime,
            firstContext: currentDependencies.firstContext,
            responders: currentDependencies.responders
          };

          if (enableProfilerTimer) {
            workInProgress.selfBaseDuration = current.selfBaseDuration;
            workInProgress.treeBaseDuration = current.treeBaseDuration;
          }
        }

        return workInProgress;
      }

      function createHostRootFiber(tag) {
        var mode = void 0;

        if (tag === ConcurrentRoot) {
          mode = ConcurrentMode | BatchedMode | StrictMode;
        } else if (tag === BatchedRoot) {
          mode = BatchedMode | StrictMode;
        } else {
          mode = NoMode;
        }

        if (enableProfilerTimer && isDevToolsPresent) {
          mode |= ProfileMode;
        }

        return createFiber(HostRoot, null, null, mode);
      }

      function createFiberFromTypeAndProps(type, key, pendingProps, owner, mode, expirationTime) {
        var fiber = void 0;
        var fiberTag = IndeterminateComponent;
        var resolvedType = type;

        if (typeof type === "function") {
          if (shouldConstruct(type)) {
            fiberTag = ClassComponent;
            {
              resolvedType = resolveClassForHotReloading(resolvedType);
            }
          } else {
            {
              resolvedType = resolveFunctionForHotReloading(resolvedType);
            }
          }
        } else if (typeof type === "string") {
          fiberTag = HostComponent;
        } else {
          getTag: switch (type) {
            case REACT_FRAGMENT_TYPE:
              return createFiberFromFragment(pendingProps.children, mode, expirationTime, key);

            case REACT_CONCURRENT_MODE_TYPE:
              fiberTag = Mode;
              mode |= ConcurrentMode | BatchedMode | StrictMode;
              break;

            case REACT_STRICT_MODE_TYPE:
              fiberTag = Mode;
              mode |= StrictMode;
              break;

            case REACT_PROFILER_TYPE:
              return createFiberFromProfiler(pendingProps, mode, expirationTime, key);

            case REACT_SUSPENSE_TYPE:
              return createFiberFromSuspense(pendingProps, mode, expirationTime, key);

            case REACT_SUSPENSE_LIST_TYPE:
              return createFiberFromSuspenseList(pendingProps, mode, expirationTime, key);

            default:
              {
                if (typeof type === "object" && type !== null) {
                  switch (type.$$typeof) {
                    case REACT_PROVIDER_TYPE:
                      fiberTag = ContextProvider;
                      break getTag;

                    case REACT_CONTEXT_TYPE:
                      fiberTag = ContextConsumer;
                      break getTag;

                    case REACT_FORWARD_REF_TYPE:
                      fiberTag = ForwardRef;
                      {
                        resolvedType = resolveForwardRefForHotReloading(resolvedType);
                      }
                      break getTag;

                    case REACT_MEMO_TYPE:
                      fiberTag = MemoComponent;
                      break getTag;

                    case REACT_LAZY_TYPE:
                      fiberTag = LazyComponent;
                      resolvedType = null;
                      break getTag;

                    case REACT_FUNDAMENTAL_TYPE:
                      if (enableFundamentalAPI) {
                        return createFiberFromFundamental(type, pendingProps, mode, expirationTime, key);
                      }

                      break;
                  }
                }

                var info = "";
                {
                  if (type === undefined || typeof type === "object" && type !== null && Object.keys(type).length === 0) {
                    info += " You likely forgot to export your component from the file " + "it's defined in, or you might have mixed up default and " + "named imports.";
                  }

                  var ownerName = owner ? getComponentName(owner.type) : null;

                  if (ownerName) {
                    info += "\n\nCheck the render method of `" + ownerName + "`.";
                  }
                }

                (function () {
                  {
                    throw ReactError(Error("Element type is invalid: expected a string (for built-in components) or a class/function (for composite components) but got: " + (type == null ? type : typeof type) + "." + info));
                  }
                })();
              }
          }
        }

        fiber = createFiber(fiberTag, pendingProps, key, mode);
        fiber.elementType = type;
        fiber.type = resolvedType;
        fiber.expirationTime = expirationTime;
        return fiber;
      }

      function createFiberFromElement(element, mode, expirationTime) {
        var owner = null;
        {
          owner = element._owner;
        }
        var type = element.type;
        var key = element.key;
        var pendingProps = element.props;
        var fiber = createFiberFromTypeAndProps(type, key, pendingProps, owner, mode, expirationTime);
        {
          fiber._debugSource = element._source;
          fiber._debugOwner = element._owner;
        }
        return fiber;
      }

      function createFiberFromFragment(elements, mode, expirationTime, key) {
        var fiber = createFiber(Fragment, elements, key, mode);
        fiber.expirationTime = expirationTime;
        return fiber;
      }

      function createFiberFromFundamental(fundamentalComponent, pendingProps, mode, expirationTime, key) {
        var fiber = createFiber(FundamentalComponent, pendingProps, key, mode);
        fiber.elementType = fundamentalComponent;
        fiber.type = fundamentalComponent;
        fiber.expirationTime = expirationTime;
        return fiber;
      }

      function createFiberFromProfiler(pendingProps, mode, expirationTime, key) {
        {
          if (typeof pendingProps.id !== "string" || typeof pendingProps.onRender !== "function") {
            warningWithoutStack$1(false, 'Profiler must specify an "id" string and "onRender" function as props');
          }
        }
        var fiber = createFiber(Profiler, pendingProps, key, mode | ProfileMode);
        fiber.elementType = REACT_PROFILER_TYPE;
        fiber.type = REACT_PROFILER_TYPE;
        fiber.expirationTime = expirationTime;
        return fiber;
      }

      function createFiberFromSuspense(pendingProps, mode, expirationTime, key) {
        var fiber = createFiber(SuspenseComponent, pendingProps, key, mode);
        fiber.type = REACT_SUSPENSE_TYPE;
        fiber.elementType = REACT_SUSPENSE_TYPE;
        fiber.expirationTime = expirationTime;
        return fiber;
      }

      function createFiberFromSuspenseList(pendingProps, mode, expirationTime, key) {
        var fiber = createFiber(SuspenseListComponent, pendingProps, key, mode);
        {
          fiber.type = REACT_SUSPENSE_LIST_TYPE;
        }
        fiber.elementType = REACT_SUSPENSE_LIST_TYPE;
        fiber.expirationTime = expirationTime;
        return fiber;
      }

      function createFiberFromText(content, mode, expirationTime) {
        var fiber = createFiber(HostText, content, null, mode);
        fiber.expirationTime = expirationTime;
        return fiber;
      }

      function createFiberFromHostInstanceForDeletion() {
        var fiber = createFiber(HostComponent, null, null, NoMode);
        fiber.elementType = "DELETED";
        fiber.type = "DELETED";
        return fiber;
      }

      function createFiberFromPortal(portal, mode, expirationTime) {
        var pendingProps = portal.children !== null ? portal.children : [];
        var fiber = createFiber(HostPortal, pendingProps, portal.key, mode);
        fiber.expirationTime = expirationTime;
        fiber.stateNode = {
          containerInfo: portal.containerInfo,
          pendingChildren: null,
          implementation: portal.implementation
        };
        return fiber;
      }

      function assignFiberPropertiesInDEV(target, source) {
        if (target === null) {
          target = createFiber(IndeterminateComponent, null, null, NoMode);
        }

        target.tag = source.tag;
        target.key = source.key;
        target.elementType = source.elementType;
        target.type = source.type;
        target.stateNode = source.stateNode;
        target.return = source.return;
        target.child = source.child;
        target.sibling = source.sibling;
        target.index = source.index;
        target.ref = source.ref;
        target.pendingProps = source.pendingProps;
        target.memoizedProps = source.memoizedProps;
        target.updateQueue = source.updateQueue;
        target.memoizedState = source.memoizedState;
        target.dependencies = source.dependencies;
        target.mode = source.mode;
        target.effectTag = source.effectTag;
        target.nextEffect = source.nextEffect;
        target.firstEffect = source.firstEffect;
        target.lastEffect = source.lastEffect;
        target.expirationTime = source.expirationTime;
        target.childExpirationTime = source.childExpirationTime;
        target.alternate = source.alternate;

        if (enableProfilerTimer) {
          target.actualDuration = source.actualDuration;
          target.actualStartTime = source.actualStartTime;
          target.selfBaseDuration = source.selfBaseDuration;
          target.treeBaseDuration = source.treeBaseDuration;
        }

        target._debugID = source._debugID;
        target._debugSource = source._debugSource;
        target._debugOwner = source._debugOwner;
        target._debugIsCurrentlyTiming = source._debugIsCurrentlyTiming;
        target._debugNeedsRemount = source._debugNeedsRemount;
        target._debugHookTypes = source._debugHookTypes;
        return target;
      }

      function FiberRootNode(containerInfo, tag, hydrate) {
        this.tag = tag;
        this.current = null;
        this.containerInfo = containerInfo;
        this.pendingChildren = null;
        this.pingCache = null;
        this.finishedExpirationTime = NoWork;
        this.finishedWork = null;
        this.timeoutHandle = noTimeout;
        this.context = null;
        this.pendingContext = null;
        this.hydrate = hydrate;
        this.firstBatch = null;
        this.callbackNode = null;
        this.callbackExpirationTime = NoWork;
        this.firstPendingTime = NoWork;
        this.lastPendingTime = NoWork;
        this.pingTime = NoWork;

        if (enableSchedulerTracing) {
          this.interactionThreadID = tracing.unstable_getThreadID();
          this.memoizedInteractions = new Set();
          this.pendingInteractionMap = new Map();
        }
      }

      function createFiberRoot(containerInfo, tag, hydrate) {
        var root = new FiberRootNode(containerInfo, tag, hydrate);
        var uninitializedFiber = createHostRootFiber(tag);
        root.current = uninitializedFiber;
        uninitializedFiber.stateNode = root;
        return root;
      }

      var ReactFiberInstrumentation = {
        debugTool: null
      };
      var ReactFiberInstrumentation_1 = ReactFiberInstrumentation;
      var didWarnAboutNestedUpdates = void 0;
      var didWarnAboutFindNodeInStrictMode = void 0;
      {
        didWarnAboutNestedUpdates = false;
        didWarnAboutFindNodeInStrictMode = {};
      }

      function getContextForSubtree(parentComponent) {
        if (!parentComponent) {
          return emptyContextObject;
        }

        var fiber = get(parentComponent);
        var parentContext = findCurrentUnmaskedContext(fiber);

        if (fiber.tag === ClassComponent) {
          var Component = fiber.type;

          if (isContextProvider(Component)) {
            return processChildContext(fiber, Component, parentContext);
          }
        }

        return parentContext;
      }

      function scheduleRootUpdate(current$$1, element, expirationTime, suspenseConfig, callback) {
        {
          if (phase === "render" && current !== null && !didWarnAboutNestedUpdates) {
            didWarnAboutNestedUpdates = true;
            warningWithoutStack$1(false, "Render methods should be a pure function of props and state; " + "triggering nested component updates from render is not allowed. " + "If necessary, trigger nested updates in componentDidUpdate.\n\n" + "Check the render method of %s.", getComponentName(current.type) || "Unknown");
          }
        }
        var update = createUpdate(expirationTime, suspenseConfig);
        update.payload = {
          element: element
        };
        callback = callback === undefined ? null : callback;

        if (callback !== null) {
          !(typeof callback === "function") ? warningWithoutStack$1(false, "render(...): Expected the last optional `callback` argument to be a " + "function. Instead received: %s.", callback) : void 0;
          update.callback = callback;
        }

        if (revertPassiveEffectsChange) {
          flushPassiveEffects();
        }

        enqueueUpdate(current$$1, update);
        scheduleWork(current$$1, expirationTime);
        return expirationTime;
      }

      function updateContainerAtExpirationTime(element, container, parentComponent, expirationTime, suspenseConfig, callback) {
        var current$$1 = container.current;
        {
          if (ReactFiberInstrumentation_1.debugTool) {
            if (current$$1.alternate === null) {
              ReactFiberInstrumentation_1.debugTool.onMountContainer(container);
            } else if (element === null) {
              ReactFiberInstrumentation_1.debugTool.onUnmountContainer(container);
            } else {
              ReactFiberInstrumentation_1.debugTool.onUpdateContainer(container);
            }
          }
        }
        var context = getContextForSubtree(parentComponent);

        if (container.context === null) {
          container.context = context;
        } else {
          container.pendingContext = context;
        }

        return scheduleRootUpdate(current$$1, element, expirationTime, suspenseConfig, callback);
      }

      function findHostInstance(component) {
        var fiber = get(component);

        if (fiber === undefined) {
          if (typeof component.render === "function") {
            (function () {
              {
                throw ReactError(Error("Unable to find node on an unmounted component."));
              }
            })();
          } else {
            (function () {
              {
                throw ReactError(Error("Argument appears to not be a ReactComponent. Keys: " + Object.keys(component)));
              }
            })();
          }
        }

        var hostFiber = findCurrentHostFiber(fiber);

        if (hostFiber === null) {
          return null;
        }

        return hostFiber.stateNode;
      }

      function findHostInstanceWithWarning(component, methodName) {
        {
          var fiber = get(component);

          if (fiber === undefined) {
            if (typeof component.render === "function") {
              (function () {
                {
                  throw ReactError(Error("Unable to find node on an unmounted component."));
                }
              })();
            } else {
              (function () {
                {
                  throw ReactError(Error("Argument appears to not be a ReactComponent. Keys: " + Object.keys(component)));
                }
              })();
            }
          }

          var hostFiber = findCurrentHostFiber(fiber);

          if (hostFiber === null) {
            return null;
          }

          if (hostFiber.mode & StrictMode) {
            var componentName = getComponentName(fiber.type) || "Component";

            if (!didWarnAboutFindNodeInStrictMode[componentName]) {
              didWarnAboutFindNodeInStrictMode[componentName] = true;

              if (fiber.mode & StrictMode) {
                warningWithoutStack$1(false, "%s is deprecated in StrictMode. " + "%s was passed an instance of %s which is inside StrictMode. " + "Instead, add a ref directly to the element you want to reference." + "\n%s" + "\n\nLearn more about using refs safely here:" + "\nhttps://fb.me/react-strict-mode-find-node", methodName, methodName, componentName, getStackByFiberInDevAndProd(hostFiber));
              } else {
                warningWithoutStack$1(false, "%s is deprecated in StrictMode. " + "%s was passed an instance of %s which renders StrictMode children. " + "Instead, add a ref directly to the element you want to reference." + "\n%s" + "\n\nLearn more about using refs safely here:" + "\nhttps://fb.me/react-strict-mode-find-node", methodName, methodName, componentName, getStackByFiberInDevAndProd(hostFiber));
              }
            }
          }

          return hostFiber.stateNode;
        }
        return findHostInstance(component);
      }

      function createContainer(containerInfo, tag, hydrate) {
        return createFiberRoot(containerInfo, tag, hydrate);
      }

      function updateContainer(element, container, parentComponent, callback) {
        var current$$1 = container.current;
        var currentTime = requestCurrentTime();
        {
          if ("undefined" !== typeof jest) {
            warnIfUnmockedScheduler(current$$1);
            warnIfNotScopedWithMatchingAct(current$$1);
          }
        }
        var suspenseConfig = requestCurrentSuspenseConfig();
        var expirationTime = computeExpirationForFiber(currentTime, current$$1, suspenseConfig);
        return updateContainerAtExpirationTime(element, container, parentComponent, expirationTime, suspenseConfig, callback);
      }

      function getPublicRootInstance(container) {
        var containerFiber = container.current;

        if (!containerFiber.child) {
          return null;
        }

        switch (containerFiber.child.tag) {
          case HostComponent:
            return getPublicInstance(containerFiber.child.stateNode);

          default:
            return containerFiber.child.stateNode;
        }
      }

      var shouldSuspendImpl = function shouldSuspendImpl(fiber) {
        return false;
      };

      function shouldSuspend(fiber) {
        return shouldSuspendImpl(fiber);
      }

      var overrideHookState = null;
      var overrideProps = null;
      var scheduleUpdate = null;
      var setSuspenseHandler = null;
      {
        var copyWithSetImpl = function copyWithSetImpl(obj, path, idx, value) {
          if (idx >= path.length) {
            return value;
          }

          var key = path[idx];
          var updated = Array.isArray(obj) ? obj.slice() : _extends({}, obj);
          updated[key] = copyWithSetImpl(obj[key], path, idx + 1, value);
          return updated;
        };

        var copyWithSet = function copyWithSet(obj, path, value) {
          return copyWithSetImpl(obj, path, 0, value);
        };

        overrideHookState = function overrideHookState(fiber, id, path, value) {
          var currentHook = fiber.memoizedState;

          while (currentHook !== null && id > 0) {
            currentHook = currentHook.next;
            id--;
          }

          if (currentHook !== null) {
            if (revertPassiveEffectsChange) {
              flushPassiveEffects();
            }

            var newState = copyWithSet(currentHook.memoizedState, path, value);
            currentHook.memoizedState = newState;
            currentHook.baseState = newState;
            fiber.memoizedProps = _extends({}, fiber.memoizedProps);
            scheduleWork(fiber, Sync);
          }
        };

        overrideProps = function overrideProps(fiber, path, value) {
          if (revertPassiveEffectsChange) {
            flushPassiveEffects();
          }

          fiber.pendingProps = copyWithSet(fiber.memoizedProps, path, value);

          if (fiber.alternate) {
            fiber.alternate.pendingProps = fiber.pendingProps;
          }

          scheduleWork(fiber, Sync);
        };

        scheduleUpdate = function scheduleUpdate(fiber) {
          if (revertPassiveEffectsChange) {
            flushPassiveEffects();
          }

          scheduleWork(fiber, Sync);
        };

        setSuspenseHandler = function setSuspenseHandler(newShouldSuspendImpl) {
          shouldSuspendImpl = newShouldSuspendImpl;
        };
      }

      function injectIntoDevTools(devToolsConfig) {
        var _findFiberByHostInstance = devToolsConfig.findFiberByHostInstance;
        var ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
        return injectInternals(_extends({}, devToolsConfig, {
          overrideHookState: overrideHookState,
          overrideProps: overrideProps,
          setSuspenseHandler: setSuspenseHandler,
          scheduleUpdate: scheduleUpdate,
          currentDispatcherRef: ReactCurrentDispatcher,
          findHostInstanceByFiber: function findHostInstanceByFiber(fiber) {
            var hostFiber = findCurrentHostFiber(fiber);

            if (hostFiber === null) {
              return null;
            }

            return hostFiber.stateNode;
          },
          findFiberByHostInstance: function findFiberByHostInstance(instance) {
            if (!_findFiberByHostInstance) {
              return null;
            }

            return _findFiberByHostInstance(instance);
          },
          findHostInstancesForRefresh: findHostInstancesForRefresh,
          scheduleRefresh: scheduleRefresh,
          scheduleRoot: scheduleRoot,
          setRefreshHandler: setRefreshHandler,
          getCurrentFiber: function getCurrentFiber() {
            return current;
          }
        }));
      }

      function _createPortal(children, containerInfo, implementation) {
        var key = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
        return {
          $$typeof: REACT_PORTAL_TYPE,
          key: key == null ? null : "" + key,
          children: children,
          containerInfo: containerInfo,
          implementation: implementation
        };
      }

      var ReactVersion = "16.8.6";

      var NativeMethodsMixin = function NativeMethodsMixin(findNodeHandle, findHostInstance) {
        var NativeMethodsMixin = {
          measure: function measure(callback) {
            var maybeInstance = void 0;

            try {
              maybeInstance = findHostInstance(this);
            } catch (error) {}

            if (maybeInstance == null) {
              return;
            }

            if (maybeInstance.canonical) {
              nativeFabricUIManager.measure(maybeInstance.node, mountSafeCallback_NOT_REALLY_SAFE(this, callback));
            } else {
              ReactNativePrivateInterface.UIManager.measure(findNodeHandle(this), mountSafeCallback_NOT_REALLY_SAFE(this, callback));
            }
          },
          measureInWindow: function measureInWindow(callback) {
            var maybeInstance = void 0;

            try {
              maybeInstance = findHostInstance(this);
            } catch (error) {}

            if (maybeInstance == null) {
              return;
            }

            if (maybeInstance.canonical) {
              nativeFabricUIManager.measureInWindow(maybeInstance.node, mountSafeCallback_NOT_REALLY_SAFE(this, callback));
            } else {
              ReactNativePrivateInterface.UIManager.measureInWindow(findNodeHandle(this), mountSafeCallback_NOT_REALLY_SAFE(this, callback));
            }
          },
          measureLayout: function measureLayout(relativeToNativeNode, onSuccess, onFail) {
            var maybeInstance = void 0;

            try {
              maybeInstance = findHostInstance(this);
            } catch (error) {}

            if (maybeInstance == null) {
              return;
            }

            if (maybeInstance.canonical) {
              warningWithoutStack$1(false, "Warning: measureLayout on components using NativeMethodsMixin " + "or ReactNative.NativeComponent is not currently supported in Fabric. " + "measureLayout must be called on a native ref. Consider using forwardRef.");
              return;
            } else {
              var relativeNode = void 0;

              if (typeof relativeToNativeNode === "number") {
                relativeNode = relativeToNativeNode;
              } else if (relativeToNativeNode._nativeTag) {
                relativeNode = relativeToNativeNode._nativeTag;
              }

              if (relativeNode == null) {
                warningWithoutStack$1(false, "Warning: ref.measureLayout must be called with a node handle or a ref to a native component.");
                return;
              }

              ReactNativePrivateInterface.UIManager.measureLayout(findNodeHandle(this), relativeNode, mountSafeCallback_NOT_REALLY_SAFE(this, onFail), mountSafeCallback_NOT_REALLY_SAFE(this, onSuccess));
            }
          },
          setNativeProps: function setNativeProps(nativeProps) {
            var maybeInstance = void 0;

            try {
              maybeInstance = findHostInstance(this);
            } catch (error) {}

            if (maybeInstance == null) {
              return;
            }

            if (maybeInstance.canonical) {
              warningWithoutStack$1(false, "Warning: setNativeProps is not currently supported in Fabric");
              return;
            }

            {
              if (warnAboutDeprecatedSetNativeProps) {
                warningWithoutStack$1(false, "Warning: Calling ref.setNativeProps(nativeProps) " + "is deprecated and will be removed in a future release. " + "Use the setNativeProps export from the react-native package instead." + "\n\timport {setNativeProps} from 'react-native';\n\tsetNativeProps(ref, nativeProps);\n");
              }
            }
            var nativeTag = maybeInstance._nativeTag || maybeInstance.canonical._nativeTag;
            var viewConfig = maybeInstance.viewConfig || maybeInstance.canonical.viewConfig;
            {
              warnForStyleProps(nativeProps, viewConfig.validAttributes);
            }
            var updatePayload = create(nativeProps, viewConfig.validAttributes);

            if (updatePayload != null) {
              ReactNativePrivateInterface.UIManager.updateView(nativeTag, viewConfig.uiViewClassName, updatePayload);
            }
          },
          focus: function focus() {
            ReactNativePrivateInterface.TextInputState.focusTextInput(findNodeHandle(this));
          },
          blur: function blur() {
            ReactNativePrivateInterface.TextInputState.blurTextInput(findNodeHandle(this));
          }
        };
        {
          var NativeMethodsMixin_DEV = NativeMethodsMixin;

          (function () {
            if (!(!NativeMethodsMixin_DEV.componentWillMount && !NativeMethodsMixin_DEV.componentWillReceiveProps && !NativeMethodsMixin_DEV.UNSAFE_componentWillMount && !NativeMethodsMixin_DEV.UNSAFE_componentWillReceiveProps)) {
              throw ReactError(Error("Do not override existing functions."));
            }
          })();

          NativeMethodsMixin_DEV.componentWillMount = function () {
            throwOnStylesProp(this, this.props);
          };

          NativeMethodsMixin_DEV.componentWillReceiveProps = function (newProps) {
            throwOnStylesProp(this, newProps);
          };

          NativeMethodsMixin_DEV.UNSAFE_componentWillMount = function () {
            throwOnStylesProp(this, this.props);
          };

          NativeMethodsMixin_DEV.UNSAFE_componentWillReceiveProps = function (newProps) {
            throwOnStylesProp(this, newProps);
          };

          NativeMethodsMixin_DEV.componentWillMount.__suppressDeprecationWarning = true;
          NativeMethodsMixin_DEV.componentWillReceiveProps.__suppressDeprecationWarning = true;
        }
        return NativeMethodsMixin;
      };

      function _classCallCheck$1(instance, Constructor) {
        if (!(instance instanceof Constructor)) {
          throw new TypeError("Cannot call a class as a function");
        }
      }

      function _possibleConstructorReturn(self, call) {
        if (!self) {
          throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
        }

        return call && (typeof call === "object" || typeof call === "function") ? call : self;
      }

      function _inherits(subClass, superClass) {
        if (typeof superClass !== "function" && superClass !== null) {
          throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
        }

        subClass.prototype = Object.create(superClass && superClass.prototype, {
          constructor: {
            value: subClass,
            enumerable: false,
            writable: true,
            configurable: true
          }
        });
        if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
      }

      var ReactNativeComponent = function ReactNativeComponent(findNodeHandle, findHostInstance) {
        var ReactNativeComponent = function (_React$Component) {
          _inherits(ReactNativeComponent, _React$Component);

          function ReactNativeComponent() {
            _classCallCheck$1(this, ReactNativeComponent);

            return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
          }

          ReactNativeComponent.prototype.blur = function blur() {
            ReactNativePrivateInterface.TextInputState.blurTextInput(findNodeHandle(this));
          };

          ReactNativeComponent.prototype.focus = function focus() {
            ReactNativePrivateInterface.TextInputState.focusTextInput(findNodeHandle(this));
          };

          ReactNativeComponent.prototype.measure = function measure(callback) {
            var maybeInstance = void 0;

            try {
              maybeInstance = findHostInstance(this);
            } catch (error) {}

            if (maybeInstance == null) {
              return;
            }

            if (maybeInstance.canonical) {
              nativeFabricUIManager.measure(maybeInstance.node, mountSafeCallback_NOT_REALLY_SAFE(this, callback));
            } else {
              ReactNativePrivateInterface.UIManager.measure(findNodeHandle(this), mountSafeCallback_NOT_REALLY_SAFE(this, callback));
            }
          };

          ReactNativeComponent.prototype.measureInWindow = function measureInWindow(callback) {
            var maybeInstance = void 0;

            try {
              maybeInstance = findHostInstance(this);
            } catch (error) {}

            if (maybeInstance == null) {
              return;
            }

            if (maybeInstance.canonical) {
              nativeFabricUIManager.measureInWindow(maybeInstance.node, mountSafeCallback_NOT_REALLY_SAFE(this, callback));
            } else {
              ReactNativePrivateInterface.UIManager.measureInWindow(findNodeHandle(this), mountSafeCallback_NOT_REALLY_SAFE(this, callback));
            }
          };

          ReactNativeComponent.prototype.measureLayout = function measureLayout(relativeToNativeNode, onSuccess, onFail) {
            var maybeInstance = void 0;

            try {
              maybeInstance = findHostInstance(this);
            } catch (error) {}

            if (maybeInstance == null) {
              return;
            }

            if (maybeInstance.canonical) {
              warningWithoutStack$1(false, "Warning: measureLayout on components using NativeMethodsMixin " + "or ReactNative.NativeComponent is not currently supported in Fabric. " + "measureLayout must be called on a native ref. Consider using forwardRef.");
              return;
            } else {
              var relativeNode = void 0;

              if (typeof relativeToNativeNode === "number") {
                relativeNode = relativeToNativeNode;
              } else if (relativeToNativeNode._nativeTag) {
                relativeNode = relativeToNativeNode._nativeTag;
              }

              if (relativeNode == null) {
                warningWithoutStack$1(false, "Warning: ref.measureLayout must be called with a node handle or a ref to a native component.");
                return;
              }

              ReactNativePrivateInterface.UIManager.measureLayout(findNodeHandle(this), relativeNode, mountSafeCallback_NOT_REALLY_SAFE(this, onFail), mountSafeCallback_NOT_REALLY_SAFE(this, onSuccess));
            }
          };

          ReactNativeComponent.prototype.setNativeProps = function setNativeProps(nativeProps) {
            var maybeInstance = void 0;

            try {
              maybeInstance = findHostInstance(this);
            } catch (error) {}

            if (maybeInstance == null) {
              return;
            }

            if (maybeInstance.canonical) {
              warningWithoutStack$1(false, "Warning: setNativeProps is not currently supported in Fabric");
              return;
            }

            {
              if (warnAboutDeprecatedSetNativeProps) {
                warningWithoutStack$1(false, "Warning: Calling ref.setNativeProps(nativeProps) " + "is deprecated and will be removed in a future release. " + "Use the setNativeProps export from the react-native package instead." + "\n\timport {setNativeProps} from 'react-native';\n\tsetNativeProps(ref, nativeProps);\n");
              }
            }
            var nativeTag = maybeInstance._nativeTag || maybeInstance.canonical._nativeTag;
            var viewConfig = maybeInstance.viewConfig || maybeInstance.canonical.viewConfig;
            var updatePayload = create(nativeProps, viewConfig.validAttributes);

            if (updatePayload != null) {
              ReactNativePrivateInterface.UIManager.updateView(nativeTag, viewConfig.uiViewClassName, updatePayload);
            }
          };

          return ReactNativeComponent;
        }(React.Component);

        return ReactNativeComponent;
      };

      var emptyObject$2 = {};
      {
        Object.freeze(emptyObject$2);
      }
      var getInspectorDataForViewTag = void 0;
      {
        var traverseOwnerTreeUp = function traverseOwnerTreeUp(hierarchy, instance) {
          if (instance) {
            hierarchy.unshift(instance);
            traverseOwnerTreeUp(hierarchy, instance._debugOwner);
          }
        };

        var getOwnerHierarchy = function getOwnerHierarchy(instance) {
          var hierarchy = [];
          traverseOwnerTreeUp(hierarchy, instance);
          return hierarchy;
        };

        var lastNonHostInstance = function lastNonHostInstance(hierarchy) {
          for (var i = hierarchy.length - 1; i > 1; i--) {
            var instance = hierarchy[i];

            if (instance.tag !== HostComponent) {
              return instance;
            }
          }

          return hierarchy[0];
        };

        var getHostProps = function getHostProps(fiber) {
          var host = findCurrentHostFiber(fiber);

          if (host) {
            return host.memoizedProps || emptyObject$2;
          }

          return emptyObject$2;
        };

        var getHostNode = function getHostNode(fiber, findNodeHandle) {
          var hostNode = void 0;

          while (fiber) {
            if (fiber.stateNode !== null && fiber.tag === HostComponent) {
              hostNode = findNodeHandle(fiber.stateNode);
            }

            if (hostNode) {
              return hostNode;
            }

            fiber = fiber.child;
          }

          return null;
        };

        var createHierarchy = function createHierarchy(fiberHierarchy) {
          return fiberHierarchy.map(function (fiber) {
            return {
              name: getComponentName(fiber.type),
              getInspectorData: function getInspectorData(findNodeHandle) {
                return {
                  measure: function measure(callback) {
                    return ReactNativePrivateInterface.UIManager.measure(getHostNode(fiber, findNodeHandle), callback);
                  },
                  props: getHostProps(fiber),
                  source: fiber._debugSource
                };
              }
            };
          });
        };

        getInspectorDataForViewTag = function getInspectorDataForViewTag(viewTag) {
          var closestInstance = getInstanceFromTag(viewTag);

          if (!closestInstance) {
            return {
              hierarchy: [],
              props: emptyObject$2,
              selection: null,
              source: null
            };
          }

          var fiber = findCurrentFiberUsingSlowPath(closestInstance);
          var fiberHierarchy = getOwnerHierarchy(fiber);
          var instance = lastNonHostInstance(fiberHierarchy);
          var hierarchy = createHierarchy(fiberHierarchy);
          var props = getHostProps(instance);
          var source = instance._debugSource;
          var selection = fiberHierarchy.indexOf(instance);
          return {
            hierarchy: hierarchy,
            props: props,
            selection: selection,
            source: source
          };
        };
      }

      function setNativeProps(handle, nativeProps) {
        if (handle._nativeTag == null) {
          !(handle._nativeTag != null) ? warningWithoutStack$1(false, "setNativeProps was called with a ref that isn't a " + "native component. Use React.forwardRef to get access to the underlying native component") : void 0;
          return;
        }

        {
          warnForStyleProps(nativeProps, handle.viewConfig.validAttributes);
        }
        var updatePayload = create(nativeProps, handle.viewConfig.validAttributes);

        if (updatePayload != null) {
          ReactNativePrivateInterface.UIManager.updateView(handle._nativeTag, handle.viewConfig.uiViewClassName, updatePayload);
        }
      }

      var ReactCurrentOwner = ReactSharedInternals.ReactCurrentOwner;

      function findNodeHandle(componentOrHandle) {
        {
          var owner = ReactCurrentOwner.current;

          if (owner !== null && owner.stateNode !== null) {
            !owner.stateNode._warnedAboutRefsInRender ? warningWithoutStack$1(false, "%s is accessing findNodeHandle inside its render(). " + "render() should be a pure function of props and state. It should " + "never access something that requires stale data from the previous " + "render, such as refs. Move this logic to componentDidMount and " + "componentDidUpdate instead.", getComponentName(owner.type) || "A component") : void 0;
            owner.stateNode._warnedAboutRefsInRender = true;
          }
        }

        if (componentOrHandle == null) {
          return null;
        }

        if (typeof componentOrHandle === "number") {
          return componentOrHandle;
        }

        if (componentOrHandle._nativeTag) {
          return componentOrHandle._nativeTag;
        }

        if (componentOrHandle.canonical && componentOrHandle.canonical._nativeTag) {
          return componentOrHandle.canonical._nativeTag;
        }

        var hostInstance = void 0;
        {
          hostInstance = findHostInstanceWithWarning(componentOrHandle, "findNodeHandle");
        }

        if (hostInstance == null) {
          return hostInstance;
        }

        if (hostInstance.canonical) {
          return hostInstance.canonical._nativeTag;
        }

        return hostInstance._nativeTag;
      }

      setBatchingImplementation(batchedUpdates$1, discreteUpdates$1, flushDiscreteUpdates, batchedEventUpdates$1);

      function computeComponentStackForErrorReporting(reactTag) {
        var fiber = getInstanceFromTag(reactTag);

        if (!fiber) {
          return "";
        }

        return getStackByFiberInDevAndProd(fiber);
      }

      var roots = new Map();
      var ReactNativeRenderer = {
        NativeComponent: ReactNativeComponent(findNodeHandle, findHostInstance),
        findNodeHandle: findNodeHandle,
        dispatchCommand: function dispatchCommand(handle, command, args) {
          if (handle._nativeTag == null) {
            !(handle._nativeTag != null) ? warningWithoutStack$1(false, "dispatchCommand was called with a ref that isn't a " + "native component. Use React.forwardRef to get access to the underlying native component") : void 0;
            return;
          }

          ReactNativePrivateInterface.UIManager.dispatchViewManagerCommand(handle._nativeTag, command, args);
        },
        setNativeProps: setNativeProps,
        render: function render(element, containerTag, callback) {
          var root = roots.get(containerTag);

          if (!root) {
            root = createContainer(containerTag, LegacyRoot, false);
            roots.set(containerTag, root);
          }

          updateContainer(element, root, null, callback);
          return getPublicRootInstance(root);
        },
        unmountComponentAtNode: function unmountComponentAtNode(containerTag) {
          var root = roots.get(containerTag);

          if (root) {
            updateContainer(null, root, null, function () {
              roots.delete(containerTag);
            });
          }
        },
        unmountComponentAtNodeAndRemoveContainer: function unmountComponentAtNodeAndRemoveContainer(containerTag) {
          ReactNativeRenderer.unmountComponentAtNode(containerTag);
          ReactNativePrivateInterface.UIManager.removeRootView(containerTag);
        },
        createPortal: function createPortal(children, containerTag) {
          var key = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
          return _createPortal(children, containerTag, null, key);
        },
        unstable_batchedUpdates: batchedUpdates,
        __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED: {
          NativeMethodsMixin: NativeMethodsMixin(findNodeHandle, findHostInstance),
          computeComponentStackForErrorReporting: computeComponentStackForErrorReporting
        }
      };
      injectIntoDevTools({
        findFiberByHostInstance: getInstanceFromTag,
        getInspectorDataForViewTag: getInspectorDataForViewTag,
        bundleType: 1,
        version: ReactVersion,
        rendererPackageName: "react-native-renderer"
      });
      var ReactNativeRenderer$2 = Object.freeze({
        default: ReactNativeRenderer
      });
      var ReactNativeRenderer$3 = ReactNativeRenderer$2 && ReactNativeRenderer || ReactNativeRenderer$2;
      var reactNativeRenderer = ReactNativeRenderer$3.default || ReactNativeRenderer$3;
      module.exports = reactNativeRenderer;
    })();
  }
},89,[13,90,192,54,58,198,201],"node_modules/react-native/Libraries/Renderer/implementations/ReactNativeRenderer-dev.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  _$$_REQUIRE(_dependencyMap[0], "../Core/InitializeCore");
},90,[91],"node_modules/react-native/Libraries/ReactPrivate/ReactNativePrivateInitializeCore.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var start = Date.now();

  _$$_REQUIRE(_dependencyMap[0], "./setUpGlobals");

  _$$_REQUIRE(_dependencyMap[1], "./setUpSystrace");

  _$$_REQUIRE(_dependencyMap[2], "./setUpErrorHandling");

  _$$_REQUIRE(_dependencyMap[3], "./polyfillPromise");

  _$$_REQUIRE(_dependencyMap[4], "./setUpRegeneratorRuntime");

  _$$_REQUIRE(_dependencyMap[5], "./setUpTimers");

  _$$_REQUIRE(_dependencyMap[6], "./setUpXHR");

  _$$_REQUIRE(_dependencyMap[7], "./setUpAlert");

  _$$_REQUIRE(_dependencyMap[8], "./setUpNavigator");

  _$$_REQUIRE(_dependencyMap[9], "./setUpBatchedBridge");

  _$$_REQUIRE(_dependencyMap[10], "./setUpSegmentFetcher");

  if (__DEV__) {
    _$$_REQUIRE(_dependencyMap[11], "./checkNativeVersion");

    _$$_REQUIRE(_dependencyMap[12], "./setUpDeveloperTools");
  }

  var GlobalPerformanceLogger = _$$_REQUIRE(_dependencyMap[13], "../Utilities/GlobalPerformanceLogger");

  GlobalPerformanceLogger.markPoint('initializeCore_start', GlobalPerformanceLogger.currentTimestamp() - (Date.now() - start));
  GlobalPerformanceLogger.markPoint('initializeCore_end');
},91,[92,93,94,109,118,119,125,147,151,152,174,176,179,159],"node_modules/react-native/Libraries/Core/InitializeCore.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  if (global.GLOBAL === undefined) {
    global.GLOBAL = global;
  }

  if (global.window === undefined) {
    global.window = global;
  }

  if (global.self === undefined) {
    global.self = global;
  }

  global.process = global.process || {};
  global.process.env = global.process.env || {};

  if (!global.process.env.NODE_ENV) {
    global.process.env.NODE_ENV = __DEV__ ? 'development' : 'production';
  }
},92,[],"node_modules/react-native/Libraries/Core/setUpGlobals.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  if (global.__RCTProfileIsProfiling) {
    var Systrace = _$$_REQUIRE(_dependencyMap[0], "../Performance/Systrace");

    Systrace.installReactHook();
    Systrace.setEnabled(true);
  }
},93,[27],"node_modules/react-native/Libraries/Core/setUpSystrace.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var ExceptionsManager = _$$_REQUIRE(_dependencyMap[0], "./ExceptionsManager");

  ExceptionsManager.installConsoleErrorReporter();

  if (!global.__fbDisableExceptionsManager) {
    var handleError = function handleError(e, isFatal) {
      try {
        ExceptionsManager.handleException(e, isFatal);
      } catch (ee) {
        console.log('Failed to print error: ', ee.message);
        throw e;
      }
    };

    var ErrorUtils = _$$_REQUIRE(_dependencyMap[1], "../vendor/core/ErrorUtils");

    ErrorUtils.setGlobalHandler(handleError);
  }
},94,[95,26],"node_modules/react-native/Libraries/Core/setUpErrorHandling.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");

  var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/possibleConstructorReturn");

  var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/getPrototypeOf");

  var _inherits = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/inherits");

  var _wrapNativeSuper = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/wrapNativeSuper");

  var SyntheticError = function (_Error) {
    _inherits(SyntheticError, _Error);

    function SyntheticError() {
      var _getPrototypeOf2;

      var _this;

      _classCallCheck(this, SyntheticError);

      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
        args[_key] = arguments[_key];
      }

      _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(SyntheticError)).call.apply(_getPrototypeOf2, [this].concat(args)));
      _this.name = '';
      return _this;
    }

    return SyntheticError;
  }(_wrapNativeSuper(Error));

  var exceptionID = 0;

  function reportException(e, isFatal) {
    var NativeExceptionsManager = _$$_REQUIRE(_dependencyMap[5], "./NativeExceptionsManager").default;

    if (NativeExceptionsManager) {
      var parseErrorStack = _$$_REQUIRE(_dependencyMap[6], "./Devtools/parseErrorStack");

      var stack = parseErrorStack(e);
      var currentExceptionID = ++exceptionID;
      var originalMessage = e.message || '';
      var message = originalMessage;

      if (e.componentStack != null) {
        message += "\n\nThis error is located at:" + e.componentStack;
      }

      var namePrefix = e.name == null || e.name === '' ? '' : e.name + ": ";
      var isFromConsoleError = e.name === 'console.error';

      if (!message.startsWith(namePrefix)) {
        message = namePrefix + message;
      }

      if (!isFromConsoleError) {
        if (console._errorOriginal) {
          console._errorOriginal(message);
        } else {
          console.error(message);
        }
      }

      message = e.jsEngine == null ? message : message + ", js engine: " + e.jsEngine;
      NativeExceptionsManager.reportException({
        message: message,
        originalMessage: message === originalMessage ? null : originalMessage,
        name: e.name == null || e.name === '' ? null : e.name,
        componentStack: typeof e.componentStack === 'string' ? e.componentStack : null,
        stack: stack,
        id: currentExceptionID,
        isFatal: isFatal,
        extraData: {
          jsEngine: e.jsEngine,
          rawStack: e.stack,
          framesPopped: e.framesToPop
        }
      });

      if (__DEV__) {
        if (e.preventSymbolication === true) {
          return;
        }

        var symbolicateStackTrace = _$$_REQUIRE(_dependencyMap[7], "./Devtools/symbolicateStackTrace");

        symbolicateStackTrace(stack).then(function (prettyStack) {
          if (prettyStack) {
            var stackWithoutCollapsedFrames = prettyStack.filter(function (frame) {
              return !frame.collapse;
            });
            NativeExceptionsManager.updateExceptionMessage(message, stackWithoutCollapsedFrames, currentExceptionID);
          } else {
            throw new Error('The stack is null');
          }
        }).catch(function (error) {
          console.log('Unable to symbolicate stack trace: ' + error.message);
        });
      }
    }
  }

  function handleException(e, isFatal) {
    var error;

    if (e instanceof Error) {
      error = e;
    } else {
      error = new SyntheticError(e);
    }

    reportException(error, isFatal);
  }

  function reactConsoleErrorHandler() {
    if (!console.reportErrorsAsExceptions) {
      console._errorOriginal.apply(console, arguments);

      return;
    }

    if (arguments[0] && arguments[0].stack) {
      reportException(arguments[0], false);
    } else {
      console._errorOriginal.apply(console, arguments);

      var stringifySafe = _$$_REQUIRE(_dependencyMap[8], "../Utilities/stringifySafe");

      var str = Array.prototype.map.call(arguments, stringifySafe).join(', ');

      if (str.slice(0, 10) === '"Warning: ') {
        return;
      }

      var _error = new SyntheticError(str);

      _error.name = 'console.error';
      _error.framesToPop = (_error.framesToPop || 0) + 1;
      reportException(_error, false);
    }
  }

  function installConsoleErrorReporter() {
    if (console._errorOriginal) {
      return;
    }

    console._errorOriginal = console.error.bind(console);
    console.error = reactConsoleErrorHandler;

    if (console.reportErrorsAsExceptions === undefined) {
      console.reportErrorsAsExceptions = true;
    }
  }

  module.exports = {
    handleException: handleException,
    installConsoleErrorReporter: installConsoleErrorReporter,
    SyntheticError: SyntheticError
  };
},95,[24,32,34,37,96,99,100,102,29],"node_modules/react-native/Libraries/Core/ExceptionsManager.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var getPrototypeOf = _$$_REQUIRE(_dependencyMap[0], "./getPrototypeOf");

  var setPrototypeOf = _$$_REQUIRE(_dependencyMap[1], "./setPrototypeOf");

  var isNativeFunction = _$$_REQUIRE(_dependencyMap[2], "./isNativeFunction");

  var construct = _$$_REQUIRE(_dependencyMap[3], "./construct");

  function _wrapNativeSuper(Class) {
    var _cache = typeof Map === "function" ? new Map() : undefined;

    module.exports = _wrapNativeSuper = function _wrapNativeSuper(Class) {
      if (Class === null || !isNativeFunction(Class)) return Class;

      if (typeof Class !== "function") {
        throw new TypeError("Super expression must either be null or a function");
      }

      if (typeof _cache !== "undefined") {
        if (_cache.has(Class)) return _cache.get(Class);

        _cache.set(Class, Wrapper);
      }

      function Wrapper() {
        return construct(Class, arguments, getPrototypeOf(this).constructor);
      }

      Wrapper.prototype = Object.create(Class.prototype, {
        constructor: {
          value: Wrapper,
          enumerable: false,
          writable: true,
          configurable: true
        }
      });
      return setPrototypeOf(Wrapper, Class);
    };

    return _wrapNativeSuper(Class);
  }

  module.exports = _wrapNativeSuper;
},96,[34,38,97,98],"node_modules/@babel/runtime/helpers/wrapNativeSuper.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  function _isNativeFunction(fn) {
    return Function.toString.call(fn).indexOf("[native code]") !== -1;
  }

  module.exports = _isNativeFunction;
},97,[],"node_modules/@babel/runtime/helpers/isNativeFunction.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var setPrototypeOf = _$$_REQUIRE(_dependencyMap[0], "./setPrototypeOf");

  function isNativeReflectConstruct() {
    if (typeof Reflect === "undefined" || !Reflect.construct) return false;
    if (Reflect.construct.sham) return false;
    if (typeof Proxy === "function") return true;

    try {
      Date.prototype.toString.call(Reflect.construct(Date, [], function () {}));
      return true;
    } catch (e) {
      return false;
    }
  }

  function _construct(Parent, args, Class) {
    if (isNativeReflectConstruct()) {
      module.exports = _construct = Reflect.construct;
    } else {
      module.exports = _construct = function _construct(Parent, args, Class) {
        var a = [null];
        a.push.apply(a, args);
        var Constructor = Function.bind.apply(Parent, a);
        var instance = new Constructor();
        if (Class) setPrototypeOf(instance, Class.prototype);
        return instance;
      };
    }

    return _construct.apply(null, arguments);
  }

  module.exports = _construct;
},98,[38],"node_modules/@babel/runtime/helpers/construct.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireWildcard");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[1], "../TurboModule/TurboModuleRegistry"));

  var Platform = _$$_REQUIRE(_dependencyMap[2], "../Utilities/Platform");

  var NativeModule = TurboModuleRegistry.getEnforcing('ExceptionsManager');
  var ExceptionsManager = {
    reportFatalException: function reportFatalException(message, stack, exceptionId) {
      NativeModule.reportFatalException(message, stack, exceptionId);
    },
    reportSoftException: function reportSoftException(message, stack, exceptionId) {
      NativeModule.reportSoftException(message, stack, exceptionId);
    },
    updateExceptionMessage: function updateExceptionMessage(message, stack, exceptionId) {
      NativeModule.updateExceptionMessage(message, stack, exceptionId);
    },
    dismissRedbox: function dismissRedbox() {
      if ("android" !== 'ios' && NativeModule.dismissRedbox) {
        NativeModule.dismissRedbox();
      }
    },
    reportException: function reportException(data) {
      if ("android" !== 'ios' && NativeModule.reportException) {
        NativeModule.reportException(data);
        return;
      }

      if (data.isFatal) {
        ExceptionsManager.reportFatalException(data.message, data.stack, data.id);
      } else {
        ExceptionsManager.reportSoftException(data.message, data.stack, data.id);
      }
    }
  };
  var _default = ExceptionsManager;
  exports.default = _default;
},99,[9,11,48],"node_modules/react-native/Libraries/Core/NativeExceptionsManager.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  function parseErrorStack(e) {
    if (!e || !e.stack) {
      return [];
    }

    var stacktraceParser = _$$_REQUIRE(_dependencyMap[0], "stacktrace-parser");

    var stack = Array.isArray(e.stack) ? e.stack : stacktraceParser.parse(e.stack);
    var framesToPop = typeof e.framesToPop === 'number' ? e.framesToPop : 0;

    while (framesToPop--) {
      stack.shift();
    }

    return stack;
  }

  module.exports = parseErrorStack;
},100,[101],"node_modules/react-native/Libraries/Core/Devtools/parseErrorStack.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  (function (global, factory) {
    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : typeof define === 'function' && define.amd ? define(['exports'], factory) : (global = global || self, factory(global.stackTraceParser = {}));
  })(this, function (exports) {
    'use strict';

    var UNKNOWN_FUNCTION = '<unknown>';

    function parse(stackString) {
      var lines = stackString.split('\n');
      return lines.reduce(function (stack, line) {
        var parseResult = parseChrome(line) || parseWinjs(line) || parseGecko(line) || parseNode(line) || parseJSC(line);

        if (parseResult) {
          stack.push(parseResult);
        }

        return stack;
      }, []);
    }

    var chromeRe = /^\s*at (.*?) ?\(((?:file|https?|blob|chrome-extension|native|eval|webpack|<anonymous>|\/).*?)(?::(\d+))?(?::(\d+))?\)?\s*$/i;
    var chromeEvalRe = /\((\S*)(?::(\d+))(?::(\d+))\)/;

    function parseChrome(line) {
      var parts = chromeRe.exec(line);

      if (!parts) {
        return null;
      }

      var isNative = parts[2] && parts[2].indexOf('native') === 0;
      var isEval = parts[2] && parts[2].indexOf('eval') === 0;
      var submatch = chromeEvalRe.exec(parts[2]);

      if (isEval && submatch != null) {
        parts[2] = submatch[1];
        parts[3] = submatch[2];
        parts[4] = submatch[3];
      }

      return {
        file: !isNative ? parts[2] : null,
        methodName: parts[1] || UNKNOWN_FUNCTION,
        arguments: isNative ? [parts[2]] : [],
        lineNumber: parts[3] ? +parts[3] : null,
        column: parts[4] ? +parts[4] : null
      };
    }

    var winjsRe = /^\s*at (?:((?:\[object object\])?.+) )?\(?((?:file|ms-appx|https?|webpack|blob):.*?):(\d+)(?::(\d+))?\)?\s*$/i;

    function parseWinjs(line) {
      var parts = winjsRe.exec(line);

      if (!parts) {
        return null;
      }

      return {
        file: parts[2],
        methodName: parts[1] || UNKNOWN_FUNCTION,
        arguments: [],
        lineNumber: +parts[3],
        column: parts[4] ? +parts[4] : null
      };
    }

    var geckoRe = /^\s*(.*?)(?:\((.*?)\))?(?:^|@)((?:file|https?|blob|chrome|webpack|resource|\[native).*?|[^@]*bundle)(?::(\d+))?(?::(\d+))?\s*$/i;
    var geckoEvalRe = /(\S+) line (\d+)(?: > eval line \d+)* > eval/i;

    function parseGecko(line) {
      var parts = geckoRe.exec(line);

      if (!parts) {
        return null;
      }

      var isEval = parts[3] && parts[3].indexOf(' > eval') > -1;
      var submatch = geckoEvalRe.exec(parts[3]);

      if (isEval && submatch != null) {
        parts[3] = submatch[1];
        parts[4] = submatch[2];
        parts[5] = null;
      }

      return {
        file: parts[3],
        methodName: parts[1] || UNKNOWN_FUNCTION,
        arguments: parts[2] ? parts[2].split(',') : [],
        lineNumber: parts[4] ? +parts[4] : null,
        column: parts[5] ? +parts[5] : null
      };
    }

    var javaScriptCoreRe = /^\s*(?:([^@]*)(?:\((.*?)\))?@)?(\S.*?):(\d+)(?::(\d+))?\s*$/i;

    function parseJSC(line) {
      var parts = javaScriptCoreRe.exec(line);

      if (!parts) {
        return null;
      }

      return {
        file: parts[3],
        methodName: parts[1] || UNKNOWN_FUNCTION,
        arguments: [],
        lineNumber: +parts[4],
        column: parts[5] ? +parts[5] : null
      };
    }

    var nodeRe = /^\s*at (?:((?:\[object object\])?[^\\/]+(?: \[as \S+\])?) )?\(?(.*?):(\d+)(?::(\d+))?\)?\s*$/i;

    function parseNode(line) {
      var parts = nodeRe.exec(line);

      if (!parts) {
        return null;
      }

      return {
        file: parts[2],
        methodName: parts[1] || UNKNOWN_FUNCTION,
        arguments: [],
        lineNumber: +parts[3],
        column: parts[4] ? +parts[4] : null
      };
    }

    exports.parse = parse;
    Object.defineProperty(exports, '__esModule', {
      value: true
    });
  });
},101,[],"node_modules/stacktrace-parser/dist/stack-trace-parser.umd.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _regenerator = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/regenerator"));

  var _defineProperty2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/defineProperty"));

  var _NativeSourceCode = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../../NativeModules/specs/NativeSourceCode"));

  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

  var getDevServer = _$$_REQUIRE(_dependencyMap[4], "./getDevServer");

  var fetch;

  function isSourcedFromDisk(sourcePath) {
    return !/^http/.test(sourcePath) && /[\\/]/.test(sourcePath);
  }

  function symbolicateStackTrace(stack) {
    var devServer, stackCopy, _NativeSourceCode$get, scriptURL, foundInternalSource, response, json;

    return _regenerator.default.async(function symbolicateStackTrace$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            if (!fetch) {
              fetch = global.fetch || _$$_REQUIRE(_dependencyMap[5], "../../Network/fetch").fetch;
            }

            devServer = getDevServer();

            if (devServer.bundleLoadedFromServer) {
              _context.next = 4;
              break;
            }

            throw new Error('Bundle was not loaded from the packager');

          case 4:
            stackCopy = stack;
            _NativeSourceCode$get = _NativeSourceCode.default.getConstants(), scriptURL = _NativeSourceCode$get.scriptURL;

            if (scriptURL) {
              foundInternalSource = false;
              stackCopy = stack.map(function (frame) {
                if (frame.file == null) {
                  return frame;
                }

                if (!foundInternalSource && isSourcedFromDisk(frame.file)) {
                  return _objectSpread({}, frame, {
                    file: scriptURL
                  });
                }

                foundInternalSource = true;
                return frame;
              });
            }

            _context.next = 9;
            return _regenerator.default.awrap(fetch(devServer.url + 'symbolicate', {
              method: 'POST',
              body: JSON.stringify({
                stack: stackCopy
              })
            }));

          case 9:
            response = _context.sent;
            _context.next = 12;
            return _regenerator.default.awrap(response.json());

          case 12:
            json = _context.sent;
            return _context.abrupt("return", json.stack);

          case 14:
          case "end":
            return _context.stop();
        }
      }
    });
  }

  module.exports = symbolicateStackTrace;
},102,[1,103,46,105,106,107],"node_modules/react-native/Libraries/Core/Devtools/symbolicateStackTrace.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  module.exports = _$$_REQUIRE(_dependencyMap[0], "regenerator-runtime");
},103,[104],"node_modules/@babel/runtime/regenerator/index.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var runtime = function (exports) {
    "use strict";

    var Op = Object.prototype;
    var hasOwn = Op.hasOwnProperty;
    var undefined;
    var $Symbol = typeof Symbol === "function" ? Symbol : {};
    var iteratorSymbol = $Symbol.iterator || "@@iterator";
    var asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator";
    var toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";

    function wrap(innerFn, outerFn, self, tryLocsList) {
      var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;
      var generator = Object.create(protoGenerator.prototype);
      var context = new Context(tryLocsList || []);
      generator._invoke = makeInvokeMethod(innerFn, self, context);
      return generator;
    }

    exports.wrap = wrap;

    function tryCatch(fn, obj, arg) {
      try {
        return {
          type: "normal",
          arg: fn.call(obj, arg)
        };
      } catch (err) {
        return {
          type: "throw",
          arg: err
        };
      }
    }

    var GenStateSuspendedStart = "suspendedStart";
    var GenStateSuspendedYield = "suspendedYield";
    var GenStateExecuting = "executing";
    var GenStateCompleted = "completed";
    var ContinueSentinel = {};

    function Generator() {}

    function GeneratorFunction() {}

    function GeneratorFunctionPrototype() {}

    var IteratorPrototype = {};

    IteratorPrototype[iteratorSymbol] = function () {
      return this;
    };

    var getProto = Object.getPrototypeOf;
    var NativeIteratorPrototype = getProto && getProto(getProto(values([])));

    if (NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {
      IteratorPrototype = NativeIteratorPrototype;
    }

    var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype);
    GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype;
    GeneratorFunctionPrototype.constructor = GeneratorFunction;
    GeneratorFunctionPrototype[toStringTagSymbol] = GeneratorFunction.displayName = "GeneratorFunction";

    function defineIteratorMethods(prototype) {
      ["next", "throw", "return"].forEach(function (method) {
        prototype[method] = function (arg) {
          return this._invoke(method, arg);
        };
      });
    }

    exports.isGeneratorFunction = function (genFun) {
      var ctor = typeof genFun === "function" && genFun.constructor;
      return ctor ? ctor === GeneratorFunction || (ctor.displayName || ctor.name) === "GeneratorFunction" : false;
    };

    exports.mark = function (genFun) {
      if (Object.setPrototypeOf) {
        Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);
      } else {
        genFun.__proto__ = GeneratorFunctionPrototype;

        if (!(toStringTagSymbol in genFun)) {
          genFun[toStringTagSymbol] = "GeneratorFunction";
        }
      }

      genFun.prototype = Object.create(Gp);
      return genFun;
    };

    exports.awrap = function (arg) {
      return {
        __await: arg
      };
    };

    function AsyncIterator(generator) {
      function invoke(method, arg, resolve, reject) {
        var record = tryCatch(generator[method], generator, arg);

        if (record.type === "throw") {
          reject(record.arg);
        } else {
          var result = record.arg;
          var value = result.value;

          if (value && typeof value === "object" && hasOwn.call(value, "__await")) {
            return Promise.resolve(value.__await).then(function (value) {
              invoke("next", value, resolve, reject);
            }, function (err) {
              invoke("throw", err, resolve, reject);
            });
          }

          return Promise.resolve(value).then(function (unwrapped) {
            result.value = unwrapped;
            resolve(result);
          }, function (error) {
            return invoke("throw", error, resolve, reject);
          });
        }
      }

      var previousPromise;

      function enqueue(method, arg) {
        function callInvokeWithMethodAndArg() {
          return new Promise(function (resolve, reject) {
            invoke(method, arg, resolve, reject);
          });
        }

        return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
      }

      this._invoke = enqueue;
    }

    defineIteratorMethods(AsyncIterator.prototype);

    AsyncIterator.prototype[asyncIteratorSymbol] = function () {
      return this;
    };

    exports.AsyncIterator = AsyncIterator;

    exports.async = function (innerFn, outerFn, self, tryLocsList) {
      var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList));
      return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function (result) {
        return result.done ? result.value : iter.next();
      });
    };

    function makeInvokeMethod(innerFn, self, context) {
      var state = GenStateSuspendedStart;
      return function invoke(method, arg) {
        if (state === GenStateExecuting) {
          throw new Error("Generator is already running");
        }

        if (state === GenStateCompleted) {
          if (method === "throw") {
            throw arg;
          }

          return doneResult();
        }

        context.method = method;
        context.arg = arg;

        while (true) {
          var delegate = context.delegate;

          if (delegate) {
            var delegateResult = maybeInvokeDelegate(delegate, context);

            if (delegateResult) {
              if (delegateResult === ContinueSentinel) continue;
              return delegateResult;
            }
          }

          if (context.method === "next") {
            context.sent = context._sent = context.arg;
          } else if (context.method === "throw") {
            if (state === GenStateSuspendedStart) {
              state = GenStateCompleted;
              throw context.arg;
            }

            context.dispatchException(context.arg);
          } else if (context.method === "return") {
            context.abrupt("return", context.arg);
          }

          state = GenStateExecuting;
          var record = tryCatch(innerFn, self, context);

          if (record.type === "normal") {
            state = context.done ? GenStateCompleted : GenStateSuspendedYield;

            if (record.arg === ContinueSentinel) {
              continue;
            }

            return {
              value: record.arg,
              done: context.done
            };
          } else if (record.type === "throw") {
            state = GenStateCompleted;
            context.method = "throw";
            context.arg = record.arg;
          }
        }
      };
    }

    function maybeInvokeDelegate(delegate, context) {
      var method = delegate.iterator[context.method];

      if (method === undefined) {
        context.delegate = null;

        if (context.method === "throw") {
          if (delegate.iterator["return"]) {
            context.method = "return";
            context.arg = undefined;
            maybeInvokeDelegate(delegate, context);

            if (context.method === "throw") {
              return ContinueSentinel;
            }
          }

          context.method = "throw";
          context.arg = new TypeError("The iterator does not provide a 'throw' method");
        }

        return ContinueSentinel;
      }

      var record = tryCatch(method, delegate.iterator, context.arg);

      if (record.type === "throw") {
        context.method = "throw";
        context.arg = record.arg;
        context.delegate = null;
        return ContinueSentinel;
      }

      var info = record.arg;

      if (!info) {
        context.method = "throw";
        context.arg = new TypeError("iterator result is not an object");
        context.delegate = null;
        return ContinueSentinel;
      }

      if (info.done) {
        context[delegate.resultName] = info.value;
        context.next = delegate.nextLoc;

        if (context.method !== "return") {
          context.method = "next";
          context.arg = undefined;
        }
      } else {
        return info;
      }

      context.delegate = null;
      return ContinueSentinel;
    }

    defineIteratorMethods(Gp);
    Gp[toStringTagSymbol] = "Generator";

    Gp[iteratorSymbol] = function () {
      return this;
    };

    Gp.toString = function () {
      return "[object Generator]";
    };

    function pushTryEntry(locs) {
      var entry = {
        tryLoc: locs[0]
      };

      if (1 in locs) {
        entry.catchLoc = locs[1];
      }

      if (2 in locs) {
        entry.finallyLoc = locs[2];
        entry.afterLoc = locs[3];
      }

      this.tryEntries.push(entry);
    }

    function resetTryEntry(entry) {
      var record = entry.completion || {};
      record.type = "normal";
      delete record.arg;
      entry.completion = record;
    }

    function Context(tryLocsList) {
      this.tryEntries = [{
        tryLoc: "root"
      }];
      tryLocsList.forEach(pushTryEntry, this);
      this.reset(true);
    }

    exports.keys = function (object) {
      var keys = [];

      for (var key in object) {
        keys.push(key);
      }

      keys.reverse();
      return function next() {
        while (keys.length) {
          var key = keys.pop();

          if (key in object) {
            next.value = key;
            next.done = false;
            return next;
          }
        }

        next.done = true;
        return next;
      };
    };

    function values(iterable) {
      if (iterable) {
        var iteratorMethod = iterable[iteratorSymbol];

        if (iteratorMethod) {
          return iteratorMethod.call(iterable);
        }

        if (typeof iterable.next === "function") {
          return iterable;
        }

        if (!isNaN(iterable.length)) {
          var i = -1,
              next = function next() {
            while (++i < iterable.length) {
              if (hasOwn.call(iterable, i)) {
                next.value = iterable[i];
                next.done = false;
                return next;
              }
            }

            next.value = undefined;
            next.done = true;
            return next;
          };

          return next.next = next;
        }
      }

      return {
        next: doneResult
      };
    }

    exports.values = values;

    function doneResult() {
      return {
        value: undefined,
        done: true
      };
    }

    Context.prototype = {
      constructor: Context,
      reset: function reset(skipTempReset) {
        this.prev = 0;
        this.next = 0;
        this.sent = this._sent = undefined;
        this.done = false;
        this.delegate = null;
        this.method = "next";
        this.arg = undefined;
        this.tryEntries.forEach(resetTryEntry);

        if (!skipTempReset) {
          for (var name in this) {
            if (name.charAt(0) === "t" && hasOwn.call(this, name) && !isNaN(+name.slice(1))) {
              this[name] = undefined;
            }
          }
        }
      },
      stop: function stop() {
        this.done = true;
        var rootEntry = this.tryEntries[0];
        var rootRecord = rootEntry.completion;

        if (rootRecord.type === "throw") {
          throw rootRecord.arg;
        }

        return this.rval;
      },
      dispatchException: function dispatchException(exception) {
        if (this.done) {
          throw exception;
        }

        var context = this;

        function handle(loc, caught) {
          record.type = "throw";
          record.arg = exception;
          context.next = loc;

          if (caught) {
            context.method = "next";
            context.arg = undefined;
          }

          return !!caught;
        }

        for (var i = this.tryEntries.length - 1; i >= 0; --i) {
          var entry = this.tryEntries[i];
          var record = entry.completion;

          if (entry.tryLoc === "root") {
            return handle("end");
          }

          if (entry.tryLoc <= this.prev) {
            var hasCatch = hasOwn.call(entry, "catchLoc");
            var hasFinally = hasOwn.call(entry, "finallyLoc");

            if (hasCatch && hasFinally) {
              if (this.prev < entry.catchLoc) {
                return handle(entry.catchLoc, true);
              } else if (this.prev < entry.finallyLoc) {
                return handle(entry.finallyLoc);
              }
            } else if (hasCatch) {
              if (this.prev < entry.catchLoc) {
                return handle(entry.catchLoc, true);
              }
            } else if (hasFinally) {
              if (this.prev < entry.finallyLoc) {
                return handle(entry.finallyLoc);
              }
            } else {
              throw new Error("try statement without catch or finally");
            }
          }
        }
      },
      abrupt: function abrupt(type, arg) {
        for (var i = this.tryEntries.length - 1; i >= 0; --i) {
          var entry = this.tryEntries[i];

          if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) {
            var finallyEntry = entry;
            break;
          }
        }

        if (finallyEntry && (type === "break" || type === "continue") && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc) {
          finallyEntry = null;
        }

        var record = finallyEntry ? finallyEntry.completion : {};
        record.type = type;
        record.arg = arg;

        if (finallyEntry) {
          this.method = "next";
          this.next = finallyEntry.finallyLoc;
          return ContinueSentinel;
        }

        return this.complete(record);
      },
      complete: function complete(record, afterLoc) {
        if (record.type === "throw") {
          throw record.arg;
        }

        if (record.type === "break" || record.type === "continue") {
          this.next = record.arg;
        } else if (record.type === "return") {
          this.rval = this.arg = record.arg;
          this.method = "return";
          this.next = "end";
        } else if (record.type === "normal" && afterLoc) {
          this.next = afterLoc;
        }

        return ContinueSentinel;
      },
      finish: function finish(finallyLoc) {
        for (var i = this.tryEntries.length - 1; i >= 0; --i) {
          var entry = this.tryEntries[i];

          if (entry.finallyLoc === finallyLoc) {
            this.complete(entry.completion, entry.afterLoc);
            resetTryEntry(entry);
            return ContinueSentinel;
          }
        }
      },
      "catch": function _catch(tryLoc) {
        for (var i = this.tryEntries.length - 1; i >= 0; --i) {
          var entry = this.tryEntries[i];

          if (entry.tryLoc === tryLoc) {
            var record = entry.completion;

            if (record.type === "throw") {
              var thrown = record.arg;
              resetTryEntry(entry);
            }

            return thrown;
          }
        }

        throw new Error("illegal catch attempt");
      },
      delegateYield: function delegateYield(iterable, resultName, nextLoc) {
        this.delegate = {
          iterator: values(iterable),
          resultName: resultName,
          nextLoc: nextLoc
        };

        if (this.method === "next") {
          this.arg = undefined;
        }

        return ContinueSentinel;
      }
    };
    return exports;
  }(typeof module === "object" ? module.exports : {});

  try {
    regeneratorRuntime = runtime;
  } catch (accidentalStrictMode) {
    Function("r", "regeneratorRuntime = r")(runtime);
  }
},104,[],"node_modules/regenerator-runtime/runtime.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireWildcard");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[1], "../../TurboModule/TurboModuleRegistry"));

  var _default = TurboModuleRegistry.getEnforcing('SourceCode');

  exports.default = _default;
},105,[9,11],"node_modules/react-native/Libraries/NativeModules/specs/NativeSourceCode.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _NativeSourceCode = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../../NativeModules/specs/NativeSourceCode"));

  var _cachedDevServerURL;

  var FALLBACK = 'http://localhost:8081/';

  function getDevServer() {
    if (_cachedDevServerURL === undefined) {
      var match = _NativeSourceCode.default.getConstants().scriptURL.match(/^https?:\/\/.*?\//);

      _cachedDevServerURL = match ? match[0] : null;
    }

    return {
      url: _cachedDevServerURL || FALLBACK,
      bundleLoadedFromServer: _cachedDevServerURL !== null
    };
  }

  module.exports = getDevServer;
},106,[1,105],"node_modules/react-native/Libraries/Core/Devtools/getDevServer.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  _$$_REQUIRE(_dependencyMap[0], "whatwg-fetch");

  module.exports = {
    fetch: fetch,
    Headers: Headers,
    Request: Request,
    Response: Response
  };
},107,[108],"node_modules/react-native/Libraries/Network/fetch.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  (function (global, factory) {
    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) : typeof define === 'function' && define.amd ? define(['exports'], factory) : factory(global.WHATWGFetch = {});
  })(this, function (exports) {
    'use strict';

    var support = {
      searchParams: 'URLSearchParams' in self,
      iterable: 'Symbol' in self && 'iterator' in Symbol,
      blob: 'FileReader' in self && 'Blob' in self && function () {
        try {
          new Blob();
          return true;
        } catch (e) {
          return false;
        }
      }(),
      formData: 'FormData' in self,
      arrayBuffer: 'ArrayBuffer' in self
    };

    function isDataView(obj) {
      return obj && DataView.prototype.isPrototypeOf(obj);
    }

    if (support.arrayBuffer) {
      var viewClasses = ['[object Int8Array]', '[object Uint8Array]', '[object Uint8ClampedArray]', '[object Int16Array]', '[object Uint16Array]', '[object Int32Array]', '[object Uint32Array]', '[object Float32Array]', '[object Float64Array]'];

      var isArrayBufferView = ArrayBuffer.isView || function (obj) {
        return obj && viewClasses.indexOf(Object.prototype.toString.call(obj)) > -1;
      };
    }

    function normalizeName(name) {
      if (typeof name !== 'string') {
        name = String(name);
      }

      if (/[^a-z0-9\-#$%&'*+.^_`|~]/i.test(name)) {
        throw new TypeError('Invalid character in header field name');
      }

      return name.toLowerCase();
    }

    function normalizeValue(value) {
      if (typeof value !== 'string') {
        value = String(value);
      }

      return value;
    }

    function iteratorFor(items) {
      var iterator = {
        next: function next() {
          var value = items.shift();
          return {
            done: value === undefined,
            value: value
          };
        }
      };

      if (support.iterable) {
        iterator[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"] = function () {
          return iterator;
        };
      }

      return iterator;
    }

    function Headers(headers) {
      this.map = {};

      if (headers instanceof Headers) {
        headers.forEach(function (value, name) {
          this.append(name, value);
        }, this);
      } else if (Array.isArray(headers)) {
        headers.forEach(function (header) {
          this.append(header[0], header[1]);
        }, this);
      } else if (headers) {
        Object.getOwnPropertyNames(headers).forEach(function (name) {
          this.append(name, headers[name]);
        }, this);
      }
    }

    Headers.prototype.append = function (name, value) {
      name = normalizeName(name);
      value = normalizeValue(value);
      var oldValue = this.map[name];
      this.map[name] = oldValue ? oldValue + ', ' + value : value;
    };

    Headers.prototype['delete'] = function (name) {
      delete this.map[normalizeName(name)];
    };

    Headers.prototype.get = function (name) {
      name = normalizeName(name);
      return this.has(name) ? this.map[name] : null;
    };

    Headers.prototype.has = function (name) {
      return this.map.hasOwnProperty(normalizeName(name));
    };

    Headers.prototype.set = function (name, value) {
      this.map[normalizeName(name)] = normalizeValue(value);
    };

    Headers.prototype.forEach = function (callback, thisArg) {
      for (var name in this.map) {
        if (this.map.hasOwnProperty(name)) {
          callback.call(thisArg, this.map[name], name, this);
        }
      }
    };

    Headers.prototype.keys = function () {
      var items = [];
      this.forEach(function (value, name) {
        items.push(name);
      });
      return iteratorFor(items);
    };

    Headers.prototype.values = function () {
      var items = [];
      this.forEach(function (value) {
        items.push(value);
      });
      return iteratorFor(items);
    };

    Headers.prototype.entries = function () {
      var items = [];
      this.forEach(function (value, name) {
        items.push([name, value]);
      });
      return iteratorFor(items);
    };

    if (support.iterable) {
      Headers.prototype[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"] = Headers.prototype.entries;
    }

    function consumed(body) {
      if (body.bodyUsed) {
        return Promise.reject(new TypeError('Already read'));
      }

      body.bodyUsed = true;
    }

    function fileReaderReady(reader) {
      return new Promise(function (resolve, reject) {
        reader.onload = function () {
          resolve(reader.result);
        };

        reader.onerror = function () {
          reject(reader.error);
        };
      });
    }

    function readBlobAsArrayBuffer(blob) {
      var reader = new FileReader();
      var promise = fileReaderReady(reader);
      reader.readAsArrayBuffer(blob);
      return promise;
    }

    function readBlobAsText(blob) {
      var reader = new FileReader();
      var promise = fileReaderReady(reader);
      reader.readAsText(blob);
      return promise;
    }

    function readArrayBufferAsText(buf) {
      var view = new Uint8Array(buf);
      var chars = new Array(view.length);

      for (var i = 0; i < view.length; i++) {
        chars[i] = String.fromCharCode(view[i]);
      }

      return chars.join('');
    }

    function bufferClone(buf) {
      if (buf.slice) {
        return buf.slice(0);
      } else {
        var view = new Uint8Array(buf.byteLength);
        view.set(new Uint8Array(buf));
        return view.buffer;
      }
    }

    function Body() {
      this.bodyUsed = false;

      this._initBody = function (body) {
        this._bodyInit = body;

        if (!body) {
          this._bodyText = '';
        } else if (typeof body === 'string') {
          this._bodyText = body;
        } else if (support.blob && Blob.prototype.isPrototypeOf(body)) {
          this._bodyBlob = body;
        } else if (support.formData && FormData.prototype.isPrototypeOf(body)) {
          this._bodyFormData = body;
        } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
          this._bodyText = body.toString();
        } else if (support.arrayBuffer && support.blob && isDataView(body)) {
          this._bodyArrayBuffer = bufferClone(body.buffer);
          this._bodyInit = new Blob([this._bodyArrayBuffer]);
        } else if (support.arrayBuffer && (ArrayBuffer.prototype.isPrototypeOf(body) || isArrayBufferView(body))) {
          this._bodyArrayBuffer = bufferClone(body);
        } else {
          this._bodyText = body = Object.prototype.toString.call(body);
        }

        if (!this.headers.get('content-type')) {
          if (typeof body === 'string') {
            this.headers.set('content-type', 'text/plain;charset=UTF-8');
          } else if (this._bodyBlob && this._bodyBlob.type) {
            this.headers.set('content-type', this._bodyBlob.type);
          } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
            this.headers.set('content-type', 'application/x-www-form-urlencoded;charset=UTF-8');
          }
        }
      };

      if (support.blob) {
        this.blob = function () {
          var rejected = consumed(this);

          if (rejected) {
            return rejected;
          }

          if (this._bodyBlob) {
            return Promise.resolve(this._bodyBlob);
          } else if (this._bodyArrayBuffer) {
            return Promise.resolve(new Blob([this._bodyArrayBuffer]));
          } else if (this._bodyFormData) {
            throw new Error('could not read FormData body as blob');
          } else {
            return Promise.resolve(new Blob([this._bodyText]));
          }
        };

        this.arrayBuffer = function () {
          if (this._bodyArrayBuffer) {
            return consumed(this) || Promise.resolve(this._bodyArrayBuffer);
          } else {
            return this.blob().then(readBlobAsArrayBuffer);
          }
        };
      }

      this.text = function () {
        var rejected = consumed(this);

        if (rejected) {
          return rejected;
        }

        if (this._bodyBlob) {
          return readBlobAsText(this._bodyBlob);
        } else if (this._bodyArrayBuffer) {
          return Promise.resolve(readArrayBufferAsText(this._bodyArrayBuffer));
        } else if (this._bodyFormData) {
          throw new Error('could not read FormData body as text');
        } else {
          return Promise.resolve(this._bodyText);
        }
      };

      if (support.formData) {
        this.formData = function () {
          return this.text().then(decode);
        };
      }

      this.json = function () {
        return this.text().then(JSON.parse);
      };

      return this;
    }

    var methods = ['DELETE', 'GET', 'HEAD', 'OPTIONS', 'POST', 'PUT'];

    function normalizeMethod(method) {
      var upcased = method.toUpperCase();
      return methods.indexOf(upcased) > -1 ? upcased : method;
    }

    function Request(input, options) {
      options = options || {};
      var body = options.body;

      if (input instanceof Request) {
        if (input.bodyUsed) {
          throw new TypeError('Already read');
        }

        this.url = input.url;
        this.credentials = input.credentials;

        if (!options.headers) {
          this.headers = new Headers(input.headers);
        }

        this.method = input.method;
        this.mode = input.mode;
        this.signal = input.signal;

        if (!body && input._bodyInit != null) {
          body = input._bodyInit;
          input.bodyUsed = true;
        }
      } else {
        this.url = String(input);
      }

      this.credentials = options.credentials || this.credentials || 'same-origin';

      if (options.headers || !this.headers) {
        this.headers = new Headers(options.headers);
      }

      this.method = normalizeMethod(options.method || this.method || 'GET');
      this.mode = options.mode || this.mode || null;
      this.signal = options.signal || this.signal;
      this.referrer = null;

      if ((this.method === 'GET' || this.method === 'HEAD') && body) {
        throw new TypeError('Body not allowed for GET or HEAD requests');
      }

      this._initBody(body);
    }

    Request.prototype.clone = function () {
      return new Request(this, {
        body: this._bodyInit
      });
    };

    function decode(body) {
      var form = new FormData();
      body.trim().split('&').forEach(function (bytes) {
        if (bytes) {
          var split = bytes.split('=');
          var name = split.shift().replace(/\+/g, ' ');
          var value = split.join('=').replace(/\+/g, ' ');
          form.append(decodeURIComponent(name), decodeURIComponent(value));
        }
      });
      return form;
    }

    function parseHeaders(rawHeaders) {
      var headers = new Headers();
      var preProcessedHeaders = rawHeaders.replace(/\r?\n[\t ]+/g, ' ');
      preProcessedHeaders.split(/\r?\n/).forEach(function (line) {
        var parts = line.split(':');
        var key = parts.shift().trim();

        if (key) {
          var value = parts.join(':').trim();
          headers.append(key, value);
        }
      });
      return headers;
    }

    Body.call(Request.prototype);

    function Response(bodyInit, options) {
      if (!options) {
        options = {};
      }

      this.type = 'default';
      this.status = options.status === undefined ? 200 : options.status;
      this.ok = this.status >= 200 && this.status < 300;
      this.statusText = 'statusText' in options ? options.statusText : 'OK';
      this.headers = new Headers(options.headers);
      this.url = options.url || '';

      this._initBody(bodyInit);
    }

    Body.call(Response.prototype);

    Response.prototype.clone = function () {
      return new Response(this._bodyInit, {
        status: this.status,
        statusText: this.statusText,
        headers: new Headers(this.headers),
        url: this.url
      });
    };

    Response.error = function () {
      var response = new Response(null, {
        status: 0,
        statusText: ''
      });
      response.type = 'error';
      return response;
    };

    var redirectStatuses = [301, 302, 303, 307, 308];

    Response.redirect = function (url, status) {
      if (redirectStatuses.indexOf(status) === -1) {
        throw new RangeError('Invalid status code');
      }

      return new Response(null, {
        status: status,
        headers: {
          location: url
        }
      });
    };

    exports.DOMException = self.DOMException;

    try {
      new exports.DOMException();
    } catch (err) {
      exports.DOMException = function (message, name) {
        this.message = message;
        this.name = name;
        var error = Error(message);
        this.stack = error.stack;
      };

      exports.DOMException.prototype = Object.create(Error.prototype);
      exports.DOMException.prototype.constructor = exports.DOMException;
    }

    function fetch(input, init) {
      return new Promise(function (resolve, reject) {
        var request = new Request(input, init);

        if (request.signal && request.signal.aborted) {
          return reject(new exports.DOMException('Aborted', 'AbortError'));
        }

        var xhr = new XMLHttpRequest();

        function abortXhr() {
          xhr.abort();
        }

        xhr.onload = function () {
          var options = {
            status: xhr.status,
            statusText: xhr.statusText,
            headers: parseHeaders(xhr.getAllResponseHeaders() || '')
          };
          options.url = 'responseURL' in xhr ? xhr.responseURL : options.headers.get('X-Request-URL');
          var body = 'response' in xhr ? xhr.response : xhr.responseText;
          resolve(new Response(body, options));
        };

        xhr.onerror = function () {
          reject(new TypeError('Network request failed'));
        };

        xhr.ontimeout = function () {
          reject(new TypeError('Network request failed'));
        };

        xhr.onabort = function () {
          reject(new exports.DOMException('Aborted', 'AbortError'));
        };

        xhr.open(request.method, request.url, true);

        if (request.credentials === 'include') {
          xhr.withCredentials = true;
        } else if (request.credentials === 'omit') {
          xhr.withCredentials = false;
        }

        if ('responseType' in xhr && support.blob) {
          xhr.responseType = 'blob';
        }

        request.headers.forEach(function (value, name) {
          xhr.setRequestHeader(name, value);
        });

        if (request.signal) {
          request.signal.addEventListener('abort', abortXhr);

          xhr.onreadystatechange = function () {
            if (xhr.readyState === 4) {
              request.signal.removeEventListener('abort', abortXhr);
            }
          };
        }

        xhr.send(typeof request._bodyInit === 'undefined' ? null : request._bodyInit);
      });
    }

    fetch.polyfill = true;

    if (!self.fetch) {
      self.fetch = fetch;
      self.Headers = Headers;
      self.Request = Request;
      self.Response = Response;
    }

    exports.Headers = Headers;
    exports.Request = Request;
    exports.Response = Response;
    exports.fetch = fetch;
    Object.defineProperty(exports, '__esModule', {
      value: true
    });
  });
},108,[],"node_modules/whatwg-fetch/dist/fetch.umd.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _require = _$$_REQUIRE(_dependencyMap[0], "../Utilities/PolyfillFunctions"),
      polyfillGlobal = _require.polyfillGlobal;

  polyfillGlobal('Promise', function () {
    return _$$_REQUIRE(_dependencyMap[1], "../Promise");
  });
},109,[110,111],"node_modules/react-native/Libraries/Core/polyfillPromise.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var defineLazyObjectProperty = _$$_REQUIRE(_dependencyMap[0], "./defineLazyObjectProperty");

  function polyfillObjectProperty(object, name, getValue) {
    var descriptor = Object.getOwnPropertyDescriptor(object, name);

    if (__DEV__ && descriptor) {
      var backupName = "original" + name[0].toUpperCase() + name.substr(1);
      Object.defineProperty(object, backupName, descriptor);
    }

    var _ref = descriptor || {},
        enumerable = _ref.enumerable,
        writable = _ref.writable,
        configurable = _ref.configurable;

    if (descriptor && !configurable) {
      console.error('Failed to set polyfill. ' + name + ' is not configurable.');
      return;
    }

    defineLazyObjectProperty(object, name, {
      get: getValue,
      enumerable: enumerable !== false,
      writable: writable !== false
    });
  }

  function polyfillGlobal(name, getValue) {
    polyfillObjectProperty(global, name, getValue);
  }

  module.exports = {
    polyfillObjectProperty: polyfillObjectProperty,
    polyfillGlobal: polyfillGlobal
  };
},110,[30],"node_modules/react-native/Libraries/Utilities/PolyfillFunctions.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var Promise = _$$_REQUIRE(_dependencyMap[0], "promise/setimmediate/es6-extensions");

  _$$_REQUIRE(_dependencyMap[1], "promise/setimmediate/done");

  _$$_REQUIRE(_dependencyMap[2], "promise/setimmediate/finally");

  if (__DEV__) {
    _$$_REQUIRE(_dependencyMap[3], "promise/setimmediate/rejection-tracking").enable({
      allRejections: true,
      onUnhandled: function onUnhandled(id) {
        var error = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
        var message;
        var stack;
        var stringValue = Object.prototype.toString.call(error);

        if (stringValue === '[object Error]') {
          message = Error.prototype.toString.call(error);
          stack = error.stack;
        } else {
          message = _$$_REQUIRE(_dependencyMap[4], "pretty-format")(error);
        }

        var warning = "Possible Unhandled Promise Rejection (id: " + id + "):\n" + (message + "\n") + (stack == null ? '' : stack);
        console.warn(warning);
      },
      onHandled: function onHandled(id) {
        var warning = "Promise Rejection Handled (id: " + id + ")\n" + 'This means you can ignore any previous messages of the form ' + ("\"Possible Unhandled Promise Rejection (id: " + id + "):\"");
        console.warn(warning);
      }
    });
  }

  module.exports = Promise;
},111,[112,114,115,116,117],"node_modules/react-native/Libraries/Promise.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var Promise = _$$_REQUIRE(_dependencyMap[0], "./core.js");

  module.exports = Promise;
  var TRUE = valuePromise(true);
  var FALSE = valuePromise(false);
  var NULL = valuePromise(null);
  var UNDEFINED = valuePromise(undefined);
  var ZERO = valuePromise(0);
  var EMPTYSTRING = valuePromise('');

  function valuePromise(value) {
    var p = new Promise(Promise._61);
    p._65 = 1;
    p._55 = value;
    return p;
  }

  Promise.resolve = function (value) {
    if (value instanceof Promise) return value;
    if (value === null) return NULL;
    if (value === undefined) return UNDEFINED;
    if (value === true) return TRUE;
    if (value === false) return FALSE;
    if (value === 0) return ZERO;
    if (value === '') return EMPTYSTRING;

    if (typeof value === 'object' || typeof value === 'function') {
      try {
        var then = value.then;

        if (typeof then === 'function') {
          return new Promise(then.bind(value));
        }
      } catch (ex) {
        return new Promise(function (resolve, reject) {
          reject(ex);
        });
      }
    }

    return valuePromise(value);
  };

  Promise.all = function (arr) {
    var args = Array.prototype.slice.call(arr);
    return new Promise(function (resolve, reject) {
      if (args.length === 0) return resolve([]);
      var remaining = args.length;

      function res(i, val) {
        if (val && (typeof val === 'object' || typeof val === 'function')) {
          if (val instanceof Promise && val.then === Promise.prototype.then) {
            while (val._65 === 3) {
              val = val._55;
            }

            if (val._65 === 1) return res(i, val._55);
            if (val._65 === 2) reject(val._55);
            val.then(function (val) {
              res(i, val);
            }, reject);
            return;
          } else {
            var then = val.then;

            if (typeof then === 'function') {
              var p = new Promise(then.bind(val));
              p.then(function (val) {
                res(i, val);
              }, reject);
              return;
            }
          }
        }

        args[i] = val;

        if (--remaining === 0) {
          resolve(args);
        }
      }

      for (var i = 0; i < args.length; i++) {
        res(i, args[i]);
      }
    });
  };

  Promise.reject = function (value) {
    return new Promise(function (resolve, reject) {
      reject(value);
    });
  };

  Promise.race = function (values) {
    return new Promise(function (resolve, reject) {
      values.forEach(function (value) {
        Promise.resolve(value).then(resolve, reject);
      });
    });
  };

  Promise.prototype['catch'] = function (onRejected) {
    return this.then(null, onRejected);
  };
},112,[113],"node_modules/promise/setimmediate/es6-extensions.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  function noop() {}

  var LAST_ERROR = null;
  var IS_ERROR = {};

  function getThen(obj) {
    try {
      return obj.then;
    } catch (ex) {
      LAST_ERROR = ex;
      return IS_ERROR;
    }
  }

  function tryCallOne(fn, a) {
    try {
      return fn(a);
    } catch (ex) {
      LAST_ERROR = ex;
      return IS_ERROR;
    }
  }

  function tryCallTwo(fn, a, b) {
    try {
      fn(a, b);
    } catch (ex) {
      LAST_ERROR = ex;
      return IS_ERROR;
    }
  }

  module.exports = Promise;

  function Promise(fn) {
    if (typeof this !== 'object') {
      throw new TypeError('Promises must be constructed via new');
    }

    if (typeof fn !== 'function') {
      throw new TypeError('Promise constructor\'s argument is not a function');
    }

    this._40 = 0;
    this._65 = 0;
    this._55 = null;
    this._72 = null;
    if (fn === noop) return;
    doResolve(fn, this);
  }

  Promise._37 = null;
  Promise._87 = null;
  Promise._61 = noop;

  Promise.prototype.then = function (onFulfilled, onRejected) {
    if (this.constructor !== Promise) {
      return safeThen(this, onFulfilled, onRejected);
    }

    var res = new Promise(noop);
    handle(this, new Handler(onFulfilled, onRejected, res));
    return res;
  };

  function safeThen(self, onFulfilled, onRejected) {
    return new self.constructor(function (resolve, reject) {
      var res = new Promise(noop);
      res.then(resolve, reject);
      handle(self, new Handler(onFulfilled, onRejected, res));
    });
  }

  function handle(self, deferred) {
    while (self._65 === 3) {
      self = self._55;
    }

    if (Promise._37) {
      Promise._37(self);
    }

    if (self._65 === 0) {
      if (self._40 === 0) {
        self._40 = 1;
        self._72 = deferred;
        return;
      }

      if (self._40 === 1) {
        self._40 = 2;
        self._72 = [self._72, deferred];
        return;
      }

      self._72.push(deferred);

      return;
    }

    handleResolved(self, deferred);
  }

  function handleResolved(self, deferred) {
    setImmediate(function () {
      var cb = self._65 === 1 ? deferred.onFulfilled : deferred.onRejected;

      if (cb === null) {
        if (self._65 === 1) {
          resolve(deferred.promise, self._55);
        } else {
          reject(deferred.promise, self._55);
        }

        return;
      }

      var ret = tryCallOne(cb, self._55);

      if (ret === IS_ERROR) {
        reject(deferred.promise, LAST_ERROR);
      } else {
        resolve(deferred.promise, ret);
      }
    });
  }

  function resolve(self, newValue) {
    if (newValue === self) {
      return reject(self, new TypeError('A promise cannot be resolved with itself.'));
    }

    if (newValue && (typeof newValue === 'object' || typeof newValue === 'function')) {
      var then = getThen(newValue);

      if (then === IS_ERROR) {
        return reject(self, LAST_ERROR);
      }

      if (then === self.then && newValue instanceof Promise) {
        self._65 = 3;
        self._55 = newValue;
        finale(self);
        return;
      } else if (typeof then === 'function') {
        doResolve(then.bind(newValue), self);
        return;
      }
    }

    self._65 = 1;
    self._55 = newValue;
    finale(self);
  }

  function reject(self, newValue) {
    self._65 = 2;
    self._55 = newValue;

    if (Promise._87) {
      Promise._87(self, newValue);
    }

    finale(self);
  }

  function finale(self) {
    if (self._40 === 1) {
      handle(self, self._72);
      self._72 = null;
    }

    if (self._40 === 2) {
      for (var i = 0; i < self._72.length; i++) {
        handle(self, self._72[i]);
      }

      self._72 = null;
    }
  }

  function Handler(onFulfilled, onRejected, promise) {
    this.onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : null;
    this.onRejected = typeof onRejected === 'function' ? onRejected : null;
    this.promise = promise;
  }

  function doResolve(fn, promise) {
    var done = false;
    var res = tryCallTwo(fn, function (value) {
      if (done) return;
      done = true;
      resolve(promise, value);
    }, function (reason) {
      if (done) return;
      done = true;
      reject(promise, reason);
    });

    if (!done && res === IS_ERROR) {
      done = true;
      reject(promise, LAST_ERROR);
    }
  }
},113,[],"node_modules/promise/setimmediate/core.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var Promise = _$$_REQUIRE(_dependencyMap[0], "./core.js");

  module.exports = Promise;

  Promise.prototype.done = function (onFulfilled, onRejected) {
    var self = arguments.length ? this.then.apply(this, arguments) : this;
    self.then(null, function (err) {
      setTimeout(function () {
        throw err;
      }, 0);
    });
  };
},114,[113],"node_modules/promise/setimmediate/done.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var Promise = _$$_REQUIRE(_dependencyMap[0], "./core.js");

  module.exports = Promise;

  Promise.prototype['finally'] = function (f) {
    return this.then(function (value) {
      return Promise.resolve(f()).then(function () {
        return value;
      });
    }, function (err) {
      return Promise.resolve(f()).then(function () {
        throw err;
      });
    });
  };
},115,[113],"node_modules/promise/setimmediate/finally.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var Promise = _$$_REQUIRE(_dependencyMap[0], "./core");

  var DEFAULT_WHITELIST = [ReferenceError, TypeError, RangeError];
  var enabled = false;
  exports.disable = disable;

  function disable() {
    enabled = false;
    Promise._37 = null;
    Promise._87 = null;
  }

  exports.enable = enable;

  function enable(options) {
    options = options || {};
    if (enabled) disable();
    enabled = true;
    var id = 0;
    var displayId = 0;
    var rejections = {};

    Promise._37 = function (promise) {
      if (promise._65 === 2 && rejections[promise._51]) {
        if (rejections[promise._51].logged) {
          onHandled(promise._51);
        } else {
          clearTimeout(rejections[promise._51].timeout);
        }

        delete rejections[promise._51];
      }
    };

    Promise._87 = function (promise, err) {
      if (promise._40 === 0) {
        promise._51 = id++;
        rejections[promise._51] = {
          displayId: null,
          error: err,
          timeout: setTimeout(onUnhandled.bind(null, promise._51), matchWhitelist(err, DEFAULT_WHITELIST) ? 100 : 2000),
          logged: false
        };
      }
    };

    function onUnhandled(id) {
      if (options.allRejections || matchWhitelist(rejections[id].error, options.whitelist || DEFAULT_WHITELIST)) {
        rejections[id].displayId = displayId++;

        if (options.onUnhandled) {
          rejections[id].logged = true;
          options.onUnhandled(rejections[id].displayId, rejections[id].error);
        } else {
          rejections[id].logged = true;
          logError(rejections[id].displayId, rejections[id].error);
        }
      }
    }

    function onHandled(id) {
      if (rejections[id].logged) {
        if (options.onHandled) {
          options.onHandled(rejections[id].displayId, rejections[id].error);
        } else if (!rejections[id].onUnhandled) {
          console.warn('Promise Rejection Handled (id: ' + rejections[id].displayId + '):');
          console.warn('  This means you can ignore any previous messages of the form "Possible Unhandled Promise Rejection" with id ' + rejections[id].displayId + '.');
        }
      }
    }
  }

  function logError(id, error) {
    console.warn('Possible Unhandled Promise Rejection (id: ' + id + '):');
    var errStr = (error && (error.stack || error)) + '';
    errStr.split('\n').forEach(function (line) {
      console.warn('  ' + line);
    });
  }

  function matchWhitelist(error, list) {
    return list.some(function (cls) {
      return error instanceof cls;
    });
  }
},116,[113],"node_modules/promise/setimmediate/rejection-tracking.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");

  (function webpackUniversalModuleDefinition(root, factory) {
    if (typeof exports === 'object' && typeof module === 'object') module.exports = factory();else if (typeof define === 'function' && define.amd) define([], factory);else if (typeof exports === 'object') exports["prettyFormat"] = factory();else root["prettyFormat"] = factory();
  })(window, function () {
    return function (modules) {
      var installedModules = {};

      function __webpack_require__(moduleId) {
        if (installedModules[moduleId]) {
          return installedModules[moduleId].exports;
        }

        var module = installedModules[moduleId] = {
          i: moduleId,
          l: false,
          exports: {}
        };
        modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
        module.l = true;
        return module.exports;
      }

      __webpack_require__.m = modules;
      __webpack_require__.c = installedModules;

      __webpack_require__.d = function (exports, name, getter) {
        if (!__webpack_require__.o(exports, name)) {
          Object.defineProperty(exports, name, {
            enumerable: true,
            get: getter
          });
        }
      };

      __webpack_require__.r = function (exports) {
        if (typeof Symbol !== 'undefined' && (typeof Symbol === "function" ? Symbol.toStringTag : "@@toStringTag")) {
          Object.defineProperty(exports, typeof Symbol === "function" ? Symbol.toStringTag : "@@toStringTag", {
            value: 'Module'
          });
        }

        Object.defineProperty(exports, '__esModule', {
          value: true
        });
      };

      __webpack_require__.t = function (value, mode) {
        if (mode & 1) value = __webpack_require__(value);
        if (mode & 8) return value;
        if (mode & 4 && typeof value === 'object' && value && value.__esModule) return value;
        var ns = Object.create(null);

        __webpack_require__.r(ns);

        Object.defineProperty(ns, 'default', {
          enumerable: true,
          value: value
        });
        if (mode & 2 && typeof value != 'string') for (var key in value) {
          __webpack_require__.d(ns, key, function (key) {
            return value[key];
          }.bind(null, key));
        }
        return ns;
      };

      __webpack_require__.n = function (module) {
        var getter = module && module.__esModule ? function getDefault() {
          return module['default'];
        } : function getModuleExports() {
          return module;
        };

        __webpack_require__.d(getter, 'a', getter);

        return getter;
      };

      __webpack_require__.o = function (object, property) {
        return Object.prototype.hasOwnProperty.call(object, property);
      };

      __webpack_require__.p = "";
      return __webpack_require__(__webpack_require__.s = "./packages/pretty-format/src/index.ts");
    }({
      "./node_modules/ansi-regex/index.js": function node_modulesAnsiRegexIndexJs(module, exports, __webpack_require__) {
        "use strict";

        module.exports = function (options) {
          options = _extends({
            onlyFirst: false
          }, options);
          var pattern = ["[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:[a-zA-Z\\d]*(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)", '(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))'].join('|');
          return new RegExp(pattern, options.onlyFirst ? undefined : 'g');
        };
      },
      "./node_modules/ansi-styles/index.js": function node_modulesAnsiStylesIndexJs(module, exports, __webpack_require__) {
        "use strict";

        (function (module) {
          function _typeof(obj) {
            if (typeof Symbol === "function" && typeof (typeof Symbol === "function" ? Symbol.iterator : "@@iterator") === "symbol") {
              _typeof = function _typeof(obj) {
                return typeof obj;
              };
            } else {
              _typeof = function _typeof(obj) {
                return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== (typeof Symbol === "function" ? Symbol.prototype : "@@prototype") ? "symbol" : typeof obj;
              };
            }

            return _typeof(obj);
          }

          var colorConvert = __webpack_require__("./node_modules/color-convert/index.js");

          var wrapAnsi16 = function wrapAnsi16(fn, offset) {
            return function () {
              var code = fn.apply(colorConvert, arguments);
              return "\x1B[".concat(code + offset, "m");
            };
          };

          var wrapAnsi256 = function wrapAnsi256(fn, offset) {
            return function () {
              var code = fn.apply(colorConvert, arguments);
              return "\x1B[".concat(38 + offset, ";5;").concat(code, "m");
            };
          };

          var wrapAnsi16m = function wrapAnsi16m(fn, offset) {
            return function () {
              var rgb = fn.apply(colorConvert, arguments);
              return "\x1B[".concat(38 + offset, ";2;").concat(rgb[0], ";").concat(rgb[1], ";").concat(rgb[2], "m");
            };
          };

          function assembleStyles() {
            var codes = new Map();
            var styles = {
              modifier: {
                reset: [0, 0],
                bold: [1, 22],
                dim: [2, 22],
                italic: [3, 23],
                underline: [4, 24],
                inverse: [7, 27],
                hidden: [8, 28],
                strikethrough: [9, 29]
              },
              color: {
                black: [30, 39],
                red: [31, 39],
                green: [32, 39],
                yellow: [33, 39],
                blue: [34, 39],
                magenta: [35, 39],
                cyan: [36, 39],
                white: [37, 39],
                gray: [90, 39],
                redBright: [91, 39],
                greenBright: [92, 39],
                yellowBright: [93, 39],
                blueBright: [94, 39],
                magentaBright: [95, 39],
                cyanBright: [96, 39],
                whiteBright: [97, 39]
              },
              bgColor: {
                bgBlack: [40, 49],
                bgRed: [41, 49],
                bgGreen: [42, 49],
                bgYellow: [43, 49],
                bgBlue: [44, 49],
                bgMagenta: [45, 49],
                bgCyan: [46, 49],
                bgWhite: [47, 49],
                bgBlackBright: [100, 49],
                bgRedBright: [101, 49],
                bgGreenBright: [102, 49],
                bgYellowBright: [103, 49],
                bgBlueBright: [104, 49],
                bgMagentaBright: [105, 49],
                bgCyanBright: [106, 49],
                bgWhiteBright: [107, 49]
              }
            };
            styles.color.grey = styles.color.gray;

            var _arr = Object.keys(styles);

            for (var _i = 0; _i < _arr.length; _i++) {
              var groupName = _arr[_i];
              var group = styles[groupName];

              var _arr3 = Object.keys(group);

              for (var _i3 = 0; _i3 < _arr3.length; _i3++) {
                var styleName = _arr3[_i3];
                var style = group[styleName];
                styles[styleName] = {
                  open: "\x1B[".concat(style[0], "m"),
                  close: "\x1B[".concat(style[1], "m")
                };
                group[styleName] = styles[styleName];
                codes.set(style[0], style[1]);
              }

              Object.defineProperty(styles, groupName, {
                value: group,
                enumerable: false
              });
              Object.defineProperty(styles, 'codes', {
                value: codes,
                enumerable: false
              });
            }

            var ansi2ansi = function ansi2ansi(n) {
              return n;
            };

            var rgb2rgb = function rgb2rgb(r, g, b) {
              return [r, g, b];
            };

            styles.color.close = "\x1B[39m";
            styles.bgColor.close = "\x1B[49m";
            styles.color.ansi = {
              ansi: wrapAnsi16(ansi2ansi, 0)
            };
            styles.color.ansi256 = {
              ansi256: wrapAnsi256(ansi2ansi, 0)
            };
            styles.color.ansi16m = {
              rgb: wrapAnsi16m(rgb2rgb, 0)
            };
            styles.bgColor.ansi = {
              ansi: wrapAnsi16(ansi2ansi, 10)
            };
            styles.bgColor.ansi256 = {
              ansi256: wrapAnsi256(ansi2ansi, 10)
            };
            styles.bgColor.ansi16m = {
              rgb: wrapAnsi16m(rgb2rgb, 10)
            };

            var _arr2 = Object.keys(colorConvert);

            for (var _i2 = 0; _i2 < _arr2.length; _i2++) {
              var key = _arr2[_i2];

              if (_typeof(colorConvert[key]) !== 'object') {
                continue;
              }

              var suite = colorConvert[key];

              if (key === 'ansi16') {
                key = 'ansi';
              }

              if ('ansi16' in suite) {
                styles.color.ansi[key] = wrapAnsi16(suite.ansi16, 0);
                styles.bgColor.ansi[key] = wrapAnsi16(suite.ansi16, 10);
              }

              if ('ansi256' in suite) {
                styles.color.ansi256[key] = wrapAnsi256(suite.ansi256, 0);
                styles.bgColor.ansi256[key] = wrapAnsi256(suite.ansi256, 10);
              }

              if ('rgb' in suite) {
                styles.color.ansi16m[key] = wrapAnsi16m(suite.rgb, 0);
                styles.bgColor.ansi16m[key] = wrapAnsi16m(suite.rgb, 10);
              }
            }

            return styles;
          }

          Object.defineProperty(module, 'exports', {
            enumerable: true,
            get: assembleStyles
          });
        }).call(this, __webpack_require__("./node_modules/webpack/buildin/module.js")(module));
      },
      "./node_modules/color-convert/conversions.js": function node_modulesColorConvertConversionsJs(module, exports, __webpack_require__) {
        "use strict";

        var cssKeywords = __webpack_require__("./node_modules/color-name/index.js");

        var reverseKeywords = {};

        for (var key in cssKeywords) {
          if (cssKeywords.hasOwnProperty(key)) {
            reverseKeywords[cssKeywords[key]] = key;
          }
        }

        var convert = module.exports = {
          rgb: {
            channels: 3,
            labels: 'rgb'
          },
          hsl: {
            channels: 3,
            labels: 'hsl'
          },
          hsv: {
            channels: 3,
            labels: 'hsv'
          },
          hwb: {
            channels: 3,
            labels: 'hwb'
          },
          cmyk: {
            channels: 4,
            labels: 'cmyk'
          },
          xyz: {
            channels: 3,
            labels: 'xyz'
          },
          lab: {
            channels: 3,
            labels: 'lab'
          },
          lch: {
            channels: 3,
            labels: 'lch'
          },
          hex: {
            channels: 1,
            labels: ['hex']
          },
          keyword: {
            channels: 1,
            labels: ['keyword']
          },
          ansi16: {
            channels: 1,
            labels: ['ansi16']
          },
          ansi256: {
            channels: 1,
            labels: ['ansi256']
          },
          hcg: {
            channels: 3,
            labels: ['h', 'c', 'g']
          },
          apple: {
            channels: 3,
            labels: ['r16', 'g16', 'b16']
          },
          gray: {
            channels: 1,
            labels: ['gray']
          }
        };

        for (var model in convert) {
          if (convert.hasOwnProperty(model)) {
            if (!('channels' in convert[model])) {
              throw new Error('missing channels property: ' + model);
            }

            if (!('labels' in convert[model])) {
              throw new Error('missing channel labels property: ' + model);
            }

            if (convert[model].labels.length !== convert[model].channels) {
              throw new Error('channel and label counts mismatch: ' + model);
            }

            var channels = convert[model].channels;
            var labels = convert[model].labels;
            delete convert[model].channels;
            delete convert[model].labels;
            Object.defineProperty(convert[model], 'channels', {
              value: channels
            });
            Object.defineProperty(convert[model], 'labels', {
              value: labels
            });
          }
        }

        convert.rgb.hsl = function (rgb) {
          var r = rgb[0] / 255;
          var g = rgb[1] / 255;
          var b = rgb[2] / 255;
          var min = Math.min(r, g, b);
          var max = Math.max(r, g, b);
          var delta = max - min;
          var h;
          var s;
          var l;

          if (max === min) {
            h = 0;
          } else if (r === max) {
            h = (g - b) / delta;
          } else if (g === max) {
            h = 2 + (b - r) / delta;
          } else if (b === max) {
            h = 4 + (r - g) / delta;
          }

          h = Math.min(h * 60, 360);

          if (h < 0) {
            h += 360;
          }

          l = (min + max) / 2;

          if (max === min) {
            s = 0;
          } else if (l <= 0.5) {
            s = delta / (max + min);
          } else {
            s = delta / (2 - max - min);
          }

          return [h, s * 100, l * 100];
        };

        convert.rgb.hsv = function (rgb) {
          var rdif;
          var gdif;
          var bdif;
          var h;
          var s;
          var r = rgb[0] / 255;
          var g = rgb[1] / 255;
          var b = rgb[2] / 255;
          var v = Math.max(r, g, b);
          var diff = v - Math.min(r, g, b);

          var diffc = function diffc(c) {
            return (v - c) / 6 / diff + 1 / 2;
          };

          if (diff === 0) {
            h = s = 0;
          } else {
            s = diff / v;
            rdif = diffc(r);
            gdif = diffc(g);
            bdif = diffc(b);

            if (r === v) {
              h = bdif - gdif;
            } else if (g === v) {
              h = 1 / 3 + rdif - bdif;
            } else if (b === v) {
              h = 2 / 3 + gdif - rdif;
            }

            if (h < 0) {
              h += 1;
            } else if (h > 1) {
              h -= 1;
            }
          }

          return [h * 360, s * 100, v * 100];
        };

        convert.rgb.hwb = function (rgb) {
          var r = rgb[0];
          var g = rgb[1];
          var b = rgb[2];
          var h = convert.rgb.hsl(rgb)[0];
          var w = 1 / 255 * Math.min(r, Math.min(g, b));
          b = 1 - 1 / 255 * Math.max(r, Math.max(g, b));
          return [h, w * 100, b * 100];
        };

        convert.rgb.cmyk = function (rgb) {
          var r = rgb[0] / 255;
          var g = rgb[1] / 255;
          var b = rgb[2] / 255;
          var c;
          var m;
          var y;
          var k;
          k = Math.min(1 - r, 1 - g, 1 - b);
          c = (1 - r - k) / (1 - k) || 0;
          m = (1 - g - k) / (1 - k) || 0;
          y = (1 - b - k) / (1 - k) || 0;
          return [c * 100, m * 100, y * 100, k * 100];
        };

        function comparativeDistance(x, y) {
          return Math.pow(x[0] - y[0], 2) + Math.pow(x[1] - y[1], 2) + Math.pow(x[2] - y[2], 2);
        }

        convert.rgb.keyword = function (rgb) {
          var reversed = reverseKeywords[rgb];

          if (reversed) {
            return reversed;
          }

          var currentClosestDistance = Infinity;
          var currentClosestKeyword;

          for (var keyword in cssKeywords) {
            if (cssKeywords.hasOwnProperty(keyword)) {
              var value = cssKeywords[keyword];
              var distance = comparativeDistance(rgb, value);

              if (distance < currentClosestDistance) {
                currentClosestDistance = distance;
                currentClosestKeyword = keyword;
              }
            }
          }

          return currentClosestKeyword;
        };

        convert.keyword.rgb = function (keyword) {
          return cssKeywords[keyword];
        };

        convert.rgb.xyz = function (rgb) {
          var r = rgb[0] / 255;
          var g = rgb[1] / 255;
          var b = rgb[2] / 255;
          r = r > 0.04045 ? Math.pow((r + 0.055) / 1.055, 2.4) : r / 12.92;
          g = g > 0.04045 ? Math.pow((g + 0.055) / 1.055, 2.4) : g / 12.92;
          b = b > 0.04045 ? Math.pow((b + 0.055) / 1.055, 2.4) : b / 12.92;
          var x = r * 0.4124 + g * 0.3576 + b * 0.1805;
          var y = r * 0.2126 + g * 0.7152 + b * 0.0722;
          var z = r * 0.0193 + g * 0.1192 + b * 0.9505;
          return [x * 100, y * 100, z * 100];
        };

        convert.rgb.lab = function (rgb) {
          var xyz = convert.rgb.xyz(rgb);
          var x = xyz[0];
          var y = xyz[1];
          var z = xyz[2];
          var l;
          var a;
          var b;
          x /= 95.047;
          y /= 100;
          z /= 108.883;
          x = x > 0.008856 ? Math.pow(x, 1 / 3) : 7.787 * x + 16 / 116;
          y = y > 0.008856 ? Math.pow(y, 1 / 3) : 7.787 * y + 16 / 116;
          z = z > 0.008856 ? Math.pow(z, 1 / 3) : 7.787 * z + 16 / 116;
          l = 116 * y - 16;
          a = 500 * (x - y);
          b = 200 * (y - z);
          return [l, a, b];
        };

        convert.hsl.rgb = function (hsl) {
          var h = hsl[0] / 360;
          var s = hsl[1] / 100;
          var l = hsl[2] / 100;
          var t1;
          var t2;
          var t3;
          var rgb;
          var val;

          if (s === 0) {
            val = l * 255;
            return [val, val, val];
          }

          if (l < 0.5) {
            t2 = l * (1 + s);
          } else {
            t2 = l + s - l * s;
          }

          t1 = 2 * l - t2;
          rgb = [0, 0, 0];

          for (var i = 0; i < 3; i++) {
            t3 = h + 1 / 3 * -(i - 1);

            if (t3 < 0) {
              t3++;
            }

            if (t3 > 1) {
              t3--;
            }

            if (6 * t3 < 1) {
              val = t1 + (t2 - t1) * 6 * t3;
            } else if (2 * t3 < 1) {
              val = t2;
            } else if (3 * t3 < 2) {
              val = t1 + (t2 - t1) * (2 / 3 - t3) * 6;
            } else {
              val = t1;
            }

            rgb[i] = val * 255;
          }

          return rgb;
        };

        convert.hsl.hsv = function (hsl) {
          var h = hsl[0];
          var s = hsl[1] / 100;
          var l = hsl[2] / 100;
          var smin = s;
          var lmin = Math.max(l, 0.01);
          var sv;
          var v;
          l *= 2;
          s *= l <= 1 ? l : 2 - l;
          smin *= lmin <= 1 ? lmin : 2 - lmin;
          v = (l + s) / 2;
          sv = l === 0 ? 2 * smin / (lmin + smin) : 2 * s / (l + s);
          return [h, sv * 100, v * 100];
        };

        convert.hsv.rgb = function (hsv) {
          var h = hsv[0] / 60;
          var s = hsv[1] / 100;
          var v = hsv[2] / 100;
          var hi = Math.floor(h) % 6;
          var f = h - Math.floor(h);
          var p = 255 * v * (1 - s);
          var q = 255 * v * (1 - s * f);
          var t = 255 * v * (1 - s * (1 - f));
          v *= 255;

          switch (hi) {
            case 0:
              return [v, t, p];

            case 1:
              return [q, v, p];

            case 2:
              return [p, v, t];

            case 3:
              return [p, q, v];

            case 4:
              return [t, p, v];

            case 5:
              return [v, p, q];
          }
        };

        convert.hsv.hsl = function (hsv) {
          var h = hsv[0];
          var s = hsv[1] / 100;
          var v = hsv[2] / 100;
          var vmin = Math.max(v, 0.01);
          var lmin;
          var sl;
          var l;
          l = (2 - s) * v;
          lmin = (2 - s) * vmin;
          sl = s * vmin;
          sl /= lmin <= 1 ? lmin : 2 - lmin;
          sl = sl || 0;
          l /= 2;
          return [h, sl * 100, l * 100];
        };

        convert.hwb.rgb = function (hwb) {
          var h = hwb[0] / 360;
          var wh = hwb[1] / 100;
          var bl = hwb[2] / 100;
          var ratio = wh + bl;
          var i;
          var v;
          var f;
          var n;

          if (ratio > 1) {
            wh /= ratio;
            bl /= ratio;
          }

          i = Math.floor(6 * h);
          v = 1 - bl;
          f = 6 * h - i;

          if ((i & 0x01) !== 0) {
            f = 1 - f;
          }

          n = wh + f * (v - wh);
          var r;
          var g;
          var b;

          switch (i) {
            default:
            case 6:
            case 0:
              r = v;
              g = n;
              b = wh;
              break;

            case 1:
              r = n;
              g = v;
              b = wh;
              break;

            case 2:
              r = wh;
              g = v;
              b = n;
              break;

            case 3:
              r = wh;
              g = n;
              b = v;
              break;

            case 4:
              r = n;
              g = wh;
              b = v;
              break;

            case 5:
              r = v;
              g = wh;
              b = n;
              break;
          }

          return [r * 255, g * 255, b * 255];
        };

        convert.cmyk.rgb = function (cmyk) {
          var c = cmyk[0] / 100;
          var m = cmyk[1] / 100;
          var y = cmyk[2] / 100;
          var k = cmyk[3] / 100;
          var r;
          var g;
          var b;
          r = 1 - Math.min(1, c * (1 - k) + k);
          g = 1 - Math.min(1, m * (1 - k) + k);
          b = 1 - Math.min(1, y * (1 - k) + k);
          return [r * 255, g * 255, b * 255];
        };

        convert.xyz.rgb = function (xyz) {
          var x = xyz[0] / 100;
          var y = xyz[1] / 100;
          var z = xyz[2] / 100;
          var r;
          var g;
          var b;
          r = x * 3.2406 + y * -1.5372 + z * -0.4986;
          g = x * -0.9689 + y * 1.8758 + z * 0.0415;
          b = x * 0.0557 + y * -0.2040 + z * 1.0570;
          r = r > 0.0031308 ? 1.055 * Math.pow(r, 1.0 / 2.4) - 0.055 : r * 12.92;
          g = g > 0.0031308 ? 1.055 * Math.pow(g, 1.0 / 2.4) - 0.055 : g * 12.92;
          b = b > 0.0031308 ? 1.055 * Math.pow(b, 1.0 / 2.4) - 0.055 : b * 12.92;
          r = Math.min(Math.max(0, r), 1);
          g = Math.min(Math.max(0, g), 1);
          b = Math.min(Math.max(0, b), 1);
          return [r * 255, g * 255, b * 255];
        };

        convert.xyz.lab = function (xyz) {
          var x = xyz[0];
          var y = xyz[1];
          var z = xyz[2];
          var l;
          var a;
          var b;
          x /= 95.047;
          y /= 100;
          z /= 108.883;
          x = x > 0.008856 ? Math.pow(x, 1 / 3) : 7.787 * x + 16 / 116;
          y = y > 0.008856 ? Math.pow(y, 1 / 3) : 7.787 * y + 16 / 116;
          z = z > 0.008856 ? Math.pow(z, 1 / 3) : 7.787 * z + 16 / 116;
          l = 116 * y - 16;
          a = 500 * (x - y);
          b = 200 * (y - z);
          return [l, a, b];
        };

        convert.lab.xyz = function (lab) {
          var l = lab[0];
          var a = lab[1];
          var b = lab[2];
          var x;
          var y;
          var z;
          y = (l + 16) / 116;
          x = a / 500 + y;
          z = y - b / 200;
          var y2 = Math.pow(y, 3);
          var x2 = Math.pow(x, 3);
          var z2 = Math.pow(z, 3);
          y = y2 > 0.008856 ? y2 : (y - 16 / 116) / 7.787;
          x = x2 > 0.008856 ? x2 : (x - 16 / 116) / 7.787;
          z = z2 > 0.008856 ? z2 : (z - 16 / 116) / 7.787;
          x *= 95.047;
          y *= 100;
          z *= 108.883;
          return [x, y, z];
        };

        convert.lab.lch = function (lab) {
          var l = lab[0];
          var a = lab[1];
          var b = lab[2];
          var hr;
          var h;
          var c;
          hr = Math.atan2(b, a);
          h = hr * 360 / 2 / Math.PI;

          if (h < 0) {
            h += 360;
          }

          c = Math.sqrt(a * a + b * b);
          return [l, c, h];
        };

        convert.lch.lab = function (lch) {
          var l = lch[0];
          var c = lch[1];
          var h = lch[2];
          var a;
          var b;
          var hr;
          hr = h / 360 * 2 * Math.PI;
          a = c * Math.cos(hr);
          b = c * Math.sin(hr);
          return [l, a, b];
        };

        convert.rgb.ansi16 = function (args) {
          var r = args[0];
          var g = args[1];
          var b = args[2];
          var value = 1 in arguments ? arguments[1] : convert.rgb.hsv(args)[2];
          value = Math.round(value / 50);

          if (value === 0) {
            return 30;
          }

          var ansi = 30 + (Math.round(b / 255) << 2 | Math.round(g / 255) << 1 | Math.round(r / 255));

          if (value === 2) {
            ansi += 60;
          }

          return ansi;
        };

        convert.hsv.ansi16 = function (args) {
          return convert.rgb.ansi16(convert.hsv.rgb(args), args[2]);
        };

        convert.rgb.ansi256 = function (args) {
          var r = args[0];
          var g = args[1];
          var b = args[2];

          if (r === g && g === b) {
            if (r < 8) {
              return 16;
            }

            if (r > 248) {
              return 231;
            }

            return Math.round((r - 8) / 247 * 24) + 232;
          }

          var ansi = 16 + 36 * Math.round(r / 255 * 5) + 6 * Math.round(g / 255 * 5) + Math.round(b / 255 * 5);
          return ansi;
        };

        convert.ansi16.rgb = function (args) {
          var color = args % 10;

          if (color === 0 || color === 7) {
            if (args > 50) {
              color += 3.5;
            }

            color = color / 10.5 * 255;
            return [color, color, color];
          }

          var mult = (~~(args > 50) + 1) * 0.5;
          var r = (color & 1) * mult * 255;
          var g = (color >> 1 & 1) * mult * 255;
          var b = (color >> 2 & 1) * mult * 255;
          return [r, g, b];
        };

        convert.ansi256.rgb = function (args) {
          if (args >= 232) {
            var c = (args - 232) * 10 + 8;
            return [c, c, c];
          }

          args -= 16;
          var rem;
          var r = Math.floor(args / 36) / 5 * 255;
          var g = Math.floor((rem = args % 36) / 6) / 5 * 255;
          var b = rem % 6 / 5 * 255;
          return [r, g, b];
        };

        convert.rgb.hex = function (args) {
          var integer = ((Math.round(args[0]) & 0xFF) << 16) + ((Math.round(args[1]) & 0xFF) << 8) + (Math.round(args[2]) & 0xFF);
          var string = integer.toString(16).toUpperCase();
          return '000000'.substring(string.length) + string;
        };

        convert.hex.rgb = function (args) {
          var match = args.toString(16).match(/[a-f0-9]{6}|[a-f0-9]{3}/i);

          if (!match) {
            return [0, 0, 0];
          }

          var colorString = match[0];

          if (match[0].length === 3) {
            colorString = colorString.split('').map(function (char) {
              return char + char;
            }).join('');
          }

          var integer = parseInt(colorString, 16);
          var r = integer >> 16 & 0xFF;
          var g = integer >> 8 & 0xFF;
          var b = integer & 0xFF;
          return [r, g, b];
        };

        convert.rgb.hcg = function (rgb) {
          var r = rgb[0] / 255;
          var g = rgb[1] / 255;
          var b = rgb[2] / 255;
          var max = Math.max(Math.max(r, g), b);
          var min = Math.min(Math.min(r, g), b);
          var chroma = max - min;
          var grayscale;
          var hue;

          if (chroma < 1) {
            grayscale = min / (1 - chroma);
          } else {
            grayscale = 0;
          }

          if (chroma <= 0) {
            hue = 0;
          } else if (max === r) {
            hue = (g - b) / chroma % 6;
          } else if (max === g) {
            hue = 2 + (b - r) / chroma;
          } else {
            hue = 4 + (r - g) / chroma + 4;
          }

          hue /= 6;
          hue %= 1;
          return [hue * 360, chroma * 100, grayscale * 100];
        };

        convert.hsl.hcg = function (hsl) {
          var s = hsl[1] / 100;
          var l = hsl[2] / 100;
          var c = 1;
          var f = 0;

          if (l < 0.5) {
            c = 2.0 * s * l;
          } else {
            c = 2.0 * s * (1.0 - l);
          }

          if (c < 1.0) {
            f = (l - 0.5 * c) / (1.0 - c);
          }

          return [hsl[0], c * 100, f * 100];
        };

        convert.hsv.hcg = function (hsv) {
          var s = hsv[1] / 100;
          var v = hsv[2] / 100;
          var c = s * v;
          var f = 0;

          if (c < 1.0) {
            f = (v - c) / (1 - c);
          }

          return [hsv[0], c * 100, f * 100];
        };

        convert.hcg.rgb = function (hcg) {
          var h = hcg[0] / 360;
          var c = hcg[1] / 100;
          var g = hcg[2] / 100;

          if (c === 0.0) {
            return [g * 255, g * 255, g * 255];
          }

          var pure = [0, 0, 0];
          var hi = h % 1 * 6;
          var v = hi % 1;
          var w = 1 - v;
          var mg = 0;

          switch (Math.floor(hi)) {
            case 0:
              pure[0] = 1;
              pure[1] = v;
              pure[2] = 0;
              break;

            case 1:
              pure[0] = w;
              pure[1] = 1;
              pure[2] = 0;
              break;

            case 2:
              pure[0] = 0;
              pure[1] = 1;
              pure[2] = v;
              break;

            case 3:
              pure[0] = 0;
              pure[1] = w;
              pure[2] = 1;
              break;

            case 4:
              pure[0] = v;
              pure[1] = 0;
              pure[2] = 1;
              break;

            default:
              pure[0] = 1;
              pure[1] = 0;
              pure[2] = w;
          }

          mg = (1.0 - c) * g;
          return [(c * pure[0] + mg) * 255, (c * pure[1] + mg) * 255, (c * pure[2] + mg) * 255];
        };

        convert.hcg.hsv = function (hcg) {
          var c = hcg[1] / 100;
          var g = hcg[2] / 100;
          var v = c + g * (1.0 - c);
          var f = 0;

          if (v > 0.0) {
            f = c / v;
          }

          return [hcg[0], f * 100, v * 100];
        };

        convert.hcg.hsl = function (hcg) {
          var c = hcg[1] / 100;
          var g = hcg[2] / 100;
          var l = g * (1.0 - c) + 0.5 * c;
          var s = 0;

          if (l > 0.0 && l < 0.5) {
            s = c / (2 * l);
          } else if (l >= 0.5 && l < 1.0) {
            s = c / (2 * (1 - l));
          }

          return [hcg[0], s * 100, l * 100];
        };

        convert.hcg.hwb = function (hcg) {
          var c = hcg[1] / 100;
          var g = hcg[2] / 100;
          var v = c + g * (1.0 - c);
          return [hcg[0], (v - c) * 100, (1 - v) * 100];
        };

        convert.hwb.hcg = function (hwb) {
          var w = hwb[1] / 100;
          var b = hwb[2] / 100;
          var v = 1 - b;
          var c = v - w;
          var g = 0;

          if (c < 1) {
            g = (v - c) / (1 - c);
          }

          return [hwb[0], c * 100, g * 100];
        };

        convert.apple.rgb = function (apple) {
          return [apple[0] / 65535 * 255, apple[1] / 65535 * 255, apple[2] / 65535 * 255];
        };

        convert.rgb.apple = function (rgb) {
          return [rgb[0] / 255 * 65535, rgb[1] / 255 * 65535, rgb[2] / 255 * 65535];
        };

        convert.gray.rgb = function (args) {
          return [args[0] / 100 * 255, args[0] / 100 * 255, args[0] / 100 * 255];
        };

        convert.gray.hsl = convert.gray.hsv = function (args) {
          return [0, 0, args[0]];
        };

        convert.gray.hwb = function (gray) {
          return [0, 100, gray[0]];
        };

        convert.gray.cmyk = function (gray) {
          return [0, 0, 0, gray[0]];
        };

        convert.gray.lab = function (gray) {
          return [gray[0], 0, 0];
        };

        convert.gray.hex = function (gray) {
          var val = Math.round(gray[0] / 100 * 255) & 0xFF;
          var integer = (val << 16) + (val << 8) + val;
          var string = integer.toString(16).toUpperCase();
          return '000000'.substring(string.length) + string;
        };

        convert.rgb.gray = function (rgb) {
          var val = (rgb[0] + rgb[1] + rgb[2]) / 3;
          return [val / 255 * 100];
        };
      },
      "./node_modules/color-convert/index.js": function node_modulesColorConvertIndexJs(module, exports, __webpack_require__) {
        "use strict";

        function _typeof(obj) {
          if (typeof Symbol === "function" && typeof (typeof Symbol === "function" ? Symbol.iterator : "@@iterator") === "symbol") {
            _typeof = function _typeof(obj) {
              return typeof obj;
            };
          } else {
            _typeof = function _typeof(obj) {
              return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== (typeof Symbol === "function" ? Symbol.prototype : "@@prototype") ? "symbol" : typeof obj;
            };
          }

          return _typeof(obj);
        }

        var conversions = __webpack_require__("./node_modules/color-convert/conversions.js");

        var route = __webpack_require__("./node_modules/color-convert/route.js");

        var convert = {};
        var models = Object.keys(conversions);

        function wrapRaw(fn) {
          var wrappedFn = function wrappedFn(args) {
            if (args === undefined || args === null) {
              return args;
            }

            if (arguments.length > 1) {
              args = Array.prototype.slice.call(arguments);
            }

            return fn(args);
          };

          if ('conversion' in fn) {
            wrappedFn.conversion = fn.conversion;
          }

          return wrappedFn;
        }

        function wrapRounded(fn) {
          var wrappedFn = function wrappedFn(args) {
            if (args === undefined || args === null) {
              return args;
            }

            if (arguments.length > 1) {
              args = Array.prototype.slice.call(arguments);
            }

            var result = fn(args);

            if (_typeof(result) === 'object') {
              for (var len = result.length, i = 0; i < len; i++) {
                result[i] = Math.round(result[i]);
              }
            }

            return result;
          };

          if ('conversion' in fn) {
            wrappedFn.conversion = fn.conversion;
          }

          return wrappedFn;
        }

        models.forEach(function (fromModel) {
          convert[fromModel] = {};
          Object.defineProperty(convert[fromModel], 'channels', {
            value: conversions[fromModel].channels
          });
          Object.defineProperty(convert[fromModel], 'labels', {
            value: conversions[fromModel].labels
          });
          var routes = route(fromModel);
          var routeModels = Object.keys(routes);
          routeModels.forEach(function (toModel) {
            var fn = routes[toModel];
            convert[fromModel][toModel] = wrapRounded(fn);
            convert[fromModel][toModel].raw = wrapRaw(fn);
          });
        });
        module.exports = convert;
      },
      "./node_modules/color-convert/route.js": function node_modulesColorConvertRouteJs(module, exports, __webpack_require__) {
        "use strict";

        var conversions = __webpack_require__("./node_modules/color-convert/conversions.js");

        function buildGraph() {
          var graph = {};
          var models = Object.keys(conversions);

          for (var len = models.length, i = 0; i < len; i++) {
            graph[models[i]] = {
              distance: -1,
              parent: null
            };
          }

          return graph;
        }

        function deriveBFS(fromModel) {
          var graph = buildGraph();
          var queue = [fromModel];
          graph[fromModel].distance = 0;

          while (queue.length) {
            var current = queue.pop();
            var adjacents = Object.keys(conversions[current]);

            for (var len = adjacents.length, i = 0; i < len; i++) {
              var adjacent = adjacents[i];
              var node = graph[adjacent];

              if (node.distance === -1) {
                node.distance = graph[current].distance + 1;
                node.parent = current;
                queue.unshift(adjacent);
              }
            }
          }

          return graph;
        }

        function link(from, to) {
          return function (args) {
            return to(from(args));
          };
        }

        function wrapConversion(toModel, graph) {
          var path = [graph[toModel].parent, toModel];
          var fn = conversions[graph[toModel].parent][toModel];
          var cur = graph[toModel].parent;

          while (graph[cur].parent) {
            path.unshift(graph[cur].parent);
            fn = link(conversions[graph[cur].parent][cur], fn);
            cur = graph[cur].parent;
          }

          fn.conversion = path;
          return fn;
        }

        module.exports = function (fromModel) {
          var graph = deriveBFS(fromModel);
          var conversion = {};
          var models = Object.keys(graph);

          for (var len = models.length, i = 0; i < len; i++) {
            var toModel = models[i];
            var node = graph[toModel];

            if (node.parent === null) {
              continue;
            }

            conversion[toModel] = wrapConversion(toModel, graph);
          }

          return conversion;
        };
      },
      "./node_modules/color-name/index.js": function node_modulesColorNameIndexJs(module, exports, __webpack_require__) {
        "use strict";

        module.exports = {
          "aliceblue": [240, 248, 255],
          "antiquewhite": [250, 235, 215],
          "aqua": [0, 255, 255],
          "aquamarine": [127, 255, 212],
          "azure": [240, 255, 255],
          "beige": [245, 245, 220],
          "bisque": [255, 228, 196],
          "black": [0, 0, 0],
          "blanchedalmond": [255, 235, 205],
          "blue": [0, 0, 255],
          "blueviolet": [138, 43, 226],
          "brown": [165, 42, 42],
          "burlywood": [222, 184, 135],
          "cadetblue": [95, 158, 160],
          "chartreuse": [127, 255, 0],
          "chocolate": [210, 105, 30],
          "coral": [255, 127, 80],
          "cornflowerblue": [100, 149, 237],
          "cornsilk": [255, 248, 220],
          "crimson": [220, 20, 60],
          "cyan": [0, 255, 255],
          "darkblue": [0, 0, 139],
          "darkcyan": [0, 139, 139],
          "darkgoldenrod": [184, 134, 11],
          "darkgray": [169, 169, 169],
          "darkgreen": [0, 100, 0],
          "darkgrey": [169, 169, 169],
          "darkkhaki": [189, 183, 107],
          "darkmagenta": [139, 0, 139],
          "darkolivegreen": [85, 107, 47],
          "darkorange": [255, 140, 0],
          "darkorchid": [153, 50, 204],
          "darkred": [139, 0, 0],
          "darksalmon": [233, 150, 122],
          "darkseagreen": [143, 188, 143],
          "darkslateblue": [72, 61, 139],
          "darkslategray": [47, 79, 79],
          "darkslategrey": [47, 79, 79],
          "darkturquoise": [0, 206, 209],
          "darkviolet": [148, 0, 211],
          "deeppink": [255, 20, 147],
          "deepskyblue": [0, 191, 255],
          "dimgray": [105, 105, 105],
          "dimgrey": [105, 105, 105],
          "dodgerblue": [30, 144, 255],
          "firebrick": [178, 34, 34],
          "floralwhite": [255, 250, 240],
          "forestgreen": [34, 139, 34],
          "fuchsia": [255, 0, 255],
          "gainsboro": [220, 220, 220],
          "ghostwhite": [248, 248, 255],
          "gold": [255, 215, 0],
          "goldenrod": [218, 165, 32],
          "gray": [128, 128, 128],
          "green": [0, 128, 0],
          "greenyellow": [173, 255, 47],
          "grey": [128, 128, 128],
          "honeydew": [240, 255, 240],
          "hotpink": [255, 105, 180],
          "indianred": [205, 92, 92],
          "indigo": [75, 0, 130],
          "ivory": [255, 255, 240],
          "khaki": [240, 230, 140],
          "lavender": [230, 230, 250],
          "lavenderblush": [255, 240, 245],
          "lawngreen": [124, 252, 0],
          "lemonchiffon": [255, 250, 205],
          "lightblue": [173, 216, 230],
          "lightcoral": [240, 128, 128],
          "lightcyan": [224, 255, 255],
          "lightgoldenrodyellow": [250, 250, 210],
          "lightgray": [211, 211, 211],
          "lightgreen": [144, 238, 144],
          "lightgrey": [211, 211, 211],
          "lightpink": [255, 182, 193],
          "lightsalmon": [255, 160, 122],
          "lightseagreen": [32, 178, 170],
          "lightskyblue": [135, 206, 250],
          "lightslategray": [119, 136, 153],
          "lightslategrey": [119, 136, 153],
          "lightsteelblue": [176, 196, 222],
          "lightyellow": [255, 255, 224],
          "lime": [0, 255, 0],
          "limegreen": [50, 205, 50],
          "linen": [250, 240, 230],
          "magenta": [255, 0, 255],
          "maroon": [128, 0, 0],
          "mediumaquamarine": [102, 205, 170],
          "mediumblue": [0, 0, 205],
          "mediumorchid": [186, 85, 211],
          "mediumpurple": [147, 112, 219],
          "mediumseagreen": [60, 179, 113],
          "mediumslateblue": [123, 104, 238],
          "mediumspringgreen": [0, 250, 154],
          "mediumturquoise": [72, 209, 204],
          "mediumvioletred": [199, 21, 133],
          "midnightblue": [25, 25, 112],
          "mintcream": [245, 255, 250],
          "mistyrose": [255, 228, 225],
          "moccasin": [255, 228, 181],
          "navajowhite": [255, 222, 173],
          "navy": [0, 0, 128],
          "oldlace": [253, 245, 230],
          "olive": [128, 128, 0],
          "olivedrab": [107, 142, 35],
          "orange": [255, 165, 0],
          "orangered": [255, 69, 0],
          "orchid": [218, 112, 214],
          "palegoldenrod": [238, 232, 170],
          "palegreen": [152, 251, 152],
          "paleturquoise": [175, 238, 238],
          "palevioletred": [219, 112, 147],
          "papayawhip": [255, 239, 213],
          "peachpuff": [255, 218, 185],
          "peru": [205, 133, 63],
          "pink": [255, 192, 203],
          "plum": [221, 160, 221],
          "powderblue": [176, 224, 230],
          "purple": [128, 0, 128],
          "rebeccapurple": [102, 51, 153],
          "red": [255, 0, 0],
          "rosybrown": [188, 143, 143],
          "royalblue": [65, 105, 225],
          "saddlebrown": [139, 69, 19],
          "salmon": [250, 128, 114],
          "sandybrown": [244, 164, 96],
          "seagreen": [46, 139, 87],
          "seashell": [255, 245, 238],
          "sienna": [160, 82, 45],
          "silver": [192, 192, 192],
          "skyblue": [135, 206, 235],
          "slateblue": [106, 90, 205],
          "slategray": [112, 128, 144],
          "slategrey": [112, 128, 144],
          "snow": [255, 250, 250],
          "springgreen": [0, 255, 127],
          "steelblue": [70, 130, 180],
          "tan": [210, 180, 140],
          "teal": [0, 128, 128],
          "thistle": [216, 191, 216],
          "tomato": [255, 99, 71],
          "turquoise": [64, 224, 208],
          "violet": [238, 130, 238],
          "wheat": [245, 222, 179],
          "white": [255, 255, 255],
          "whitesmoke": [245, 245, 245],
          "yellow": [255, 255, 0],
          "yellowgreen": [154, 205, 50]
        };
      },
      "./node_modules/react-is/cjs/react-is.development.js": function node_modulesReactIsCjsReactIsDevelopmentJs(module, exports, __webpack_require__) {
        "use strict";
        /** @license React v16.8.6
         * react-is.development.js
         *
         * 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.
         */

        function _typeof(obj) {
          if (typeof Symbol === "function" && typeof (typeof Symbol === "function" ? Symbol.iterator : "@@iterator") === "symbol") {
            _typeof = function _typeof(obj) {
              return typeof obj;
            };
          } else {
            _typeof = function _typeof(obj) {
              return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== (typeof Symbol === "function" ? Symbol.prototype : "@@prototype") ? "symbol" : typeof obj;
            };
          }

          return _typeof(obj);
        }

        if (true) {
          (function () {
            'use strict';

            Object.defineProperty(exports, '__esModule', {
              value: true
            });
            var hasSymbol = typeof Symbol === 'function' && (typeof Symbol === "function" ? Symbol.for : "@@for");
            var REACT_ELEMENT_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.element') : 0xeac7;
            var REACT_PORTAL_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.portal') : 0xeaca;
            var REACT_FRAGMENT_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.fragment') : 0xeacb;
            var REACT_STRICT_MODE_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.strict_mode') : 0xeacc;
            var REACT_PROFILER_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.profiler') : 0xead2;
            var REACT_PROVIDER_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.provider') : 0xeacd;
            var REACT_CONTEXT_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.context') : 0xeace;
            var REACT_ASYNC_MODE_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.async_mode') : 0xeacf;
            var REACT_CONCURRENT_MODE_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.concurrent_mode') : 0xeacf;
            var REACT_FORWARD_REF_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.forward_ref') : 0xead0;
            var REACT_SUSPENSE_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.suspense') : 0xead1;
            var REACT_MEMO_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.memo') : 0xead3;
            var REACT_LAZY_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.lazy') : 0xead4;

            function isValidElementType(type) {
              return typeof type === 'string' || typeof type === 'function' || type === REACT_FRAGMENT_TYPE || type === REACT_CONCURRENT_MODE_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || _typeof(type) === 'object' && type !== null && (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE);
            }

            var lowPriorityWarning = function lowPriorityWarning() {};

            {
              var printWarning = function printWarning(format) {
                for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
                  args[_key - 1] = arguments[_key];
                }

                var argIndex = 0;
                var message = 'Warning: ' + format.replace(/%s/g, function () {
                  return args[argIndex++];
                });

                if (typeof console !== 'undefined') {
                  console.warn(message);
                }

                try {
                  throw new Error(message);
                } catch (x) {}
              };

              lowPriorityWarning = function lowPriorityWarning(condition, format) {
                if (format === undefined) {
                  throw new Error('`lowPriorityWarning(condition, format, ...args)` requires a warning ' + 'message argument');
                }

                if (!condition) {
                  for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
                    args[_key2 - 2] = arguments[_key2];
                  }

                  printWarning.apply(undefined, [format].concat(args));
                }
              };
            }
            var lowPriorityWarning$1 = lowPriorityWarning;

            function typeOf(object) {
              if (_typeof(object) === 'object' && object !== null) {
                var $$typeof = object.$$typeof;

                switch ($$typeof) {
                  case REACT_ELEMENT_TYPE:
                    var type = object.type;

                    switch (type) {
                      case REACT_ASYNC_MODE_TYPE:
                      case REACT_CONCURRENT_MODE_TYPE:
                      case REACT_FRAGMENT_TYPE:
                      case REACT_PROFILER_TYPE:
                      case REACT_STRICT_MODE_TYPE:
                      case REACT_SUSPENSE_TYPE:
                        return type;

                      default:
                        var $$typeofType = type && type.$$typeof;

                        switch ($$typeofType) {
                          case REACT_CONTEXT_TYPE:
                          case REACT_FORWARD_REF_TYPE:
                          case REACT_PROVIDER_TYPE:
                            return $$typeofType;

                          default:
                            return $$typeof;
                        }

                    }

                  case REACT_LAZY_TYPE:
                  case REACT_MEMO_TYPE:
                  case REACT_PORTAL_TYPE:
                    return $$typeof;
                }
              }

              return undefined;
            }

            var AsyncMode = REACT_ASYNC_MODE_TYPE;
            var ConcurrentMode = REACT_CONCURRENT_MODE_TYPE;
            var ContextConsumer = REACT_CONTEXT_TYPE;
            var ContextProvider = REACT_PROVIDER_TYPE;
            var Element = REACT_ELEMENT_TYPE;
            var ForwardRef = REACT_FORWARD_REF_TYPE;
            var Fragment = REACT_FRAGMENT_TYPE;
            var Lazy = REACT_LAZY_TYPE;
            var Memo = REACT_MEMO_TYPE;
            var Portal = REACT_PORTAL_TYPE;
            var Profiler = REACT_PROFILER_TYPE;
            var StrictMode = REACT_STRICT_MODE_TYPE;
            var Suspense = REACT_SUSPENSE_TYPE;
            var hasWarnedAboutDeprecatedIsAsyncMode = false;

            function isAsyncMode(object) {
              {
                if (!hasWarnedAboutDeprecatedIsAsyncMode) {
                  hasWarnedAboutDeprecatedIsAsyncMode = true;
                  lowPriorityWarning$1(false, 'The ReactIs.isAsyncMode() alias has been deprecated, ' + 'and will be removed in React 17+. Update your code to use ' + 'ReactIs.isConcurrentMode() instead. It has the exact same API.');
                }
              }
              return isConcurrentMode(object) || typeOf(object) === REACT_ASYNC_MODE_TYPE;
            }

            function isConcurrentMode(object) {
              return typeOf(object) === REACT_CONCURRENT_MODE_TYPE;
            }

            function isContextConsumer(object) {
              return typeOf(object) === REACT_CONTEXT_TYPE;
            }

            function isContextProvider(object) {
              return typeOf(object) === REACT_PROVIDER_TYPE;
            }

            function isElement(object) {
              return _typeof(object) === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
            }

            function isForwardRef(object) {
              return typeOf(object) === REACT_FORWARD_REF_TYPE;
            }

            function isFragment(object) {
              return typeOf(object) === REACT_FRAGMENT_TYPE;
            }

            function isLazy(object) {
              return typeOf(object) === REACT_LAZY_TYPE;
            }

            function isMemo(object) {
              return typeOf(object) === REACT_MEMO_TYPE;
            }

            function isPortal(object) {
              return typeOf(object) === REACT_PORTAL_TYPE;
            }

            function isProfiler(object) {
              return typeOf(object) === REACT_PROFILER_TYPE;
            }

            function isStrictMode(object) {
              return typeOf(object) === REACT_STRICT_MODE_TYPE;
            }

            function isSuspense(object) {
              return typeOf(object) === REACT_SUSPENSE_TYPE;
            }

            exports.typeOf = typeOf;
            exports.AsyncMode = AsyncMode;
            exports.ConcurrentMode = ConcurrentMode;
            exports.ContextConsumer = ContextConsumer;
            exports.ContextProvider = ContextProvider;
            exports.Element = Element;
            exports.ForwardRef = ForwardRef;
            exports.Fragment = Fragment;
            exports.Lazy = Lazy;
            exports.Memo = Memo;
            exports.Portal = Portal;
            exports.Profiler = Profiler;
            exports.StrictMode = StrictMode;
            exports.Suspense = Suspense;
            exports.isValidElementType = isValidElementType;
            exports.isAsyncMode = isAsyncMode;
            exports.isConcurrentMode = isConcurrentMode;
            exports.isContextConsumer = isContextConsumer;
            exports.isContextProvider = isContextProvider;
            exports.isElement = isElement;
            exports.isForwardRef = isForwardRef;
            exports.isFragment = isFragment;
            exports.isLazy = isLazy;
            exports.isMemo = isMemo;
            exports.isPortal = isPortal;
            exports.isProfiler = isProfiler;
            exports.isStrictMode = isStrictMode;
            exports.isSuspense = isSuspense;
          })();
        }
      },
      "./node_modules/react-is/index.js": function node_modulesReactIsIndexJs(module, exports, __webpack_require__) {
        "use strict";

        if (false) {} else {
          module.exports = __webpack_require__("./node_modules/react-is/cjs/react-is.development.js");
        }
      },
      "./node_modules/webpack/buildin/module.js": function node_modulesWebpackBuildinModuleJs(module, exports, __webpack_require__) {
        "use strict";

        module.exports = function (module) {
          if (!module.webpackPolyfill) {
            module.deprecate = function () {};

            module.paths = [];
            if (!module.children) module.children = [];
            Object.defineProperty(module, "loaded", {
              enumerable: true,
              get: function get() {
                return module.l;
              }
            });
            Object.defineProperty(module, "id", {
              enumerable: true,
              get: function get() {
                return module.i;
              }
            });
            module.webpackPolyfill = 1;
          }

          return module;
        };
      },
      "./packages/pretty-format/src/collections.ts": function packagesPrettyFormatSrcCollectionsTs(module, exports, __webpack_require__) {
        "use strict";

        Object.defineProperty(exports, "__esModule", {
          value: true
        });
        exports.printIteratorEntries = printIteratorEntries;
        exports.printIteratorValues = printIteratorValues;
        exports.printListItems = printListItems;
        exports.printObjectProperties = printObjectProperties;

        var getKeysOfEnumerableProperties = function getKeysOfEnumerableProperties(object) {
          var keys = Object.keys(object).sort();

          if (Object.getOwnPropertySymbols) {
            Object.getOwnPropertySymbols(object).forEach(function (symbol) {
              if (Object.getOwnPropertyDescriptor(object, symbol).enumerable) {
                keys.push(symbol);
              }
            });
          }

          return keys;
        };

        function printIteratorEntries(iterator, config, indentation, depth, refs, printer) {
          var separator = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : ': ';
          var result = '';
          var current = iterator.next();

          if (!current.done) {
            result += config.spacingOuter;
            var indentationNext = indentation + config.indent;

            while (!current.done) {
              var name = printer(current.value[0], config, indentationNext, depth, refs);
              var value = printer(current.value[1], config, indentationNext, depth, refs);
              result += indentationNext + name + separator + value;
              current = iterator.next();

              if (!current.done) {
                result += ',' + config.spacingInner;
              } else if (!config.min) {
                result += ',';
              }
            }

            result += config.spacingOuter + indentation;
          }

          return result;
        }

        function printIteratorValues(iterator, config, indentation, depth, refs, printer) {
          var result = '';
          var current = iterator.next();

          if (!current.done) {
            result += config.spacingOuter;
            var indentationNext = indentation + config.indent;

            while (!current.done) {
              result += indentationNext + printer(current.value, config, indentationNext, depth, refs);
              current = iterator.next();

              if (!current.done) {
                result += ',' + config.spacingInner;
              } else if (!config.min) {
                result += ',';
              }
            }

            result += config.spacingOuter + indentation;
          }

          return result;
        }

        function printListItems(list, config, indentation, depth, refs, printer) {
          var result = '';

          if (list.length) {
            result += config.spacingOuter;
            var indentationNext = indentation + config.indent;

            for (var i = 0; i < list.length; i++) {
              result += indentationNext + printer(list[i], config, indentationNext, depth, refs);

              if (i < list.length - 1) {
                result += ',' + config.spacingInner;
              } else if (!config.min) {
                result += ',';
              }
            }

            result += config.spacingOuter + indentation;
          }

          return result;
        }

        function printObjectProperties(val, config, indentation, depth, refs, printer) {
          var result = '';
          var keys = getKeysOfEnumerableProperties(val);

          if (keys.length) {
            result += config.spacingOuter;
            var indentationNext = indentation + config.indent;

            for (var i = 0; i < keys.length; i++) {
              var key = keys[i];
              var name = printer(key, config, indentationNext, depth, refs);
              var value = printer(val[key], config, indentationNext, depth, refs);
              result += indentationNext + name + ': ' + value;

              if (i < keys.length - 1) {
                result += ',' + config.spacingInner;
              } else if (!config.min) {
                result += ',';
              }
            }

            result += config.spacingOuter + indentation;
          }

          return result;
        }
      },
      "./packages/pretty-format/src/index.ts": function packagesPrettyFormatSrcIndexTs(module, exports, __webpack_require__) {
        "use strict";

        var _ansiStyles = _interopRequireDefault(__webpack_require__("./node_modules/ansi-styles/index.js"));

        var _collections = __webpack_require__("./packages/pretty-format/src/collections.ts");

        var _AsymmetricMatcher = _interopRequireDefault(__webpack_require__("./packages/pretty-format/src/plugins/AsymmetricMatcher.ts"));

        var _ConvertAnsi = _interopRequireDefault(__webpack_require__("./packages/pretty-format/src/plugins/ConvertAnsi.ts"));

        var _DOMCollection = _interopRequireDefault(__webpack_require__("./packages/pretty-format/src/plugins/DOMCollection.ts"));

        var _DOMElement = _interopRequireDefault(__webpack_require__("./packages/pretty-format/src/plugins/DOMElement.ts"));

        var _Immutable = _interopRequireDefault(__webpack_require__("./packages/pretty-format/src/plugins/Immutable.ts"));

        var _ReactElement = _interopRequireDefault(__webpack_require__("./packages/pretty-format/src/plugins/ReactElement.ts"));

        var _ReactTestComponent = _interopRequireDefault(__webpack_require__("./packages/pretty-format/src/plugins/ReactTestComponent.ts"));

        function _interopRequireDefault(obj) {
          return obj && obj.__esModule ? obj : {
            default: obj
          };
        }

        function _typeof(obj) {
          if (typeof Symbol === "function" && typeof (typeof Symbol === "function" ? Symbol.iterator : "@@iterator") === "symbol") {
            _typeof = function _typeof(obj) {
              return typeof obj;
            };
          } else {
            _typeof = function _typeof(obj) {
              return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== (typeof Symbol === "function" ? Symbol.prototype : "@@prototype") ? "symbol" : typeof obj;
            };
          }

          return _typeof(obj);
        }

        function _classCallCheck(instance, Constructor) {
          if (!(instance instanceof Constructor)) {
            throw new TypeError("Cannot call a class as a function");
          }
        }

        function _possibleConstructorReturn(self, call) {
          if (call && (_typeof(call) === "object" || typeof call === "function")) {
            return call;
          }

          return _assertThisInitialized(self);
        }

        function _assertThisInitialized(self) {
          if (self === void 0) {
            throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
          }

          return self;
        }

        function _inherits(subClass, superClass) {
          if (typeof superClass !== "function" && superClass !== null) {
            throw new TypeError("Super expression must either be null or a function");
          }

          subClass.prototype = Object.create(superClass && superClass.prototype, {
            constructor: {
              value: subClass,
              writable: true,
              configurable: true
            }
          });
          if (superClass) _setPrototypeOf(subClass, superClass);
        }

        function _wrapNativeSuper(Class) {
          var _cache = typeof Map === "function" ? new Map() : undefined;

          _wrapNativeSuper = function _wrapNativeSuper(Class) {
            if (Class === null || !_isNativeFunction(Class)) return Class;

            if (typeof Class !== "function") {
              throw new TypeError("Super expression must either be null or a function");
            }

            if (typeof _cache !== "undefined") {
              if (_cache.has(Class)) return _cache.get(Class);

              _cache.set(Class, Wrapper);
            }

            function Wrapper() {
              return _construct(Class, arguments, _getPrototypeOf(this).constructor);
            }

            Wrapper.prototype = Object.create(Class.prototype, {
              constructor: {
                value: Wrapper,
                enumerable: false,
                writable: true,
                configurable: true
              }
            });
            return _setPrototypeOf(Wrapper, Class);
          };

          return _wrapNativeSuper(Class);
        }

        function isNativeReflectConstruct() {
          if (typeof Reflect === "undefined" || !Reflect.construct) return false;
          if (Reflect.construct.sham) return false;
          if (typeof Proxy === "function") return true;

          try {
            Date.prototype.toString.call(Reflect.construct(Date, [], function () {}));
            return true;
          } catch (e) {
            return false;
          }
        }

        function _construct(Parent, args, Class) {
          if (isNativeReflectConstruct()) {
            _construct = Reflect.construct;
          } else {
            _construct = function _construct(Parent, args, Class) {
              var a = [null];
              a.push.apply(a, args);
              var Constructor = Function.bind.apply(Parent, a);
              var instance = new Constructor();
              if (Class) _setPrototypeOf(instance, Class.prototype);
              return instance;
            };
          }

          return _construct.apply(null, arguments);
        }

        function _isNativeFunction(fn) {
          return Function.toString.call(fn).indexOf("[native code]") !== -1;
        }

        function _setPrototypeOf(o, p) {
          _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
            o.__proto__ = p;
            return o;
          };

          return _setPrototypeOf(o, p);
        }

        function _getPrototypeOf(o) {
          _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
            return o.__proto__ || Object.getPrototypeOf(o);
          };
          return _getPrototypeOf(o);
        }

        var toString = Object.prototype.toString;
        var toISOString = Date.prototype.toISOString;
        var errorToString = Error.prototype.toString;
        var regExpToString = RegExp.prototype.toString;
        var symbolToString = (typeof Symbol === "function" ? Symbol.prototype : "@@prototype").toString;

        var getConstructorName = function getConstructorName(val) {
          return typeof val.constructor === 'function' && val.constructor.name || 'Object';
        };

        var isWindow = function isWindow(val) {
          return typeof window !== 'undefined' && val === window;
        };

        var SYMBOL_REGEXP = /^Symbol\((.*)\)(.*)$/;
        var NEWLINE_REGEXP = /\n/gi;

        var PrettyFormatPluginError = function (_Error) {
          _inherits(PrettyFormatPluginError, _Error);

          function PrettyFormatPluginError(message, stack) {
            var _this;

            _classCallCheck(this, PrettyFormatPluginError);

            _this = _possibleConstructorReturn(this, _getPrototypeOf(PrettyFormatPluginError).call(this, message));
            _this.stack = stack;
            _this.name = _this.constructor.name;
            return _this;
          }

          return PrettyFormatPluginError;
        }(_wrapNativeSuper(Error));

        function isToStringedArrayType(toStringed) {
          return toStringed === '[object Array]' || toStringed === '[object ArrayBuffer]' || toStringed === '[object DataView]' || toStringed === '[object Float32Array]' || toStringed === '[object Float64Array]' || toStringed === '[object Int8Array]' || toStringed === '[object Int16Array]' || toStringed === '[object Int32Array]' || toStringed === '[object Uint8Array]' || toStringed === '[object Uint8ClampedArray]' || toStringed === '[object Uint16Array]' || toStringed === '[object Uint32Array]';
        }

        function printNumber(val) {
          return Object.is(val, -0) ? '-0' : String(val);
        }

        function printBigInt(val) {
          return String("".concat(val, "n"));
        }

        function printFunction(val, printFunctionName) {
          if (!printFunctionName) {
            return '[Function]';
          }

          return '[Function ' + (val.name || 'anonymous') + ']';
        }

        function printSymbol(val) {
          return symbolToString.call(val).replace(SYMBOL_REGEXP, 'Symbol($1)');
        }

        function printError(val) {
          return '[' + errorToString.call(val) + ']';
        }

        function printBasicValue(val, printFunctionName, escapeRegex, escapeString) {
          if (val === true || val === false) {
            return '' + val;
          }

          if (val === undefined) {
            return 'undefined';
          }

          if (val === null) {
            return 'null';
          }

          var typeOf = _typeof(val);

          if (typeOf === 'number') {
            return printNumber(val);
          }

          if (typeOf === 'bigint') {
            return printBigInt(val);
          }

          if (typeOf === 'string') {
            if (escapeString) {
              return '"' + val.replace(/"|\\/g, '\\$&') + '"';
            }

            return '"' + val + '"';
          }

          if (typeOf === 'function') {
            return printFunction(val, printFunctionName);
          }

          if (typeOf === 'symbol') {
            return printSymbol(val);
          }

          var toStringed = toString.call(val);

          if (toStringed === '[object WeakMap]') {
            return 'WeakMap {}';
          }

          if (toStringed === '[object WeakSet]') {
            return 'WeakSet {}';
          }

          if (toStringed === '[object Function]' || toStringed === '[object GeneratorFunction]') {
            return printFunction(val, printFunctionName);
          }

          if (toStringed === '[object Symbol]') {
            return printSymbol(val);
          }

          if (toStringed === '[object Date]') {
            return isNaN(+val) ? 'Date { NaN }' : toISOString.call(val);
          }

          if (toStringed === '[object Error]') {
            return printError(val);
          }

          if (toStringed === '[object RegExp]') {
            if (escapeRegex) {
              return regExpToString.call(val).replace(/[\\^$*+?.()|[\]{}]/g, '\\$&');
            }

            return regExpToString.call(val);
          }

          if (val instanceof Error) {
            return printError(val);
          }

          return null;
        }

        function printComplexValue(val, config, indentation, depth, refs, hasCalledToJSON) {
          if (refs.indexOf(val) !== -1) {
            return '[Circular]';
          }

          refs = refs.slice();
          refs.push(val);
          var hitMaxDepth = ++depth > config.maxDepth;
          var min = config.min;

          if (config.callToJSON && !hitMaxDepth && val.toJSON && typeof val.toJSON === 'function' && !hasCalledToJSON) {
            return printer(val.toJSON(), config, indentation, depth, refs, true);
          }

          var toStringed = toString.call(val);

          if (toStringed === '[object Arguments]') {
            return hitMaxDepth ? '[Arguments]' : (min ? '' : 'Arguments ') + '[' + (0, _collections.printListItems)(val, config, indentation, depth, refs, printer) + ']';
          }

          if (isToStringedArrayType(toStringed)) {
            return hitMaxDepth ? '[' + val.constructor.name + ']' : (min ? '' : val.constructor.name + ' ') + '[' + (0, _collections.printListItems)(val, config, indentation, depth, refs, printer) + ']';
          }

          if (toStringed === '[object Map]') {
            return hitMaxDepth ? '[Map]' : 'Map {' + (0, _collections.printIteratorEntries)(val.entries(), config, indentation, depth, refs, printer, ' => ') + '}';
          }

          if (toStringed === '[object Set]') {
            return hitMaxDepth ? '[Set]' : 'Set {' + (0, _collections.printIteratorValues)(val.values(), config, indentation, depth, refs, printer) + '}';
          }

          return hitMaxDepth || isWindow(val) ? '[' + getConstructorName(val) + ']' : (min ? '' : getConstructorName(val) + ' ') + '{' + (0, _collections.printObjectProperties)(val, config, indentation, depth, refs, printer) + '}';
        }

        function isNewPlugin(plugin) {
          return plugin.serialize != null;
        }

        function printPlugin(plugin, val, config, indentation, depth, refs) {
          var printed;

          try {
            printed = isNewPlugin(plugin) ? plugin.serialize(val, config, indentation, depth, refs, printer) : plugin.print(val, function (valChild) {
              return printer(valChild, config, indentation, depth, refs);
            }, function (str) {
              var indentationNext = indentation + config.indent;
              return indentationNext + str.replace(NEWLINE_REGEXP, '\n' + indentationNext);
            }, {
              edgeSpacing: config.spacingOuter,
              min: config.min,
              spacing: config.spacingInner
            }, config.colors);
          } catch (error) {
            throw new PrettyFormatPluginError(error.message, error.stack);
          }

          if (typeof printed !== 'string') {
            throw new Error("pretty-format: Plugin must return type \"string\" but instead returned \"".concat(_typeof(printed), "\"."));
          }

          return printed;
        }

        function findPlugin(plugins, val) {
          for (var p = 0; p < plugins.length; p++) {
            try {
              if (plugins[p].test(val)) {
                return plugins[p];
              }
            } catch (error) {
              throw new PrettyFormatPluginError(error.message, error.stack);
            }
          }

          return null;
        }

        function printer(val, config, indentation, depth, refs, hasCalledToJSON) {
          var plugin = findPlugin(config.plugins, val);

          if (plugin !== null) {
            return printPlugin(plugin, val, config, indentation, depth, refs);
          }

          var basicResult = printBasicValue(val, config.printFunctionName, config.escapeRegex, config.escapeString);

          if (basicResult !== null) {
            return basicResult;
          }

          return printComplexValue(val, config, indentation, depth, refs, hasCalledToJSON);
        }

        var DEFAULT_THEME = {
          comment: 'gray',
          content: 'reset',
          prop: 'yellow',
          tag: 'cyan',
          value: 'green'
        };
        var DEFAULT_THEME_KEYS = Object.keys(DEFAULT_THEME);
        var DEFAULT_OPTIONS = {
          callToJSON: true,
          escapeRegex: false,
          escapeString: true,
          highlight: false,
          indent: 2,
          maxDepth: Infinity,
          min: false,
          plugins: [],
          printFunctionName: true,
          theme: DEFAULT_THEME
        };

        function validateOptions(options) {
          Object.keys(options).forEach(function (key) {
            if (!DEFAULT_OPTIONS.hasOwnProperty(key)) {
              throw new Error("pretty-format: Unknown option \"".concat(key, "\"."));
            }
          });

          if (options.min && options.indent !== undefined && options.indent !== 0) {
            throw new Error('pretty-format: Options "min" and "indent" cannot be used together.');
          }

          if (options.theme !== undefined) {
            if (options.theme === null) {
              throw new Error("pretty-format: Option \"theme\" must not be null.");
            }

            if (_typeof(options.theme) !== 'object') {
              throw new Error("pretty-format: Option \"theme\" must be of type \"object\" but instead received \"".concat(_typeof(options.theme), "\"."));
            }
          }
        }

        var getColorsHighlight = function getColorsHighlight(options) {
          return DEFAULT_THEME_KEYS.reduce(function (colors, key) {
            var value = options.theme && options.theme[key] !== undefined ? options.theme[key] : DEFAULT_THEME[key];
            var color = value && _ansiStyles.default[value];

            if (color && typeof color.close === 'string' && typeof color.open === 'string') {
              colors[key] = color;
            } else {
              throw new Error("pretty-format: Option \"theme\" has a key \"".concat(key, "\" whose value \"").concat(value, "\" is undefined in ansi-styles."));
            }

            return colors;
          }, Object.create(null));
        };

        var getColorsEmpty = function getColorsEmpty() {
          return DEFAULT_THEME_KEYS.reduce(function (colors, key) {
            colors[key] = {
              close: '',
              open: ''
            };
            return colors;
          }, Object.create(null));
        };

        var getPrintFunctionName = function getPrintFunctionName(options) {
          return options && options.printFunctionName !== undefined ? options.printFunctionName : DEFAULT_OPTIONS.printFunctionName;
        };

        var getEscapeRegex = function getEscapeRegex(options) {
          return options && options.escapeRegex !== undefined ? options.escapeRegex : DEFAULT_OPTIONS.escapeRegex;
        };

        var getEscapeString = function getEscapeString(options) {
          return options && options.escapeString !== undefined ? options.escapeString : DEFAULT_OPTIONS.escapeString;
        };

        var getConfig = function getConfig(options) {
          return {
            callToJSON: options && options.callToJSON !== undefined ? options.callToJSON : DEFAULT_OPTIONS.callToJSON,
            colors: options && options.highlight ? getColorsHighlight(options) : getColorsEmpty(),
            escapeRegex: getEscapeRegex(options),
            escapeString: getEscapeString(options),
            indent: options && options.min ? '' : createIndent(options && options.indent !== undefined ? options.indent : DEFAULT_OPTIONS.indent),
            maxDepth: options && options.maxDepth !== undefined ? options.maxDepth : DEFAULT_OPTIONS.maxDepth,
            min: options && options.min !== undefined ? options.min : DEFAULT_OPTIONS.min,
            plugins: options && options.plugins !== undefined ? options.plugins : DEFAULT_OPTIONS.plugins,
            printFunctionName: getPrintFunctionName(options),
            spacingInner: options && options.min ? ' ' : '\n',
            spacingOuter: options && options.min ? '' : '\n'
          };
        };

        function createIndent(indent) {
          return new Array(indent + 1).join(' ');
        }

        function prettyFormat(val, options) {
          if (options) {
            validateOptions(options);

            if (options.plugins) {
              var plugin = findPlugin(options.plugins, val);

              if (plugin !== null) {
                return printPlugin(plugin, val, getConfig(options), '', 0, []);
              }
            }
          }

          var basicResult = printBasicValue(val, getPrintFunctionName(options), getEscapeRegex(options), getEscapeString(options));

          if (basicResult !== null) {
            return basicResult;
          }

          return printComplexValue(val, getConfig(options), '', 0, []);
        }

        prettyFormat.plugins = {
          AsymmetricMatcher: _AsymmetricMatcher.default,
          ConvertAnsi: _ConvertAnsi.default,
          DOMCollection: _DOMCollection.default,
          DOMElement: _DOMElement.default,
          Immutable: _Immutable.default,
          ReactElement: _ReactElement.default,
          ReactTestComponent: _ReactTestComponent.default
        };
        module.exports = prettyFormat;
      },
      "./packages/pretty-format/src/plugins/AsymmetricMatcher.ts": function packagesPrettyFormatSrcPluginsAsymmetricMatcherTs(module, exports, __webpack_require__) {
        "use strict";

        Object.defineProperty(exports, "__esModule", {
          value: true
        });
        exports.default = exports.test = exports.serialize = void 0;

        var _collections = __webpack_require__("./packages/pretty-format/src/collections.ts");

        var asymmetricMatcher = (typeof Symbol === "function" ? Symbol.for : "@@for")('jest.asymmetricMatcher');
        var SPACE = ' ';

        var serialize = function serialize(val, config, indentation, depth, refs, printer) {
          var stringedValue = val.toString();

          if (stringedValue === 'ArrayContaining' || stringedValue === 'ArrayNotContaining') {
            if (++depth > config.maxDepth) {
              return '[' + stringedValue + ']';
            }

            return stringedValue + SPACE + '[' + (0, _collections.printListItems)(val.sample, config, indentation, depth, refs, printer) + ']';
          }

          if (stringedValue === 'ObjectContaining' || stringedValue === 'ObjectNotContaining') {
            if (++depth > config.maxDepth) {
              return '[' + stringedValue + ']';
            }

            return stringedValue + SPACE + '{' + (0, _collections.printObjectProperties)(val.sample, config, indentation, depth, refs, printer) + '}';
          }

          if (stringedValue === 'StringMatching' || stringedValue === 'StringNotMatching') {
            return stringedValue + SPACE + printer(val.sample, config, indentation, depth, refs);
          }

          if (stringedValue === 'StringContaining' || stringedValue === 'StringNotContaining') {
            return stringedValue + SPACE + printer(val.sample, config, indentation, depth, refs);
          }

          return val.toAsymmetricMatcher();
        };

        exports.serialize = serialize;

        var test = function test(val) {
          return val && val.$$typeof === asymmetricMatcher;
        };

        exports.test = test;
        var plugin = {
          serialize: serialize,
          test: test
        };
        var _default = plugin;
        exports.default = _default;
      },
      "./packages/pretty-format/src/plugins/ConvertAnsi.ts": function packagesPrettyFormatSrcPluginsConvertAnsiTs(module, exports, __webpack_require__) {
        "use strict";

        Object.defineProperty(exports, "__esModule", {
          value: true
        });
        exports.default = exports.serialize = exports.test = void 0;

        var _ansiRegex = _interopRequireDefault(__webpack_require__("./node_modules/ansi-regex/index.js"));

        var _ansiStyles = _interopRequireDefault(__webpack_require__("./node_modules/ansi-styles/index.js"));

        function _interopRequireDefault(obj) {
          return obj && obj.__esModule ? obj : {
            default: obj
          };
        }

        var toHumanReadableAnsi = function toHumanReadableAnsi(text) {
          return text.replace((0, _ansiRegex.default)(), function (match) {
            switch (match) {
              case _ansiStyles.default.red.close:
              case _ansiStyles.default.green.close:
              case _ansiStyles.default.cyan.close:
              case _ansiStyles.default.gray.close:
              case _ansiStyles.default.white.close:
              case _ansiStyles.default.yellow.close:
              case _ansiStyles.default.bgRed.close:
              case _ansiStyles.default.bgGreen.close:
              case _ansiStyles.default.bgYellow.close:
              case _ansiStyles.default.inverse.close:
              case _ansiStyles.default.dim.close:
              case _ansiStyles.default.bold.close:
              case _ansiStyles.default.reset.open:
              case _ansiStyles.default.reset.close:
                return '</>';

              case _ansiStyles.default.red.open:
                return '<red>';

              case _ansiStyles.default.green.open:
                return '<green>';

              case _ansiStyles.default.cyan.open:
                return '<cyan>';

              case _ansiStyles.default.gray.open:
                return '<gray>';

              case _ansiStyles.default.white.open:
                return '<white>';

              case _ansiStyles.default.yellow.open:
                return '<yellow>';

              case _ansiStyles.default.bgRed.open:
                return '<bgRed>';

              case _ansiStyles.default.bgGreen.open:
                return '<bgGreen>';

              case _ansiStyles.default.bgYellow.open:
                return '<bgYellow>';

              case _ansiStyles.default.inverse.open:
                return '<inverse>';

              case _ansiStyles.default.dim.open:
                return '<dim>';

              case _ansiStyles.default.bold.open:
                return '<bold>';

              default:
                return '';
            }
          });
        };

        var test = function test(val) {
          return typeof val === 'string' && !!val.match((0, _ansiRegex.default)());
        };

        exports.test = test;

        var serialize = function serialize(val, config, indentation, depth, refs, printer) {
          return printer(toHumanReadableAnsi(val), config, indentation, depth, refs);
        };

        exports.serialize = serialize;
        var plugin = {
          serialize: serialize,
          test: test
        };
        var _default = plugin;
        exports.default = _default;
      },
      "./packages/pretty-format/src/plugins/DOMCollection.ts": function packagesPrettyFormatSrcPluginsDOMCollectionTs(module, exports, __webpack_require__) {
        "use strict";

        Object.defineProperty(exports, "__esModule", {
          value: true
        });
        exports.default = exports.serialize = exports.test = void 0;

        var _collections = __webpack_require__("./packages/pretty-format/src/collections.ts");

        function _objectSpread(target) {
          for (var i = 1; i < arguments.length; i++) {
            var source = arguments[i] != null ? arguments[i] : {};
            var ownKeys = Object.keys(source);

            if (typeof Object.getOwnPropertySymbols === 'function') {
              ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) {
                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
              }));
            }

            ownKeys.forEach(function (key) {
              _defineProperty(target, key, source[key]);
            });
          }

          return target;
        }

        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;
        }

        var SPACE = ' ';
        var OBJECT_NAMES = ['DOMStringMap', 'NamedNodeMap'];
        var ARRAY_REGEXP = /^(HTML\w*Collection|NodeList)$/;

        var testName = function testName(name) {
          return OBJECT_NAMES.indexOf(name) !== -1 || ARRAY_REGEXP.test(name);
        };

        var test = function test(val) {
          return val && val.constructor && val.constructor.name && testName(val.constructor.name);
        };

        exports.test = test;

        var propsReducer = function propsReducer(props, attribute) {
          props[attribute.name] = attribute.value;
          return props;
        };

        var serialize = function serialize(collection, config, indentation, depth, refs, printer) {
          var name = collection.constructor.name;

          if (++depth > config.maxDepth) {
            return '[' + name + ']';
          }

          return (config.min ? '' : name + SPACE) + (OBJECT_NAMES.indexOf(name) !== -1 ? '{' + (0, _collections.printObjectProperties)(name === 'NamedNodeMap' ? Array.prototype.reduce.call(collection, propsReducer, {}) : _objectSpread({}, collection), config, indentation, depth, refs, printer) + '}' : '[' + (0, _collections.printListItems)(Array.from(collection), config, indentation, depth, refs, printer) + ']');
        };

        exports.serialize = serialize;
        var plugin = {
          serialize: serialize,
          test: test
        };
        var _default = plugin;
        exports.default = _default;
      },
      "./packages/pretty-format/src/plugins/DOMElement.ts": function packagesPrettyFormatSrcPluginsDOMElementTs(module, exports, __webpack_require__) {
        "use strict";

        Object.defineProperty(exports, "__esModule", {
          value: true
        });
        exports.default = exports.serialize = exports.test = void 0;

        var _markup = __webpack_require__("./packages/pretty-format/src/plugins/lib/markup.ts");

        var ELEMENT_NODE = 1;
        var TEXT_NODE = 3;
        var COMMENT_NODE = 8;
        var FRAGMENT_NODE = 11;
        var ELEMENT_REGEXP = /^((HTML|SVG)\w*)?Element$/;

        var testNode = function testNode(nodeType, name) {
          return nodeType === ELEMENT_NODE && ELEMENT_REGEXP.test(name) || nodeType === TEXT_NODE && name === 'Text' || nodeType === COMMENT_NODE && name === 'Comment' || nodeType === FRAGMENT_NODE && name === 'DocumentFragment';
        };

        var test = function test(val) {
          return val && val.constructor && val.constructor.name && testNode(val.nodeType, val.constructor.name);
        };

        exports.test = test;

        function nodeIsText(node) {
          return node.nodeType === TEXT_NODE;
        }

        function nodeIsComment(node) {
          return node.nodeType === COMMENT_NODE;
        }

        function nodeIsFragment(node) {
          return node.nodeType === FRAGMENT_NODE;
        }

        var serialize = function serialize(node, config, indentation, depth, refs, printer) {
          if (nodeIsText(node)) {
            return (0, _markup.printText)(node.data, config);
          }

          if (nodeIsComment(node)) {
            return (0, _markup.printComment)(node.data, config);
          }

          var type = nodeIsFragment(node) ? "DocumentFragment" : node.tagName.toLowerCase();

          if (++depth > config.maxDepth) {
            return (0, _markup.printElementAsLeaf)(type, config);
          }

          return (0, _markup.printElement)(type, (0, _markup.printProps)(nodeIsFragment(node) ? [] : Array.from(node.attributes).map(function (attr) {
            return attr.name;
          }).sort(), nodeIsFragment(node) ? [] : Array.from(node.attributes).reduce(function (props, attribute) {
            props[attribute.name] = attribute.value;
            return props;
          }, {}), config, indentation + config.indent, depth, refs, printer), (0, _markup.printChildren)(Array.prototype.slice.call(node.childNodes || node.children), config, indentation + config.indent, depth, refs, printer), config, indentation);
        };

        exports.serialize = serialize;
        var plugin = {
          serialize: serialize,
          test: test
        };
        var _default = plugin;
        exports.default = _default;
      },
      "./packages/pretty-format/src/plugins/Immutable.ts": function packagesPrettyFormatSrcPluginsImmutableTs(module, exports, __webpack_require__) {
        "use strict";

        Object.defineProperty(exports, "__esModule", {
          value: true
        });
        exports.default = exports.test = exports.serialize = void 0;

        var _collections = __webpack_require__("./packages/pretty-format/src/collections.ts");

        var IS_ITERABLE_SENTINEL = '@@__IMMUTABLE_ITERABLE__@@';
        var IS_LIST_SENTINEL = '@@__IMMUTABLE_LIST__@@';
        var IS_KEYED_SENTINEL = '@@__IMMUTABLE_KEYED__@@';
        var IS_MAP_SENTINEL = '@@__IMMUTABLE_MAP__@@';
        var IS_ORDERED_SENTINEL = '@@__IMMUTABLE_ORDERED__@@';
        var IS_RECORD_SENTINEL = '@@__IMMUTABLE_RECORD__@@';
        var IS_SEQ_SENTINEL = '@@__IMMUTABLE_SEQ__@@';
        var IS_SET_SENTINEL = '@@__IMMUTABLE_SET__@@';
        var IS_STACK_SENTINEL = '@@__IMMUTABLE_STACK__@@';

        var getImmutableName = function getImmutableName(name) {
          return 'Immutable.' + name;
        };

        var printAsLeaf = function printAsLeaf(name) {
          return '[' + name + ']';
        };

        var SPACE = ' ';
        var LAZY = '…';

        var printImmutableEntries = function printImmutableEntries(val, config, indentation, depth, refs, printer, type) {
          return ++depth > config.maxDepth ? printAsLeaf(getImmutableName(type)) : getImmutableName(type) + SPACE + '{' + (0, _collections.printIteratorEntries)(val.entries(), config, indentation, depth, refs, printer) + '}';
        };

        var getRecordEntries = function getRecordEntries(val) {
          var i = 0;
          return {
            next: function next() {
              if (i < val._keys.length) {
                var key = val._keys[i++];
                return {
                  done: false,
                  value: [key, val.get(key)]
                };
              }

              return {
                done: true
              };
            }
          };
        };

        var printImmutableRecord = function printImmutableRecord(val, config, indentation, depth, refs, printer) {
          var name = getImmutableName(val._name || 'Record');
          return ++depth > config.maxDepth ? printAsLeaf(name) : name + SPACE + '{' + (0, _collections.printIteratorEntries)(getRecordEntries(val), config, indentation, depth, refs, printer) + '}';
        };

        var printImmutableSeq = function printImmutableSeq(val, config, indentation, depth, refs, printer) {
          var name = getImmutableName('Seq');

          if (++depth > config.maxDepth) {
            return printAsLeaf(name);
          }

          if (val[IS_KEYED_SENTINEL]) {
            return name + SPACE + '{' + (val._iter || val._object ? (0, _collections.printIteratorEntries)(val.entries(), config, indentation, depth, refs, printer) : LAZY) + '}';
          }

          return name + SPACE + '[' + (val._iter || val._array || val._collection || val._iterable ? (0, _collections.printIteratorValues)(val.values(), config, indentation, depth, refs, printer) : LAZY) + ']';
        };

        var printImmutableValues = function printImmutableValues(val, config, indentation, depth, refs, printer, type) {
          return ++depth > config.maxDepth ? printAsLeaf(getImmutableName(type)) : getImmutableName(type) + SPACE + '[' + (0, _collections.printIteratorValues)(val.values(), config, indentation, depth, refs, printer) + ']';
        };

        var serialize = function serialize(val, config, indentation, depth, refs, printer) {
          if (val[IS_MAP_SENTINEL]) {
            return printImmutableEntries(val, config, indentation, depth, refs, printer, val[IS_ORDERED_SENTINEL] ? 'OrderedMap' : 'Map');
          }

          if (val[IS_LIST_SENTINEL]) {
            return printImmutableValues(val, config, indentation, depth, refs, printer, 'List');
          }

          if (val[IS_SET_SENTINEL]) {
            return printImmutableValues(val, config, indentation, depth, refs, printer, val[IS_ORDERED_SENTINEL] ? 'OrderedSet' : 'Set');
          }

          if (val[IS_STACK_SENTINEL]) {
            return printImmutableValues(val, config, indentation, depth, refs, printer, 'Stack');
          }

          if (val[IS_SEQ_SENTINEL]) {
            return printImmutableSeq(val, config, indentation, depth, refs, printer);
          }

          return printImmutableRecord(val, config, indentation, depth, refs, printer);
        };

        exports.serialize = serialize;

        var test = function test(val) {
          return val && (val[IS_ITERABLE_SENTINEL] === true || val[IS_RECORD_SENTINEL] === true);
        };

        exports.test = test;
        var plugin = {
          serialize: serialize,
          test: test
        };
        var _default = plugin;
        exports.default = _default;
      },
      "./packages/pretty-format/src/plugins/ReactElement.ts": function packagesPrettyFormatSrcPluginsReactElementTs(module, exports, __webpack_require__) {
        "use strict";

        Object.defineProperty(exports, "__esModule", {
          value: true
        });
        exports.default = exports.test = exports.serialize = void 0;

        var ReactIs = _interopRequireWildcard(__webpack_require__("./node_modules/react-is/index.js"));

        var _markup = __webpack_require__("./packages/pretty-format/src/plugins/lib/markup.ts");

        function _interopRequireWildcard(obj) {
          if (obj && obj.__esModule) {
            return obj;
          } else {
            var newObj = {};

            if (obj != null) {
              for (var key in obj) {
                if (Object.prototype.hasOwnProperty.call(obj, key)) {
                  var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {};

                  if (desc.get || desc.set) {
                    Object.defineProperty(newObj, key, desc);
                  } else {
                    newObj[key] = obj[key];
                  }
                }
              }
            }

            newObj.default = obj;
            return newObj;
          }
        }

        function _typeof(obj) {
          if (typeof Symbol === "function" && typeof (typeof Symbol === "function" ? Symbol.iterator : "@@iterator") === "symbol") {
            _typeof = function _typeof(obj) {
              return typeof obj;
            };
          } else {
            _typeof = function _typeof(obj) {
              return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== (typeof Symbol === "function" ? Symbol.prototype : "@@prototype") ? "symbol" : typeof obj;
            };
          }

          return _typeof(obj);
        }

        var getChildren = function getChildren(arg) {
          var children = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];

          if (Array.isArray(arg)) {
            arg.forEach(function (item) {
              getChildren(item, children);
            });
          } else if (arg != null && arg !== false) {
            children.push(arg);
          }

          return children;
        };

        var getType = function getType(element) {
          var type = element.type;

          if (typeof type === 'string') {
            return type;
          }

          if (typeof type === 'function') {
            return type.displayName || type.name || 'Unknown';
          }

          if (ReactIs.isFragment(element)) {
            return 'React.Fragment';
          }

          if (ReactIs.isSuspense(element)) {
            return 'React.Suspense';
          }

          if (_typeof(type) === 'object' && type !== null) {
            if (ReactIs.isContextProvider(element)) {
              return 'Context.Provider';
            }

            if (ReactIs.isContextConsumer(element)) {
              return 'Context.Consumer';
            }

            if (ReactIs.isForwardRef(element)) {
              var functionName = type.render.displayName || type.render.name || '';
              return functionName !== '' ? 'ForwardRef(' + functionName + ')' : 'ForwardRef';
            }

            if (ReactIs.isMemo(type)) {
              var _functionName = type.displayName || type.type.displayName || type.type.name || '';

              return _functionName !== '' ? 'Memo(' + _functionName + ')' : 'Memo';
            }
          }

          return 'UNDEFINED';
        };

        var getPropKeys = function getPropKeys(element) {
          var props = element.props;
          return Object.keys(props).filter(function (key) {
            return key !== 'children' && props[key] !== undefined;
          }).sort();
        };

        var serialize = function serialize(element, config, indentation, depth, refs, printer) {
          return ++depth > config.maxDepth ? (0, _markup.printElementAsLeaf)(getType(element), config) : (0, _markup.printElement)(getType(element), (0, _markup.printProps)(getPropKeys(element), element.props, config, indentation + config.indent, depth, refs, printer), (0, _markup.printChildren)(getChildren(element.props.children), config, indentation + config.indent, depth, refs, printer), config, indentation);
        };

        exports.serialize = serialize;

        var test = function test(val) {
          return val && ReactIs.isElement(val);
        };

        exports.test = test;
        var plugin = {
          serialize: serialize,
          test: test
        };
        var _default = plugin;
        exports.default = _default;
      },
      "./packages/pretty-format/src/plugins/ReactTestComponent.ts": function packagesPrettyFormatSrcPluginsReactTestComponentTs(module, exports, __webpack_require__) {
        "use strict";

        Object.defineProperty(exports, "__esModule", {
          value: true
        });
        exports.default = exports.test = exports.serialize = void 0;

        var _markup = __webpack_require__("./packages/pretty-format/src/plugins/lib/markup.ts");

        var testSymbol = (typeof Symbol === "function" ? Symbol.for : "@@for")('react.test.json');

        var getPropKeys = function getPropKeys(object) {
          var props = object.props;
          return props ? Object.keys(props).filter(function (key) {
            return props[key] !== undefined;
          }).sort() : [];
        };

        var serialize = function serialize(object, config, indentation, depth, refs, printer) {
          return ++depth > config.maxDepth ? (0, _markup.printElementAsLeaf)(object.type, config) : (0, _markup.printElement)(object.type, object.props ? (0, _markup.printProps)(getPropKeys(object), object.props, config, indentation + config.indent, depth, refs, printer) : '', object.children ? (0, _markup.printChildren)(object.children, config, indentation + config.indent, depth, refs, printer) : '', config, indentation);
        };

        exports.serialize = serialize;

        var test = function test(val) {
          return val && val.$$typeof === testSymbol;
        };

        exports.test = test;
        var plugin = {
          serialize: serialize,
          test: test
        };
        var _default = plugin;
        exports.default = _default;
      },
      "./packages/pretty-format/src/plugins/lib/escapeHTML.ts": function packagesPrettyFormatSrcPluginsLibEscapeHTMLTs(module, exports, __webpack_require__) {
        "use strict";

        Object.defineProperty(exports, "__esModule", {
          value: true
        });
        exports.default = escapeHTML;

        function escapeHTML(str) {
          return str.replace(/</g, '&lt;').replace(/>/g, '&gt;');
        }
      },
      "./packages/pretty-format/src/plugins/lib/markup.ts": function packagesPrettyFormatSrcPluginsLibMarkupTs(module, exports, __webpack_require__) {
        "use strict";

        Object.defineProperty(exports, "__esModule", {
          value: true
        });
        exports.printElementAsLeaf = exports.printElement = exports.printComment = exports.printText = exports.printChildren = exports.printProps = void 0;

        var _escapeHTML = _interopRequireDefault(__webpack_require__("./packages/pretty-format/src/plugins/lib/escapeHTML.ts"));

        function _interopRequireDefault(obj) {
          return obj && obj.__esModule ? obj : {
            default: obj
          };
        }

        var printProps = function printProps(keys, props, config, indentation, depth, refs, printer) {
          var indentationNext = indentation + config.indent;
          var colors = config.colors;
          return keys.map(function (key) {
            var value = props[key];
            var printed = printer(value, config, indentationNext, depth, refs);

            if (typeof value !== 'string') {
              if (printed.indexOf('\n') !== -1) {
                printed = config.spacingOuter + indentationNext + printed + config.spacingOuter + indentation;
              }

              printed = '{' + printed + '}';
            }

            return config.spacingInner + indentation + colors.prop.open + key + colors.prop.close + '=' + colors.value.open + printed + colors.value.close;
          }).join('');
        };

        exports.printProps = printProps;

        var printChildren = function printChildren(children, config, indentation, depth, refs, printer) {
          return children.map(function (child) {
            return config.spacingOuter + indentation + (typeof child === 'string' ? printText(child, config) : printer(child, config, indentation, depth, refs));
          }).join('');
        };

        exports.printChildren = printChildren;

        var printText = function printText(text, config) {
          var contentColor = config.colors.content;
          return contentColor.open + (0, _escapeHTML.default)(text) + contentColor.close;
        };

        exports.printText = printText;

        var printComment = function printComment(comment, config) {
          var commentColor = config.colors.comment;
          return commentColor.open + '<!--' + (0, _escapeHTML.default)(comment) + '-->' + commentColor.close;
        };

        exports.printComment = printComment;

        var printElement = function printElement(type, printedProps, printedChildren, config, indentation) {
          var tagColor = config.colors.tag;
          return tagColor.open + '<' + type + (printedProps && tagColor.close + printedProps + config.spacingOuter + indentation + tagColor.open) + (printedChildren ? '>' + tagColor.close + printedChildren + config.spacingOuter + indentation + tagColor.open + '</' + type : (printedProps && !config.min ? '' : ' ') + '/') + '>' + tagColor.close;
        };

        exports.printElement = printElement;

        var printElementAsLeaf = function printElementAsLeaf(type, config) {
          var tagColor = config.colors.tag;
          return tagColor.open + '<' + type + tagColor.close + ' …' + tagColor.open + ' />' + tagColor.close;
        };

        exports.printElementAsLeaf = printElementAsLeaf;
      }
    });
  });
},117,[13],"node_modules/pretty-format/build-es5/index.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _require = _$$_REQUIRE(_dependencyMap[0], "../Utilities/PolyfillFunctions"),
      polyfillGlobal = _require.polyfillGlobal;

  polyfillGlobal('regeneratorRuntime', function () {
    delete global.regeneratorRuntime;
    return _$$_REQUIRE(_dependencyMap[1], "regenerator-runtime/runtime");
  });
},118,[110,104],"node_modules/react-native/Libraries/Core/setUpRegeneratorRuntime.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  if (!global.RN$Bridgeless) {
    var _require = _$$_REQUIRE(_dependencyMap[0], "../Utilities/PolyfillFunctions"),
        polyfillGlobal = _require.polyfillGlobal;

    var defineLazyTimer = function defineLazyTimer(name) {
      polyfillGlobal(name, function () {
        return _$$_REQUIRE(_dependencyMap[1], "./Timers/JSTimers")[name];
      });
    };

    defineLazyTimer('setTimeout');
    defineLazyTimer('setInterval');
    defineLazyTimer('setImmediate');
    defineLazyTimer('clearTimeout');
    defineLazyTimer('clearInterval');
    defineLazyTimer('clearImmediate');
    defineLazyTimer('requestAnimationFrame');
    defineLazyTimer('cancelAnimationFrame');
    defineLazyTimer('requestIdleCallback');
    defineLazyTimer('cancelIdleCallback');
  }
},119,[110,120],"node_modules/react-native/Libraries/Core/setUpTimers.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _NativeTiming = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./NativeTiming"));

  var BatchedBridge = _$$_REQUIRE(_dependencyMap[2], "../../BatchedBridge/BatchedBridge");

  var Platform = _$$_REQUIRE(_dependencyMap[3], "../../Utilities/Platform");

  var Systrace = _$$_REQUIRE(_dependencyMap[4], "../../Performance/Systrace");

  var invariant = _$$_REQUIRE(_dependencyMap[5], "invariant");

  var _performanceNow = null;

  function performanceNow() {
    if (!_performanceNow) {
      _performanceNow = _$$_REQUIRE(_dependencyMap[6], "fbjs/lib/performanceNow");
    }

    return _performanceNow();
  }

  var FRAME_DURATION = 1000 / 60;
  var IDLE_CALLBACK_FRAME_DEADLINE = 1;
  var MAX_TIMER_DURATION_MS = 60 * 1000;
  var IS_ANDROID = "android" === 'android';
  var ANDROID_LONG_TIMER_MESSAGE = 'Setting a timer for a long period of time, i.e. multiple minutes, is a ' + 'performance and correctness issue on Android as it keeps the timer ' + 'module awake, and timers can only be called when the app is in the foreground. ' + 'See https://github.com/facebook/react-native/issues/12981 for more info.';
  var callbacks = [];
  var types = [];
  var timerIDs = [];
  var immediates = [];
  var requestIdleCallbacks = [];
  var requestIdleCallbackTimeouts = {};
  var identifiers = [];
  var GUID = 1;
  var errors = null;
  var hasEmittedTimeDriftWarning = false;

  function _getFreeIndex() {
    var freeIndex = timerIDs.indexOf(null);

    if (freeIndex === -1) {
      freeIndex = timerIDs.length;
    }

    return freeIndex;
  }

  function _allocateCallback(func, type) {
    var id = GUID++;

    var freeIndex = _getFreeIndex();

    timerIDs[freeIndex] = id;
    callbacks[freeIndex] = func;
    types[freeIndex] = type;

    if (__DEV__) {
      var parseErrorStack = _$$_REQUIRE(_dependencyMap[7], "../Devtools/parseErrorStack");

      var error = new Error();
      error.framesToPop = 1;
      var stack = parseErrorStack(error);

      if (stack) {
        identifiers[freeIndex] = stack.shift();
      }
    }

    return id;
  }

  function _callTimer(timerID, frameTime, didTimeout) {
    _$$_REQUIRE(_dependencyMap[8], "fbjs/lib/warning")(timerID <= GUID, 'Tried to call timer with ID %s but no such timer exists.', timerID);

    var timerIndex = timerIDs.indexOf(timerID);

    if (timerIndex === -1) {
      return;
    }

    var type = types[timerIndex];
    var callback = callbacks[timerIndex];

    if (!callback || !type) {
      console.error('No callback found for timerID ' + timerID);
      return;
    }

    if (__DEV__) {
      var identifier = identifiers[timerIndex] || {};
      Systrace.beginEvent('Systrace.callTimer: ' + identifier.methodName);
    }

    if (type === 'setTimeout' || type === 'setImmediate' || type === 'requestAnimationFrame' || type === 'requestIdleCallback') {
      _clearIndex(timerIndex);
    }

    try {
      if (type === 'setTimeout' || type === 'setInterval' || type === 'setImmediate') {
        callback();
      } else if (type === 'requestAnimationFrame') {
        callback(performanceNow());
      } else if (type === 'requestIdleCallback') {
        callback({
          timeRemaining: function timeRemaining() {
            return Math.max(0, FRAME_DURATION - (performanceNow() - frameTime));
          },
          didTimeout: !!didTimeout
        });
      } else {
        console.error('Tried to call a callback with invalid type: ' + type);
      }
    } catch (e) {
      if (!errors) {
        errors = [e];
      } else {
        errors.push(e);
      }
    }

    if (__DEV__) {
      Systrace.endEvent();
    }
  }

  function _callImmediatesPass() {
    if (__DEV__) {
      Systrace.beginEvent('callImmediatesPass()');
    }

    if (immediates.length > 0) {
      var passImmediates = immediates.slice();
      immediates = [];

      for (var i = 0; i < passImmediates.length; ++i) {
        _callTimer(passImmediates[i], 0);
      }
    }

    if (__DEV__) {
      Systrace.endEvent();
    }

    return immediates.length > 0;
  }

  function _clearIndex(i) {
    timerIDs[i] = null;
    callbacks[i] = null;
    types[i] = null;
    identifiers[i] = null;
  }

  function _freeCallback(timerID) {
    if (timerID == null) {
      return;
    }

    var index = timerIDs.indexOf(timerID);

    if (index !== -1) {
      _clearIndex(index);

      var type = types[index];

      if (type !== 'setImmediate' && type !== 'requestIdleCallback') {
        deleteTimer(timerID);
      }
    }
  }

  var JSTimers = {
    setTimeout: function setTimeout(func, duration) {
      for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
        args[_key - 2] = arguments[_key];
      }

      if (__DEV__ && IS_ANDROID && duration > MAX_TIMER_DURATION_MS) {
        console.warn(ANDROID_LONG_TIMER_MESSAGE + '\n' + '(Saw setTimeout with duration ' + duration + 'ms)');
      }

      var id = _allocateCallback(function () {
        return func.apply(undefined, args);
      }, 'setTimeout');

      createTimer(id, duration || 0, Date.now(), false);
      return id;
    },
    setInterval: function setInterval(func, duration) {
      for (var _len2 = arguments.length, args = new Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
        args[_key2 - 2] = arguments[_key2];
      }

      if (__DEV__ && IS_ANDROID && duration > MAX_TIMER_DURATION_MS) {
        console.warn(ANDROID_LONG_TIMER_MESSAGE + '\n' + '(Saw setInterval with duration ' + duration + 'ms)');
      }

      var id = _allocateCallback(function () {
        return func.apply(undefined, args);
      }, 'setInterval');

      createTimer(id, duration || 0, Date.now(), true);
      return id;
    },
    setImmediate: function setImmediate(func) {
      for (var _len3 = arguments.length, args = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
        args[_key3 - 1] = arguments[_key3];
      }

      var id = _allocateCallback(function () {
        return func.apply(undefined, args);
      }, 'setImmediate');

      immediates.push(id);
      return id;
    },
    requestAnimationFrame: function requestAnimationFrame(func) {
      var id = _allocateCallback(func, 'requestAnimationFrame');

      createTimer(id, 1, Date.now(), false);
      return id;
    },
    requestIdleCallback: function requestIdleCallback(func, options) {
      if (requestIdleCallbacks.length === 0) {
        setSendIdleEvents(true);
      }

      var timeout = options && options.timeout;

      var id = _allocateCallback(timeout != null ? function (deadline) {
        var timeoutId = requestIdleCallbackTimeouts[id];

        if (timeoutId) {
          JSTimers.clearTimeout(timeoutId);
          delete requestIdleCallbackTimeouts[id];
        }

        return func(deadline);
      } : func, 'requestIdleCallback');

      requestIdleCallbacks.push(id);

      if (timeout != null) {
        var timeoutId = JSTimers.setTimeout(function () {
          var index = requestIdleCallbacks.indexOf(id);

          if (index > -1) {
            requestIdleCallbacks.splice(index, 1);

            _callTimer(id, performanceNow(), true);
          }

          delete requestIdleCallbackTimeouts[id];

          if (requestIdleCallbacks.length === 0) {
            setSendIdleEvents(false);
          }
        }, timeout);
        requestIdleCallbackTimeouts[id] = timeoutId;
      }

      return id;
    },
    cancelIdleCallback: function cancelIdleCallback(timerID) {
      _freeCallback(timerID);

      var index = requestIdleCallbacks.indexOf(timerID);

      if (index !== -1) {
        requestIdleCallbacks.splice(index, 1);
      }

      var timeoutId = requestIdleCallbackTimeouts[timerID];

      if (timeoutId) {
        JSTimers.clearTimeout(timeoutId);
        delete requestIdleCallbackTimeouts[timerID];
      }

      if (requestIdleCallbacks.length === 0) {
        setSendIdleEvents(false);
      }
    },
    clearTimeout: function clearTimeout(timerID) {
      _freeCallback(timerID);
    },
    clearInterval: function clearInterval(timerID) {
      _freeCallback(timerID);
    },
    clearImmediate: function clearImmediate(timerID) {
      _freeCallback(timerID);

      var index = immediates.indexOf(timerID);

      if (index !== -1) {
        immediates.splice(index, 1);
      }
    },
    cancelAnimationFrame: function cancelAnimationFrame(timerID) {
      _freeCallback(timerID);
    },
    callTimers: function callTimers(timersToCall) {
      invariant(timersToCall.length !== 0, 'Cannot call `callTimers` with an empty list of IDs.');
      errors = null;

      for (var i = 0; i < timersToCall.length; i++) {
        _callTimer(timersToCall[i], 0);
      }

      if (errors) {
        var errorCount = errors.length;

        if (errorCount > 1) {
          for (var ii = 1; ii < errorCount; ii++) {
            JSTimers.setTimeout(function (error) {
              throw error;
            }.bind(null, errors[ii]), 0);
          }
        }

        throw errors[0];
      }
    },
    callIdleCallbacks: function callIdleCallbacks(frameTime) {
      if (FRAME_DURATION - (performanceNow() - frameTime) < IDLE_CALLBACK_FRAME_DEADLINE) {
        return;
      }

      errors = null;

      if (requestIdleCallbacks.length > 0) {
        var passIdleCallbacks = requestIdleCallbacks.slice();
        requestIdleCallbacks = [];

        for (var i = 0; i < passIdleCallbacks.length; ++i) {
          _callTimer(passIdleCallbacks[i], frameTime);
        }
      }

      if (requestIdleCallbacks.length === 0) {
        setSendIdleEvents(false);
      }

      if (errors) {
        errors.forEach(function (error) {
          return JSTimers.setTimeout(function () {
            throw error;
          }, 0);
        });
      }
    },
    callImmediates: function callImmediates() {
      errors = null;

      while (_callImmediatesPass()) {}

      if (errors) {
        errors.forEach(function (error) {
          return JSTimers.setTimeout(function () {
            throw error;
          }, 0);
        });
      }
    },
    emitTimeDriftWarning: function emitTimeDriftWarning(warningMessage) {
      if (hasEmittedTimeDriftWarning) {
        return;
      }

      hasEmittedTimeDriftWarning = true;
      console.warn(warningMessage);
    }
  };

  function createTimer(callbackID, duration, jsSchedulingTime, repeats) {
    invariant(_NativeTiming.default, 'NativeTiming is available');

    _NativeTiming.default.createTimer(callbackID, duration, jsSchedulingTime, repeats);
  }

  function deleteTimer(timerID) {
    invariant(_NativeTiming.default, 'NativeTiming is available');

    _NativeTiming.default.deleteTimer(timerID);
  }

  function setSendIdleEvents(sendIdleEvents) {
    invariant(_NativeTiming.default, 'NativeTiming is available');

    _NativeTiming.default.setSendIdleEvents(sendIdleEvents);
  }

  var ExportedJSTimers;

  if (!_NativeTiming.default) {
    console.warn("Timing native module is not available, can't set timers.");
    ExportedJSTimers = {
      callImmediates: JSTimers.callImmediates,
      setImmediate: JSTimers.setImmediate
    };
  } else {
    ExportedJSTimers = JSTimers;
  }

  BatchedBridge.setImmediatesCallback(ExportedJSTimers.callImmediates.bind(ExportedJSTimers));
  module.exports = ExportedJSTimers;
},120,[1,121,18,48,27,3,122,100,5],"node_modules/react-native/Libraries/Core/Timers/JSTimers.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireWildcard");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[1], "../../TurboModule/TurboModuleRegistry"));

  var _default = TurboModuleRegistry.get('Timing');

  exports.default = _default;
},121,[9,11],"node_modules/react-native/Libraries/Core/Timers/NativeTiming.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  "use strict";

  var performance = _$$_REQUIRE(_dependencyMap[0], "./performance");

  var performanceNow;

  if (performance.now) {
    performanceNow = function performanceNow() {
      return performance.now();
    };
  } else {
    performanceNow = function performanceNow() {
      return Date.now();
    };
  }

  module.exports = performanceNow;
},122,[123],"node_modules/fbjs/lib/performanceNow.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var ExecutionEnvironment = _$$_REQUIRE(_dependencyMap[0], "./ExecutionEnvironment");

  var performance;

  if (ExecutionEnvironment.canUseDOM) {
    performance = window.performance || window.msPerformance || window.webkitPerformance;
  }

  module.exports = performance || {};
},123,[124],"node_modules/fbjs/lib/performance.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var canUseDOM = !!(typeof window !== 'undefined' && window.document && window.document.createElement);
  var ExecutionEnvironment = {
    canUseDOM: canUseDOM,
    canUseWorkers: typeof Worker !== 'undefined',
    canUseEventListeners: canUseDOM && !!(window.addEventListener || window.attachEvent),
    canUseViewport: canUseDOM && !!window.screen,
    isInWorker: !canUseDOM
  };
  module.exports = ExecutionEnvironment;
},124,[],"node_modules/fbjs/lib/ExecutionEnvironment.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _require = _$$_REQUIRE(_dependencyMap[0], "../Utilities/PolyfillFunctions"),
      polyfillGlobal = _require.polyfillGlobal;

  polyfillGlobal('XMLHttpRequest', function () {
    return _$$_REQUIRE(_dependencyMap[1], "../Network/XMLHttpRequest");
  });
  polyfillGlobal('FormData', function () {
    return _$$_REQUIRE(_dependencyMap[2], "../Network/FormData");
  });
  polyfillGlobal('fetch', function () {
    return _$$_REQUIRE(_dependencyMap[3], "../Network/fetch").fetch;
  });
  polyfillGlobal('Headers', function () {
    return _$$_REQUIRE(_dependencyMap[3], "../Network/fetch").Headers;
  });
  polyfillGlobal('Request', function () {
    return _$$_REQUIRE(_dependencyMap[3], "../Network/fetch").Request;
  });
  polyfillGlobal('Response', function () {
    return _$$_REQUIRE(_dependencyMap[3], "../Network/fetch").Response;
  });
  polyfillGlobal('WebSocket', function () {
    return _$$_REQUIRE(_dependencyMap[4], "../WebSocket/WebSocket");
  });
  polyfillGlobal('Blob', function () {
    return _$$_REQUIRE(_dependencyMap[5], "../Blob/Blob");
  });
  polyfillGlobal('File', function () {
    return _$$_REQUIRE(_dependencyMap[6], "../Blob/File");
  });
  polyfillGlobal('FileReader', function () {
    return _$$_REQUIRE(_dependencyMap[7], "../Blob/FileReader");
  });
  polyfillGlobal('URL', function () {
    return _$$_REQUIRE(_dependencyMap[8], "../Blob/URL").URL;
  });
  polyfillGlobal('URLSearchParams', function () {
    return _$$_REQUIRE(_dependencyMap[8], "../Blob/URL").URLSearchParams;
  });
  polyfillGlobal('AbortController', function () {
    return _$$_REQUIRE(_dependencyMap[9], "abort-controller/dist/abort-controller").AbortController;
  });
  polyfillGlobal('AbortSignal', function () {
    return _$$_REQUIRE(_dependencyMap[9], "abort-controller/dist/abort-controller").AbortSignal;
  });
},125,[110,126,138,107,139,129,142,143,145,146],"node_modules/react-native/Libraries/Core/setUpXHR.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _toConsumableArray = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/toConsumableArray");

  var _get = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/get");

  var _createClass = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass");

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/classCallCheck");

  var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/possibleConstructorReturn");

  var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/getPrototypeOf");

  var _inherits = _$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits");

  var BlobManager = _$$_REQUIRE(_dependencyMap[7], "../Blob/BlobManager");

  var EventTarget = _$$_REQUIRE(_dependencyMap[8], "event-target-shim");

  var RCTNetworking = _$$_REQUIRE(_dependencyMap[9], "./RCTNetworking");

  var base64 = _$$_REQUIRE(_dependencyMap[10], "base64-js");

  var invariant = _$$_REQUIRE(_dependencyMap[11], "invariant");

  var warning = _$$_REQUIRE(_dependencyMap[12], "fbjs/lib/warning");

  if (BlobManager.isAvailable) {
    BlobManager.addNetworkingHandler();
  }

  var UNSENT = 0;
  var OPENED = 1;
  var HEADERS_RECEIVED = 2;
  var LOADING = 3;
  var DONE = 4;
  var SUPPORTED_RESPONSE_TYPES = {
    arraybuffer: typeof global.ArrayBuffer === 'function',
    blob: typeof global.Blob === 'function',
    document: false,
    json: true,
    text: true,
    '': true
  };
  var REQUEST_EVENTS = ['abort', 'error', 'load', 'loadstart', 'progress', 'timeout', 'loadend'];
  var XHR_EVENTS = REQUEST_EVENTS.concat('readystatechange');

  var XMLHttpRequestEventTarget = function (_ref) {
    _inherits(XMLHttpRequestEventTarget, _ref);

    function XMLHttpRequestEventTarget() {
      _classCallCheck(this, XMLHttpRequestEventTarget);

      return _possibleConstructorReturn(this, _getPrototypeOf(XMLHttpRequestEventTarget).apply(this, arguments));
    }

    return XMLHttpRequestEventTarget;
  }(EventTarget.apply(void 0, REQUEST_EVENTS));

  var XMLHttpRequest = function (_ref2) {
    _inherits(XMLHttpRequest, _ref2);

    _createClass(XMLHttpRequest, null, [{
      key: "setInterceptor",
      value: function setInterceptor(interceptor) {
        XMLHttpRequest._interceptor = interceptor;
      }
    }]);

    function XMLHttpRequest() {
      var _this;

      _classCallCheck(this, XMLHttpRequest);

      _this = _possibleConstructorReturn(this, _getPrototypeOf(XMLHttpRequest).call(this));
      _this.UNSENT = UNSENT;
      _this.OPENED = OPENED;
      _this.HEADERS_RECEIVED = HEADERS_RECEIVED;
      _this.LOADING = LOADING;
      _this.DONE = DONE;
      _this.readyState = UNSENT;
      _this.status = 0;
      _this.timeout = 0;
      _this.withCredentials = true;
      _this.upload = new XMLHttpRequestEventTarget();
      _this._aborted = false;
      _this._hasError = false;
      _this._method = null;
      _this._response = '';
      _this._url = null;
      _this._timedOut = false;
      _this._trackingName = 'unknown';
      _this._incrementalEvents = false;

      _this._reset();

      return _this;
    }

    _createClass(XMLHttpRequest, [{
      key: "_reset",
      value: function _reset() {
        this.readyState = this.UNSENT;
        this.responseHeaders = undefined;
        this.status = 0;
        delete this.responseURL;
        this._requestId = null;
        this._cachedResponse = undefined;
        this._hasError = false;
        this._headers = {};
        this._response = '';
        this._responseType = '';
        this._sent = false;
        this._lowerCaseResponseHeaders = {};

        this._clearSubscriptions();

        this._timedOut = false;
      }
    }, {
      key: "__didCreateRequest",
      value: function __didCreateRequest(requestId) {
        this._requestId = requestId;
        XMLHttpRequest._interceptor && XMLHttpRequest._interceptor.requestSent(requestId, this._url || '', this._method || 'GET', this._headers);
      }
    }, {
      key: "__didUploadProgress",
      value: function __didUploadProgress(requestId, progress, total) {
        if (requestId === this._requestId) {
          this.upload.dispatchEvent({
            type: 'progress',
            lengthComputable: true,
            loaded: progress,
            total: total
          });
        }
      }
    }, {
      key: "__didReceiveResponse",
      value: function __didReceiveResponse(requestId, status, responseHeaders, responseURL) {
        if (requestId === this._requestId) {
          this.status = status;
          this.setResponseHeaders(responseHeaders);
          this.setReadyState(this.HEADERS_RECEIVED);

          if (responseURL || responseURL === '') {
            this.responseURL = responseURL;
          } else {
            delete this.responseURL;
          }

          XMLHttpRequest._interceptor && XMLHttpRequest._interceptor.responseReceived(requestId, responseURL || this._url || '', status, responseHeaders || {});
        }
      }
    }, {
      key: "__didReceiveData",
      value: function __didReceiveData(requestId, response) {
        if (requestId !== this._requestId) {
          return;
        }

        this._response = response;
        this._cachedResponse = undefined;
        this.setReadyState(this.LOADING);
        XMLHttpRequest._interceptor && XMLHttpRequest._interceptor.dataReceived(requestId, response);
      }
    }, {
      key: "__didReceiveIncrementalData",
      value: function __didReceiveIncrementalData(requestId, responseText, progress, total) {
        if (requestId !== this._requestId) {
          return;
        }

        if (!this._response) {
          this._response = responseText;
        } else {
          this._response += responseText;
        }

        XMLHttpRequest._interceptor && XMLHttpRequest._interceptor.dataReceived(requestId, responseText);
        this.setReadyState(this.LOADING);

        this.__didReceiveDataProgress(requestId, progress, total);
      }
    }, {
      key: "__didReceiveDataProgress",
      value: function __didReceiveDataProgress(requestId, loaded, total) {
        if (requestId !== this._requestId) {
          return;
        }

        this.dispatchEvent({
          type: 'progress',
          lengthComputable: total >= 0,
          loaded: loaded,
          total: total
        });
      }
    }, {
      key: "__didCompleteResponse",
      value: function __didCompleteResponse(requestId, error, timeOutError) {
        if (requestId === this._requestId) {
          if (error) {
            if (this._responseType === '' || this._responseType === 'text') {
              this._response = error;
            }

            this._hasError = true;

            if (timeOutError) {
              this._timedOut = true;
            }
          }

          this._clearSubscriptions();

          this._requestId = null;
          this.setReadyState(this.DONE);

          if (error) {
            XMLHttpRequest._interceptor && XMLHttpRequest._interceptor.loadingFailed(requestId, error);
          } else {
            XMLHttpRequest._interceptor && XMLHttpRequest._interceptor.loadingFinished(requestId, this._response.length);
          }
        }
      }
    }, {
      key: "_clearSubscriptions",
      value: function _clearSubscriptions() {
        (this._subscriptions || []).forEach(function (sub) {
          if (sub) {
            sub.remove();
          }
        });
        this._subscriptions = [];
      }
    }, {
      key: "getAllResponseHeaders",
      value: function getAllResponseHeaders() {
        if (!this.responseHeaders) {
          return null;
        }

        var headers = this.responseHeaders || {};
        return Object.keys(headers).map(function (headerName) {
          return headerName + ': ' + headers[headerName];
        }).join('\r\n');
      }
    }, {
      key: "getResponseHeader",
      value: function getResponseHeader(header) {
        var value = this._lowerCaseResponseHeaders[header.toLowerCase()];

        return value !== undefined ? value : null;
      }
    }, {
      key: "setRequestHeader",
      value: function setRequestHeader(header, value) {
        if (this.readyState !== this.OPENED) {
          throw new Error('Request has not been opened');
        }

        this._headers[header.toLowerCase()] = String(value);
      }
    }, {
      key: "setTrackingName",
      value: function setTrackingName(trackingName) {
        this._trackingName = trackingName;
        return this;
      }
    }, {
      key: "open",
      value: function open(method, url, async) {
        if (this.readyState !== this.UNSENT) {
          throw new Error('Cannot open, already sending');
        }

        if (async !== undefined && !async) {
          throw new Error('Synchronous http requests are not supported');
        }

        if (!url) {
          throw new Error('Cannot load an empty url');
        }

        this._method = method.toUpperCase();
        this._url = url;
        this._aborted = false;
        this.setReadyState(this.OPENED);
      }
    }, {
      key: "send",
      value: function send(data) {
        var _this2 = this;

        if (this.readyState !== this.OPENED) {
          throw new Error('Request has not been opened');
        }

        if (this._sent) {
          throw new Error('Request has already been sent');
        }

        this._sent = true;
        var incrementalEvents = this._incrementalEvents || !!this.onreadystatechange || !!this.onprogress;

        this._subscriptions.push(RCTNetworking.addListener('didSendNetworkData', function (args) {
          return _this2.__didUploadProgress.apply(_this2, _toConsumableArray(args));
        }));

        this._subscriptions.push(RCTNetworking.addListener('didReceiveNetworkResponse', function (args) {
          return _this2.__didReceiveResponse.apply(_this2, _toConsumableArray(args));
        }));

        this._subscriptions.push(RCTNetworking.addListener('didReceiveNetworkData', function (args) {
          return _this2.__didReceiveData.apply(_this2, _toConsumableArray(args));
        }));

        this._subscriptions.push(RCTNetworking.addListener('didReceiveNetworkIncrementalData', function (args) {
          return _this2.__didReceiveIncrementalData.apply(_this2, _toConsumableArray(args));
        }));

        this._subscriptions.push(RCTNetworking.addListener('didReceiveNetworkDataProgress', function (args) {
          return _this2.__didReceiveDataProgress.apply(_this2, _toConsumableArray(args));
        }));

        this._subscriptions.push(RCTNetworking.addListener('didCompleteNetworkResponse', function (args) {
          return _this2.__didCompleteResponse.apply(_this2, _toConsumableArray(args));
        }));

        var nativeResponseType = 'text';

        if (this._responseType === 'arraybuffer') {
          nativeResponseType = 'base64';
        }

        if (this._responseType === 'blob') {
          nativeResponseType = 'blob';
        }

        invariant(this._method, 'Request method needs to be defined.');
        invariant(this._url, 'Request URL needs to be defined.');
        RCTNetworking.sendRequest(this._method, this._trackingName, this._url, this._headers, data, nativeResponseType, incrementalEvents, this.timeout, this.__didCreateRequest.bind(this), this.withCredentials);
      }
    }, {
      key: "abort",
      value: function abort() {
        this._aborted = true;

        if (this._requestId) {
          RCTNetworking.abortRequest(this._requestId);
        }

        if (!(this.readyState === this.UNSENT || this.readyState === this.OPENED && !this._sent || this.readyState === this.DONE)) {
          this._reset();

          this.setReadyState(this.DONE);
        }

        this._reset();
      }
    }, {
      key: "setResponseHeaders",
      value: function setResponseHeaders(responseHeaders) {
        this.responseHeaders = responseHeaders || null;
        var headers = responseHeaders || {};
        this._lowerCaseResponseHeaders = Object.keys(headers).reduce(function (lcaseHeaders, headerName) {
          lcaseHeaders[headerName.toLowerCase()] = headers[headerName];
          return lcaseHeaders;
        }, {});
      }
    }, {
      key: "setReadyState",
      value: function setReadyState(newState) {
        this.readyState = newState;
        this.dispatchEvent({
          type: 'readystatechange'
        });

        if (newState === this.DONE) {
          if (this._aborted) {
            this.dispatchEvent({
              type: 'abort'
            });
          } else if (this._hasError) {
            if (this._timedOut) {
              this.dispatchEvent({
                type: 'timeout'
              });
            } else {
              this.dispatchEvent({
                type: 'error'
              });
            }
          } else {
            this.dispatchEvent({
              type: 'load'
            });
          }

          this.dispatchEvent({
            type: 'loadend'
          });
        }
      }
    }, {
      key: "addEventListener",
      value: function addEventListener(type, listener) {
        if (type === 'readystatechange' || type === 'progress') {
          this._incrementalEvents = true;
        }

        _get(_getPrototypeOf(XMLHttpRequest.prototype), "addEventListener", this).call(this, type, listener);
      }
    }, {
      key: "responseType",
      get: function get() {
        return this._responseType;
      },
      set: function set(responseType) {
        if (this._sent) {
          throw new Error("Failed to set the 'responseType' property on 'XMLHttpRequest': The " + 'response type cannot be set after the request has been sent.');
        }

        if (!SUPPORTED_RESPONSE_TYPES.hasOwnProperty(responseType)) {
          warning(false, "The provided value '" + responseType + "' is not a valid 'responseType'.");
          return;
        }

        invariant(SUPPORTED_RESPONSE_TYPES[responseType] || responseType === 'document', "The provided value '" + responseType + "' is unsupported in this environment.");

        if (responseType === 'blob') {
          invariant(BlobManager.isAvailable, 'Native module BlobModule is required for blob support');
        }

        this._responseType = responseType;
      }
    }, {
      key: "responseText",
      get: function get() {
        if (this._responseType !== '' && this._responseType !== 'text') {
          throw new Error("The 'responseText' property is only available if 'responseType' " + ("is set to '' or 'text', but it is '" + this._responseType + "'."));
        }

        if (this.readyState < LOADING) {
          return '';
        }

        return this._response;
      }
    }, {
      key: "response",
      get: function get() {
        var responseType = this.responseType;

        if (responseType === '' || responseType === 'text') {
          return this.readyState < LOADING || this._hasError ? '' : this._response;
        }

        if (this.readyState !== DONE) {
          return null;
        }

        if (this._cachedResponse !== undefined) {
          return this._cachedResponse;
        }

        switch (responseType) {
          case 'document':
            this._cachedResponse = null;
            break;

          case 'arraybuffer':
            this._cachedResponse = base64.toByteArray(this._response).buffer;
            break;

          case 'blob':
            if (typeof this._response === 'object' && this._response) {
              this._cachedResponse = BlobManager.createFromOptions(this._response);
            } else if (this._response === '') {
              this._cachedResponse = null;
            } else {
              throw new Error("Invalid response for blob: " + this._response);
            }

            break;

          case 'json':
            try {
              this._cachedResponse = JSON.parse(this._response);
            } catch (_) {
              this._cachedResponse = null;
            }

            break;

          default:
            this._cachedResponse = null;
        }

        return this._cachedResponse;
      }
    }]);

    return XMLHttpRequest;
  }(EventTarget.apply(void 0, _toConsumableArray(XHR_EVENTS)));

  XMLHttpRequest.UNSENT = UNSENT;
  XMLHttpRequest.OPENED = OPENED;
  XMLHttpRequest.HEADERS_RECEIVED = HEADERS_RECEIVED;
  XMLHttpRequest.LOADING = LOADING;
  XMLHttpRequest.DONE = DONE;
  XMLHttpRequest._interceptor = null;
  module.exports = XMLHttpRequest;
},126,[20,35,25,24,32,34,37,127,131,132,137,3,5],"node_modules/react-native/Libraries/Network/XMLHttpRequest.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _defineProperty2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/defineProperty"));

  var _extends2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/extends"));

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/createClass"));

  var _NativeBlobModule = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "./NativeBlobModule"));

  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "invariant"));

  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

  var Blob = _$$_REQUIRE(_dependencyMap[7], "./Blob");

  var BlobRegistry = _$$_REQUIRE(_dependencyMap[8], "./BlobRegistry");

  function uuidv4() {
    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
      var r = Math.random() * 16 | 0,
          v = c == 'x' ? r : r & 0x3 | 0x8;
      return v.toString(16);
    });
  }

  function createBlobCollector(blobId) {
    if (global.__blobCollectorProvider == null) {
      return null;
    } else {
      return global.__blobCollectorProvider(blobId);
    }
  }

  var BlobManager = function () {
    function BlobManager() {
      (0, _classCallCheck2.default)(this, BlobManager);
    }

    (0, _createClass2.default)(BlobManager, null, [{
      key: "createFromParts",
      value: function createFromParts(parts, options) {
        (0, _invariant.default)(_NativeBlobModule.default, 'NativeBlobModule is available.');
        var blobId = uuidv4();
        var items = parts.map(function (part) {
          if (part instanceof ArrayBuffer || global.ArrayBufferView && part instanceof global.ArrayBufferView) {
            throw new Error("Creating blobs from 'ArrayBuffer' and 'ArrayBufferView' are not supported");
          }

          if (part instanceof Blob) {
            return {
              data: part.data,
              type: 'blob'
            };
          } else {
            return {
              data: String(part),
              type: 'string'
            };
          }
        });
        var size = items.reduce(function (acc, curr) {
          if (curr.type === 'string') {
            return acc + global.unescape(encodeURI(curr.data)).length;
          } else {
            return acc + curr.data.size;
          }
        }, 0);

        _NativeBlobModule.default.createFromParts(items, blobId);

        return BlobManager.createFromOptions({
          blobId: blobId,
          offset: 0,
          size: size,
          type: options ? options.type : '',
          lastModified: options ? options.lastModified : Date.now()
        });
      }
    }, {
      key: "createFromOptions",
      value: function createFromOptions(options) {
        BlobRegistry.register(options.blobId);
        return (0, _extends2.default)(Object.create(Blob.prototype), {
          data: options.__collector == null ? _objectSpread({}, options, {
            __collector: createBlobCollector(options.blobId)
          }) : options
        });
      }
    }, {
      key: "release",
      value: function release(blobId) {
        (0, _invariant.default)(_NativeBlobModule.default, 'NativeBlobModule is available.');
        BlobRegistry.unregister(blobId);

        if (BlobRegistry.has(blobId)) {
          return;
        }

        _NativeBlobModule.default.release(blobId);
      }
    }, {
      key: "addNetworkingHandler",
      value: function addNetworkingHandler() {
        (0, _invariant.default)(_NativeBlobModule.default, 'NativeBlobModule is available.');

        _NativeBlobModule.default.addNetworkingHandler();
      }
    }, {
      key: "addWebSocketHandler",
      value: function addWebSocketHandler(socketId) {
        (0, _invariant.default)(_NativeBlobModule.default, 'NativeBlobModule is available.');

        _NativeBlobModule.default.addWebSocketHandler(socketId);
      }
    }, {
      key: "removeWebSocketHandler",
      value: function removeWebSocketHandler(socketId) {
        (0, _invariant.default)(_NativeBlobModule.default, 'NativeBlobModule is available.');

        _NativeBlobModule.default.removeWebSocketHandler(socketId);
      }
    }, {
      key: "sendOverSocket",
      value: function sendOverSocket(blob, socketId) {
        (0, _invariant.default)(_NativeBlobModule.default, 'NativeBlobModule is available.');

        _NativeBlobModule.default.sendOverSocket(blob.data, socketId);
      }
    }]);
    return BlobManager;
  }();

  BlobManager.isAvailable = !!_NativeBlobModule.default;
  module.exports = BlobManager;
},127,[1,46,13,24,25,128,3,129,130],"node_modules/react-native/Libraries/Blob/BlobManager.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireWildcard");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[1], "../TurboModule/TurboModuleRegistry"));

  var _default = TurboModuleRegistry.get('BlobModule');

  exports.default = _default;
},128,[9,11],"node_modules/react-native/Libraries/Blob/NativeBlobModule.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");

  var Blob = function () {
    function Blob() {
      var parts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
      var options = arguments.length > 1 ? arguments[1] : undefined;

      _classCallCheck(this, Blob);

      var BlobManager = _$$_REQUIRE(_dependencyMap[2], "./BlobManager");

      this.data = BlobManager.createFromParts(parts, options).data;
    }

    _createClass(Blob, [{
      key: "slice",
      value: function slice(start, end) {
        var BlobManager = _$$_REQUIRE(_dependencyMap[2], "./BlobManager");

        var _this$data = this.data,
            offset = _this$data.offset,
            size = _this$data.size;

        if (typeof start === 'number') {
          if (start > size) {
            start = size;
          }

          offset += start;
          size -= start;

          if (typeof end === 'number') {
            if (end < 0) {
              end = this.size + end;
            }

            size = end - start;
          }
        }

        return BlobManager.createFromOptions({
          blobId: this.data.blobId,
          offset: offset,
          size: size
        });
      }
    }, {
      key: "close",
      value: function close() {
        var BlobManager = _$$_REQUIRE(_dependencyMap[2], "./BlobManager");

        BlobManager.release(this.data.blobId);
        this.data = null;
      }
    }, {
      key: "data",
      set: function set(data) {
        this._data = data;
      },
      get: function get() {
        if (!this._data) {
          throw new Error('Blob has been closed and is no longer available');
        }

        return this._data;
      }
    }, {
      key: "size",
      get: function get() {
        return this.data.size;
      }
    }, {
      key: "type",
      get: function get() {
        return this.data.type || '';
      }
    }]);

    return Blob;
  }();

  module.exports = Blob;
},129,[24,25,127],"node_modules/react-native/Libraries/Blob/Blob.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var registry = {};

  var register = function register(id) {
    if (registry[id]) {
      registry[id]++;
    } else {
      registry[id] = 1;
    }
  };

  var unregister = function unregister(id) {
    if (registry[id]) {
      registry[id]--;

      if (registry[id] <= 0) {
        delete registry[id];
      }
    }
  };

  var has = function has(id) {
    return registry[id] && registry[id] > 0;
  };

  module.exports = {
    register: register,
    unregister: unregister,
    has: has
  };
},130,[],"node_modules/react-native/Libraries/Blob/BlobRegistry.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  Object.defineProperty(exports, '__esModule', {
    value: true
  });
  var privateData = new WeakMap();
  var wrappers = new WeakMap();

  function pd(event) {
    var retv = privateData.get(event);
    console.assert(retv != null, "'this' is expected an Event object, but got", event);
    return retv;
  }

  function setCancelFlag(data) {
    if (data.passiveListener != null) {
      if (typeof console !== "undefined" && typeof console.error === "function") {
        console.error("Unable to preventDefault inside passive event listener invocation.", data.passiveListener);
      }

      return;
    }

    if (!data.event.cancelable) {
      return;
    }

    data.canceled = true;

    if (typeof data.event.preventDefault === "function") {
      data.event.preventDefault();
    }
  }

  function Event(eventTarget, event) {
    privateData.set(this, {
      eventTarget: eventTarget,
      event: event,
      eventPhase: 2,
      currentTarget: eventTarget,
      canceled: false,
      stopped: false,
      immediateStopped: false,
      passiveListener: null,
      timeStamp: event.timeStamp || Date.now()
    });
    Object.defineProperty(this, "isTrusted", {
      value: false,
      enumerable: true
    });
    var keys = Object.keys(event);

    for (var i = 0; i < keys.length; ++i) {
      var key = keys[i];

      if (!(key in this)) {
        Object.defineProperty(this, key, defineRedirectDescriptor(key));
      }
    }
  }

  Event.prototype = {
    get type() {
      return pd(this).event.type;
    },

    get target() {
      return pd(this).eventTarget;
    },

    get currentTarget() {
      return pd(this).currentTarget;
    },

    composedPath: function composedPath() {
      var currentTarget = pd(this).currentTarget;

      if (currentTarget == null) {
        return [];
      }

      return [currentTarget];
    },

    get NONE() {
      return 0;
    },

    get CAPTURING_PHASE() {
      return 1;
    },

    get AT_TARGET() {
      return 2;
    },

    get BUBBLING_PHASE() {
      return 3;
    },

    get eventPhase() {
      return pd(this).eventPhase;
    },

    stopPropagation: function stopPropagation() {
      var data = pd(this);
      data.stopped = true;

      if (typeof data.event.stopPropagation === "function") {
        data.event.stopPropagation();
      }
    },
    stopImmediatePropagation: function stopImmediatePropagation() {
      var data = pd(this);
      data.stopped = true;
      data.immediateStopped = true;

      if (typeof data.event.stopImmediatePropagation === "function") {
        data.event.stopImmediatePropagation();
      }
    },

    get bubbles() {
      return Boolean(pd(this).event.bubbles);
    },

    get cancelable() {
      return Boolean(pd(this).event.cancelable);
    },

    preventDefault: function preventDefault() {
      setCancelFlag(pd(this));
    },

    get defaultPrevented() {
      return pd(this).canceled;
    },

    get composed() {
      return Boolean(pd(this).event.composed);
    },

    get timeStamp() {
      return pd(this).timeStamp;
    },

    get srcElement() {
      return pd(this).eventTarget;
    },

    get cancelBubble() {
      return pd(this).stopped;
    },

    set cancelBubble(value) {
      if (!value) {
        return;
      }

      var data = pd(this);
      data.stopped = true;

      if (typeof data.event.cancelBubble === "boolean") {
        data.event.cancelBubble = true;
      }
    },

    get returnValue() {
      return !pd(this).canceled;
    },

    set returnValue(value) {
      if (!value) {
        setCancelFlag(pd(this));
      }
    },

    initEvent: function initEvent() {}
  };
  Object.defineProperty(Event.prototype, "constructor", {
    value: Event,
    configurable: true,
    writable: true
  });

  if (typeof window !== "undefined" && typeof window.Event !== "undefined") {
    Object.setPrototypeOf(Event.prototype, window.Event.prototype);
    wrappers.set(window.Event.prototype, Event);
  }

  function defineRedirectDescriptor(key) {
    return {
      get: function get() {
        return pd(this).event[key];
      },
      set: function set(value) {
        pd(this).event[key] = value;
      },
      configurable: true,
      enumerable: true
    };
  }

  function defineCallDescriptor(key) {
    return {
      value: function value() {
        var event = pd(this).event;
        return event[key].apply(event, arguments);
      },
      configurable: true,
      enumerable: true
    };
  }

  function defineWrapper(BaseEvent, proto) {
    var keys = Object.keys(proto);

    if (keys.length === 0) {
      return BaseEvent;
    }

    function CustomEvent(eventTarget, event) {
      BaseEvent.call(this, eventTarget, event);
    }

    CustomEvent.prototype = Object.create(BaseEvent.prototype, {
      constructor: {
        value: CustomEvent,
        configurable: true,
        writable: true
      }
    });

    for (var i = 0; i < keys.length; ++i) {
      var key = keys[i];

      if (!(key in BaseEvent.prototype)) {
        var descriptor = Object.getOwnPropertyDescriptor(proto, key);
        var isFunc = typeof descriptor.value === "function";
        Object.defineProperty(CustomEvent.prototype, key, isFunc ? defineCallDescriptor(key) : defineRedirectDescriptor(key));
      }
    }

    return CustomEvent;
  }

  function getWrapper(proto) {
    if (proto == null || proto === Object.prototype) {
      return Event;
    }

    var wrapper = wrappers.get(proto);

    if (wrapper == null) {
      wrapper = defineWrapper(getWrapper(Object.getPrototypeOf(proto)), proto);
      wrappers.set(proto, wrapper);
    }

    return wrapper;
  }

  function wrapEvent(eventTarget, event) {
    var Wrapper = getWrapper(Object.getPrototypeOf(event));
    return new Wrapper(eventTarget, event);
  }

  function isStopped(event) {
    return pd(event).immediateStopped;
  }

  function setEventPhase(event, eventPhase) {
    pd(event).eventPhase = eventPhase;
  }

  function setCurrentTarget(event, currentTarget) {
    pd(event).currentTarget = currentTarget;
  }

  function setPassiveListener(event, passiveListener) {
    pd(event).passiveListener = passiveListener;
  }

  var listenersMap = new WeakMap();
  var CAPTURE = 1;
  var BUBBLE = 2;
  var ATTRIBUTE = 3;

  function isObject(x) {
    return x !== null && typeof x === "object";
  }

  function getListeners(eventTarget) {
    var listeners = listenersMap.get(eventTarget);

    if (listeners == null) {
      throw new TypeError("'this' is expected an EventTarget object, but got another value.");
    }

    return listeners;
  }

  function defineEventAttributeDescriptor(eventName) {
    return {
      get: function get() {
        var listeners = getListeners(this);
        var node = listeners.get(eventName);

        while (node != null) {
          if (node.listenerType === ATTRIBUTE) {
            return node.listener;
          }

          node = node.next;
        }

        return null;
      },
      set: function set(listener) {
        if (typeof listener !== "function" && !isObject(listener)) {
          listener = null;
        }

        var listeners = getListeners(this);
        var prev = null;
        var node = listeners.get(eventName);

        while (node != null) {
          if (node.listenerType === ATTRIBUTE) {
            if (prev !== null) {
              prev.next = node.next;
            } else if (node.next !== null) {
              listeners.set(eventName, node.next);
            } else {
              listeners.delete(eventName);
            }
          } else {
            prev = node;
          }

          node = node.next;
        }

        if (listener !== null) {
          var newNode = {
            listener: listener,
            listenerType: ATTRIBUTE,
            passive: false,
            once: false,
            next: null
          };

          if (prev === null) {
            listeners.set(eventName, newNode);
          } else {
            prev.next = newNode;
          }
        }
      },
      configurable: true,
      enumerable: true
    };
  }

  function defineEventAttribute(eventTargetPrototype, eventName) {
    Object.defineProperty(eventTargetPrototype, "on" + eventName, defineEventAttributeDescriptor(eventName));
  }

  function defineCustomEventTarget(eventNames) {
    function CustomEventTarget() {
      EventTarget.call(this);
    }

    CustomEventTarget.prototype = Object.create(EventTarget.prototype, {
      constructor: {
        value: CustomEventTarget,
        configurable: true,
        writable: true
      }
    });

    for (var i = 0; i < eventNames.length; ++i) {
      defineEventAttribute(CustomEventTarget.prototype, eventNames[i]);
    }

    return CustomEventTarget;
  }

  function EventTarget() {
    if (this instanceof EventTarget) {
      listenersMap.set(this, new Map());
      return;
    }

    if (arguments.length === 1 && Array.isArray(arguments[0])) {
      return defineCustomEventTarget(arguments[0]);
    }

    if (arguments.length > 0) {
      var types = new Array(arguments.length);

      for (var i = 0; i < arguments.length; ++i) {
        types[i] = arguments[i];
      }

      return defineCustomEventTarget(types);
    }

    throw new TypeError("Cannot call a class as a function");
  }

  EventTarget.prototype = {
    addEventListener: function addEventListener(eventName, listener, options) {
      if (listener == null) {
        return;
      }

      if (typeof listener !== "function" && !isObject(listener)) {
        throw new TypeError("'listener' should be a function or an object.");
      }

      var listeners = getListeners(this);
      var optionsIsObj = isObject(options);
      var capture = optionsIsObj ? Boolean(options.capture) : Boolean(options);
      var listenerType = capture ? CAPTURE : BUBBLE;
      var newNode = {
        listener: listener,
        listenerType: listenerType,
        passive: optionsIsObj && Boolean(options.passive),
        once: optionsIsObj && Boolean(options.once),
        next: null
      };
      var node = listeners.get(eventName);

      if (node === undefined) {
        listeners.set(eventName, newNode);
        return;
      }

      var prev = null;

      while (node != null) {
        if (node.listener === listener && node.listenerType === listenerType) {
          return;
        }

        prev = node;
        node = node.next;
      }

      prev.next = newNode;
    },
    removeEventListener: function removeEventListener(eventName, listener, options) {
      if (listener == null) {
        return;
      }

      var listeners = getListeners(this);
      var capture = isObject(options) ? Boolean(options.capture) : Boolean(options);
      var listenerType = capture ? CAPTURE : BUBBLE;
      var prev = null;
      var node = listeners.get(eventName);

      while (node != null) {
        if (node.listener === listener && node.listenerType === listenerType) {
          if (prev !== null) {
            prev.next = node.next;
          } else if (node.next !== null) {
            listeners.set(eventName, node.next);
          } else {
            listeners.delete(eventName);
          }

          return;
        }

        prev = node;
        node = node.next;
      }
    },
    dispatchEvent: function dispatchEvent(event) {
      if (event == null || typeof event.type !== "string") {
        throw new TypeError('"event.type" should be a string.');
      }

      var listeners = getListeners(this);
      var eventName = event.type;
      var node = listeners.get(eventName);

      if (node == null) {
        return true;
      }

      var wrappedEvent = wrapEvent(this, event);
      var prev = null;

      while (node != null) {
        if (node.once) {
          if (prev !== null) {
            prev.next = node.next;
          } else if (node.next !== null) {
            listeners.set(eventName, node.next);
          } else {
            listeners.delete(eventName);
          }
        } else {
          prev = node;
        }

        setPassiveListener(wrappedEvent, node.passive ? node.listener : null);

        if (typeof node.listener === "function") {
          try {
            node.listener.call(this, wrappedEvent);
          } catch (err) {
            if (typeof console !== "undefined" && typeof console.error === "function") {
              console.error(err);
            }
          }
        } else if (node.listenerType !== ATTRIBUTE && typeof node.listener.handleEvent === "function") {
          node.listener.handleEvent(wrappedEvent);
        }

        if (isStopped(wrappedEvent)) {
          break;
        }

        node = node.next;
      }

      setPassiveListener(wrappedEvent, null);
      setEventPhase(wrappedEvent, 0);
      setCurrentTarget(wrappedEvent, null);
      return !wrappedEvent.defaultPrevented;
    }
  };
  Object.defineProperty(EventTarget.prototype, "constructor", {
    value: EventTarget,
    configurable: true,
    writable: true
  });

  if (typeof window !== "undefined" && typeof window.EventTarget !== "undefined") {
    Object.setPrototypeOf(EventTarget.prototype, window.EventTarget.prototype);
  }

  exports.defineEventAttribute = defineEventAttribute;
  exports.EventTarget = EventTarget;
  exports.default = EventTarget;
  module.exports = EventTarget;
  module.exports.EventTarget = module.exports["default"] = EventTarget;
  module.exports.defineEventAttribute = defineEventAttribute;
},131,[],"node_modules/event-target-shim/dist/event-target-shim.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _defineProperty2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/defineProperty"));

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits"));

  var _NativeNetworkingAndroid = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "./NativeNetworkingAndroid"));

  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

  var NativeEventEmitter = _$$_REQUIRE(_dependencyMap[8], "../EventEmitter/NativeEventEmitter");

  var convertRequestBody = _$$_REQUIRE(_dependencyMap[9], "./convertRequestBody");

  function convertHeadersMapToArray(headers) {
    var headerArray = [];

    for (var name in headers) {
      headerArray.push([name, headers[name]]);
    }

    return headerArray;
  }

  var _requestId = 1;

  function generateRequestId() {
    return _requestId++;
  }

  var RCTNetworking = function (_NativeEventEmitter) {
    (0, _inherits2.default)(RCTNetworking, _NativeEventEmitter);

    function RCTNetworking() {
      (0, _classCallCheck2.default)(this, RCTNetworking);
      return (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(RCTNetworking).call(this, _NativeNetworkingAndroid.default));
    }

    (0, _createClass2.default)(RCTNetworking, [{
      key: "sendRequest",
      value: function sendRequest(method, trackingName, url, headers, data, responseType, incrementalUpdates, timeout, callback, withCredentials) {
        var body = convertRequestBody(data);

        if (body && body.formData) {
          body.formData = body.formData.map(function (part) {
            return _objectSpread({}, part, {
              headers: convertHeadersMapToArray(part.headers)
            });
          });
        }

        var requestId = generateRequestId();

        _NativeNetworkingAndroid.default.sendRequest(method, url, requestId, convertHeadersMapToArray(headers), _objectSpread({}, body, {
          trackingName: trackingName
        }), responseType, incrementalUpdates, timeout, withCredentials);

        callback(requestId);
      }
    }, {
      key: "abortRequest",
      value: function abortRequest(requestId) {
        _NativeNetworkingAndroid.default.abortRequest(requestId);
      }
    }, {
      key: "clearCookies",
      value: function clearCookies(callback) {
        _NativeNetworkingAndroid.default.clearCookies(callback);
      }
    }]);
    return RCTNetworking;
  }(NativeEventEmitter);

  module.exports = new RCTNetworking();
},132,[1,46,24,25,32,34,37,133,134,135],"node_modules/react-native/Libraries/Network/RCTNetworking.android.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireWildcard");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[1], "../TurboModule/TurboModuleRegistry"));

  var _default = TurboModuleRegistry.getEnforcing('Networking');

  exports.default = _default;
},133,[9,11],"node_modules/react-native/Libraries/Network/NativeNetworkingAndroid.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");

  var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");

  var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");

  var _get = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/get");

  var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");

  var EventEmitter = _$$_REQUIRE(_dependencyMap[6], "../vendor/emitter/EventEmitter");

  var Platform = _$$_REQUIRE(_dependencyMap[7], "../Utilities/Platform");

  var RCTDeviceEventEmitter = _$$_REQUIRE(_dependencyMap[8], "./RCTDeviceEventEmitter");

  var invariant = _$$_REQUIRE(_dependencyMap[9], "invariant");

  var NativeEventEmitter = function (_EventEmitter) {
    _inherits(NativeEventEmitter, _EventEmitter);

    function NativeEventEmitter(nativeModule) {
      var _this;

      _classCallCheck(this, NativeEventEmitter);

      _this = _possibleConstructorReturn(this, _getPrototypeOf(NativeEventEmitter).call(this, RCTDeviceEventEmitter.sharedSubscriber));

      if ("android" === 'ios') {
        invariant(nativeModule, 'Native module cannot be null.');
        _this._nativeModule = nativeModule;
      }

      return _this;
    }

    _createClass(NativeEventEmitter, [{
      key: "addListener",
      value: function addListener(eventType, listener, context) {
        if (this._nativeModule != null) {
          this._nativeModule.addListener(eventType);
        }

        return _get(_getPrototypeOf(NativeEventEmitter.prototype), "addListener", this).call(this, eventType, listener, context);
      }
    }, {
      key: "removeAllListeners",
      value: function removeAllListeners(eventType) {
        invariant(eventType, 'eventType argument is required.');
        var count = this.listeners(eventType).length;

        if (this._nativeModule != null) {
          this._nativeModule.removeListeners(count);
        }

        _get(_getPrototypeOf(NativeEventEmitter.prototype), "removeAllListeners", this).call(this, eventType);
      }
    }, {
      key: "removeSubscription",
      value: function removeSubscription(subscription) {
        if (this._nativeModule != null) {
          this._nativeModule.removeListeners(1);
        }

        _get(_getPrototypeOf(NativeEventEmitter.prototype), "removeSubscription", this).call(this, subscription);
      }
    }]);

    return NativeEventEmitter;
  }(EventEmitter);

  module.exports = NativeEventEmitter;
},134,[24,25,32,34,35,37,39,48,31,3],"node_modules/react-native/Libraries/EventEmitter/NativeEventEmitter.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var binaryToBase64 = _$$_REQUIRE(_dependencyMap[0], "../Utilities/binaryToBase64");

  var Blob = _$$_REQUIRE(_dependencyMap[1], "../Blob/Blob");

  var FormData = _$$_REQUIRE(_dependencyMap[2], "./FormData");

  function convertRequestBody(body) {
    if (typeof body === 'string') {
      return {
        string: body
      };
    }

    if (body instanceof Blob) {
      return {
        blob: body.data
      };
    }

    if (body instanceof FormData) {
      return {
        formData: body.getParts()
      };
    }

    if (body instanceof ArrayBuffer || ArrayBuffer.isView(body)) {
      return {
        base64: binaryToBase64(body)
      };
    }

    return body;
  }

  module.exports = convertRequestBody;
},135,[136,129,138],"node_modules/react-native/Libraries/Network/convertRequestBody.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var base64 = _$$_REQUIRE(_dependencyMap[0], "base64-js");

  function binaryToBase64(data) {
    if (data instanceof ArrayBuffer) {
      data = new Uint8Array(data);
    }

    if (data instanceof Uint8Array) {
      return base64.fromByteArray(data);
    }

    if (!ArrayBuffer.isView(data)) {
      throw new Error('data must be ArrayBuffer or typed array');
    }

    var _data = data,
        buffer = _data.buffer,
        byteOffset = _data.byteOffset,
        byteLength = _data.byteLength;
    return base64.fromByteArray(new Uint8Array(buffer, byteOffset, byteLength));
  }

  module.exports = binaryToBase64;
},136,[137],"node_modules/react-native/Libraries/Utilities/binaryToBase64.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  exports.byteLength = byteLength;
  exports.toByteArray = toByteArray;
  exports.fromByteArray = fromByteArray;
  var lookup = [];
  var revLookup = [];
  var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array;
  var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';

  for (var i = 0, len = code.length; i < len; ++i) {
    lookup[i] = code[i];
    revLookup[code.charCodeAt(i)] = i;
  }

  revLookup['-'.charCodeAt(0)] = 62;
  revLookup['_'.charCodeAt(0)] = 63;

  function getLens(b64) {
    var len = b64.length;

    if (len % 4 > 0) {
      throw new Error('Invalid string. Length must be a multiple of 4');
    }

    var validLen = b64.indexOf('=');
    if (validLen === -1) validLen = len;
    var placeHoldersLen = validLen === len ? 0 : 4 - validLen % 4;
    return [validLen, placeHoldersLen];
  }

  function byteLength(b64) {
    var lens = getLens(b64);
    var validLen = lens[0];
    var placeHoldersLen = lens[1];
    return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
  }

  function _byteLength(b64, validLen, placeHoldersLen) {
    return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
  }

  function toByteArray(b64) {
    var tmp;
    var lens = getLens(b64);
    var validLen = lens[0];
    var placeHoldersLen = lens[1];
    var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen));
    var curByte = 0;
    var len = placeHoldersLen > 0 ? validLen - 4 : validLen;
    var i;

    for (i = 0; i < len; i += 4) {
      tmp = revLookup[b64.charCodeAt(i)] << 18 | revLookup[b64.charCodeAt(i + 1)] << 12 | revLookup[b64.charCodeAt(i + 2)] << 6 | revLookup[b64.charCodeAt(i + 3)];
      arr[curByte++] = tmp >> 16 & 0xFF;
      arr[curByte++] = tmp >> 8 & 0xFF;
      arr[curByte++] = tmp & 0xFF;
    }

    if (placeHoldersLen === 2) {
      tmp = revLookup[b64.charCodeAt(i)] << 2 | revLookup[b64.charCodeAt(i + 1)] >> 4;
      arr[curByte++] = tmp & 0xFF;
    }

    if (placeHoldersLen === 1) {
      tmp = revLookup[b64.charCodeAt(i)] << 10 | revLookup[b64.charCodeAt(i + 1)] << 4 | revLookup[b64.charCodeAt(i + 2)] >> 2;
      arr[curByte++] = tmp >> 8 & 0xFF;
      arr[curByte++] = tmp & 0xFF;
    }

    return arr;
  }

  function tripletToBase64(num) {
    return lookup[num >> 18 & 0x3F] + lookup[num >> 12 & 0x3F] + lookup[num >> 6 & 0x3F] + lookup[num & 0x3F];
  }

  function encodeChunk(uint8, start, end) {
    var tmp;
    var output = [];

    for (var i = start; i < end; i += 3) {
      tmp = (uint8[i] << 16 & 0xFF0000) + (uint8[i + 1] << 8 & 0xFF00) + (uint8[i + 2] & 0xFF);
      output.push(tripletToBase64(tmp));
    }

    return output.join('');
  }

  function fromByteArray(uint8) {
    var tmp;
    var len = uint8.length;
    var extraBytes = len % 3;
    var parts = [];
    var maxChunkLength = 16383;

    for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
      parts.push(encodeChunk(uint8, i, i + maxChunkLength > len2 ? len2 : i + maxChunkLength));
    }

    if (extraBytes === 1) {
      tmp = uint8[len - 1];
      parts.push(lookup[tmp >> 2] + lookup[tmp << 4 & 0x3F] + '==');
    } else if (extraBytes === 2) {
      tmp = (uint8[len - 2] << 8) + uint8[len - 1];
      parts.push(lookup[tmp >> 10] + lookup[tmp >> 4 & 0x3F] + lookup[tmp << 2 & 0x3F] + '=');
    }

    return parts.join('');
  }
},137,[],"node_modules/base64-js/index.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");

  var _slicedToArray = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/slicedToArray");

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass");

  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

  var FormData = function () {
    function FormData() {
      _classCallCheck(this, FormData);

      this._parts = [];
    }

    _createClass(FormData, [{
      key: "append",
      value: function append(key, value) {
        this._parts.push([key, value]);
      }
    }, {
      key: "getParts",
      value: function getParts() {
        return this._parts.map(function (_ref) {
          var _ref2 = _slicedToArray(_ref, 2),
              name = _ref2[0],
              value = _ref2[1];

          var contentDisposition = 'form-data; name="' + name + '"';
          var headers = {
            'content-disposition': contentDisposition
          };

          if (typeof value === 'object' && value) {
            if (typeof value.name === 'string') {
              headers['content-disposition'] += '; filename="' + value.name + '"';
            }

            if (typeof value.type === 'string') {
              headers['content-type'] = value.type;
            }

            return _objectSpread({}, value, {
              headers: headers,
              fieldName: name
            });
          }

          return {
            string: String(value),
            headers: headers,
            fieldName: name
          };
        });
      }
    }]);

    return FormData;
  }();

  module.exports = FormData;
},138,[46,14,24,25],"node_modules/react-native/Libraries/Network/FormData.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _objectWithoutProperties2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/objectWithoutProperties"));

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits"));

  var _NativeWebSocketModule = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "./NativeWebSocketModule"));

  var Blob = _$$_REQUIRE(_dependencyMap[8], "../Blob/Blob");

  var BlobManager = _$$_REQUIRE(_dependencyMap[9], "../Blob/BlobManager");

  var EventTarget = _$$_REQUIRE(_dependencyMap[10], "event-target-shim");

  var NativeEventEmitter = _$$_REQUIRE(_dependencyMap[11], "../EventEmitter/NativeEventEmitter");

  var Platform = _$$_REQUIRE(_dependencyMap[12], "../Utilities/Platform");

  var WebSocketEvent = _$$_REQUIRE(_dependencyMap[13], "./WebSocketEvent");

  var base64 = _$$_REQUIRE(_dependencyMap[14], "base64-js");

  var binaryToBase64 = _$$_REQUIRE(_dependencyMap[15], "../Utilities/binaryToBase64");

  var invariant = _$$_REQUIRE(_dependencyMap[16], "invariant");

  var CONNECTING = 0;
  var OPEN = 1;
  var CLOSING = 2;
  var CLOSED = 3;
  var CLOSE_NORMAL = 1000;
  var WEBSOCKET_EVENTS = ['close', 'error', 'message', 'open'];
  var nextWebSocketId = 0;

  var WebSocket = function (_ref) {
    (0, _inherits2.default)(WebSocket, _ref);

    function WebSocket(url, protocols, options) {
      var _this;

      (0, _classCallCheck2.default)(this, WebSocket);
      _this = (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(WebSocket).call(this));
      _this.CONNECTING = CONNECTING;
      _this.OPEN = OPEN;
      _this.CLOSING = CLOSING;
      _this.CLOSED = CLOSED;
      _this.readyState = CONNECTING;

      if (typeof protocols === 'string') {
        protocols = [protocols];
      }

      var _ref2 = options || {},
          _ref2$headers = _ref2.headers,
          headers = _ref2$headers === void 0 ? {} : _ref2$headers,
          unrecognized = (0, _objectWithoutProperties2.default)(_ref2, ["headers"]);

      if (unrecognized && typeof unrecognized.origin === 'string') {
        console.warn('Specifying `origin` as a WebSocket connection option is deprecated. Include it under `headers` instead.');
        headers.origin = unrecognized.origin;
        delete unrecognized.origin;
      }

      if (Object.keys(unrecognized).length > 0) {
        console.warn('Unrecognized WebSocket connection option(s) `' + Object.keys(unrecognized).join('`, `') + '`. ' + 'Did you mean to put these under `headers`?');
      }

      if (!Array.isArray(protocols)) {
        protocols = null;
      }

      _this._eventEmitter = new NativeEventEmitter(_NativeWebSocketModule.default);
      _this._socketId = nextWebSocketId++;

      _this._registerEvents();

      _NativeWebSocketModule.default.connect(url, protocols, {
        headers: headers
      }, _this._socketId);

      return _this;
    }

    (0, _createClass2.default)(WebSocket, [{
      key: "close",
      value: function close(code, reason) {
        if (this.readyState === this.CLOSING || this.readyState === this.CLOSED) {
          return;
        }

        this.readyState = this.CLOSING;

        this._close(code, reason);
      }
    }, {
      key: "send",
      value: function send(data) {
        if (this.readyState === this.CONNECTING) {
          throw new Error('INVALID_STATE_ERR');
        }

        if (data instanceof Blob) {
          invariant(BlobManager.isAvailable, 'Native module BlobModule is required for blob support');
          BlobManager.sendOverSocket(data, this._socketId);
          return;
        }

        if (typeof data === 'string') {
          _NativeWebSocketModule.default.send(data, this._socketId);

          return;
        }

        if (data instanceof ArrayBuffer || ArrayBuffer.isView(data)) {
          _NativeWebSocketModule.default.sendBinary(binaryToBase64(data), this._socketId);

          return;
        }

        throw new Error('Unsupported data type');
      }
    }, {
      key: "ping",
      value: function ping() {
        if (this.readyState === this.CONNECTING) {
          throw new Error('INVALID_STATE_ERR');
        }

        _NativeWebSocketModule.default.ping(this._socketId);
      }
    }, {
      key: "_close",
      value: function _close(code, reason) {
        var statusCode = typeof code === 'number' ? code : CLOSE_NORMAL;
        var closeReason = typeof reason === 'string' ? reason : '';

        _NativeWebSocketModule.default.close(statusCode, closeReason, this._socketId);

        if (BlobManager.isAvailable && this._binaryType === 'blob') {
          BlobManager.removeWebSocketHandler(this._socketId);
        }
      }
    }, {
      key: "_unregisterEvents",
      value: function _unregisterEvents() {
        this._subscriptions.forEach(function (e) {
          return e.remove();
        });

        this._subscriptions = [];
      }
    }, {
      key: "_registerEvents",
      value: function _registerEvents() {
        var _this2 = this;

        this._subscriptions = [this._eventEmitter.addListener('websocketMessage', function (ev) {
          if (ev.id !== _this2._socketId) {
            return;
          }

          var data = ev.data;

          switch (ev.type) {
            case 'binary':
              data = base64.toByteArray(ev.data).buffer;
              break;

            case 'blob':
              data = BlobManager.createFromOptions(ev.data);
              break;
          }

          _this2.dispatchEvent(new WebSocketEvent('message', {
            data: data
          }));
        }), this._eventEmitter.addListener('websocketOpen', function (ev) {
          if (ev.id !== _this2._socketId) {
            return;
          }

          _this2.readyState = _this2.OPEN;
          _this2.protocol = ev.protocol;

          _this2.dispatchEvent(new WebSocketEvent('open'));
        }), this._eventEmitter.addListener('websocketClosed', function (ev) {
          if (ev.id !== _this2._socketId) {
            return;
          }

          _this2.readyState = _this2.CLOSED;

          _this2.dispatchEvent(new WebSocketEvent('close', {
            code: ev.code,
            reason: ev.reason
          }));

          _this2._unregisterEvents();

          _this2.close();
        }), this._eventEmitter.addListener('websocketFailed', function (ev) {
          if (ev.id !== _this2._socketId) {
            return;
          }

          _this2.readyState = _this2.CLOSED;

          _this2.dispatchEvent(new WebSocketEvent('error', {
            message: ev.message
          }));

          _this2.dispatchEvent(new WebSocketEvent('close', {
            message: ev.message
          }));

          _this2._unregisterEvents();

          _this2.close();
        })];
      }
    }, {
      key: "binaryType",
      get: function get() {
        return this._binaryType;
      },
      set: function set(binaryType) {
        if (binaryType !== 'blob' && binaryType !== 'arraybuffer') {
          throw new Error("binaryType must be either 'blob' or 'arraybuffer'");
        }

        if (this._binaryType === 'blob' || binaryType === 'blob') {
          invariant(BlobManager.isAvailable, 'Native module BlobModule is required for blob support');

          if (binaryType === 'blob') {
            BlobManager.addWebSocketHandler(this._socketId);
          } else {
            BlobManager.removeWebSocketHandler(this._socketId);
          }
        }

        this._binaryType = binaryType;
      }
    }]);
    return WebSocket;
  }(EventTarget.apply(void 0, WEBSOCKET_EVENTS));

  WebSocket.CONNECTING = CONNECTING;
  WebSocket.OPEN = OPEN;
  WebSocket.CLOSING = CLOSING;
  WebSocket.CLOSED = CLOSED;
  module.exports = WebSocket;
},139,[1,52,24,25,32,34,37,140,129,127,131,134,48,141,137,136,3],"node_modules/react-native/Libraries/WebSocket/WebSocket.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireWildcard");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[1], "../TurboModule/TurboModuleRegistry"));

  var _default = TurboModuleRegistry.getEnforcing('WebSocketModule');

  exports.default = _default;
},140,[9,11],"node_modules/react-native/Libraries/WebSocket/NativeWebSocketModule.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");

  var WebSocketEvent = function WebSocketEvent(type, eventInitDict) {
    _classCallCheck(this, WebSocketEvent);

    this.type = type.toString();

    _extends(this, eventInitDict);
  };

  module.exports = WebSocketEvent;
},141,[13,24],"node_modules/react-native/Libraries/WebSocket/WebSocketEvent.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");

  var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");

  var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");

  var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");

  var Blob = _$$_REQUIRE(_dependencyMap[5], "./Blob");

  var invariant = _$$_REQUIRE(_dependencyMap[6], "invariant");

  var File = function (_Blob) {
    _inherits(File, _Blob);

    function File(parts, name, options) {
      var _this;

      _classCallCheck(this, File);

      invariant(parts != null && name != null, 'Failed to construct `File`: Must pass both `parts` and `name` arguments.');
      _this = _possibleConstructorReturn(this, _getPrototypeOf(File).call(this, parts, options));
      _this.data.name = name;
      return _this;
    }

    _createClass(File, [{
      key: "name",
      get: function get() {
        invariant(this.data.name != null, 'Files must have a name set.');
        return this.data.name;
      }
    }, {
      key: "lastModified",
      get: function get() {
        return this.data.lastModified || 0;
      }
    }]);

    return File;
  }(Blob);

  module.exports = File;
},142,[24,25,32,34,37,129,3],"node_modules/react-native/Libraries/Blob/File.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits"));

  var _NativeFileReaderModule = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "./NativeFileReaderModule"));

  var Blob = _$$_REQUIRE(_dependencyMap[7], "./Blob");

  var EventTarget = _$$_REQUIRE(_dependencyMap[8], "event-target-shim");

  var READER_EVENTS = ['abort', 'error', 'load', 'loadstart', 'loadend', 'progress'];
  var EMPTY = 0;
  var LOADING = 1;
  var DONE = 2;

  var FileReader = function (_ref) {
    (0, _inherits2.default)(FileReader, _ref);

    function FileReader() {
      var _this;

      (0, _classCallCheck2.default)(this, FileReader);
      _this = (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(FileReader).call(this));
      _this.EMPTY = EMPTY;
      _this.LOADING = LOADING;
      _this.DONE = DONE;
      _this._aborted = false;
      _this._subscriptions = [];

      _this._reset();

      return _this;
    }

    (0, _createClass2.default)(FileReader, [{
      key: "_reset",
      value: function _reset() {
        this._readyState = EMPTY;
        this._error = null;
        this._result = null;
      }
    }, {
      key: "_clearSubscriptions",
      value: function _clearSubscriptions() {
        this._subscriptions.forEach(function (sub) {
          return sub.remove();
        });

        this._subscriptions = [];
      }
    }, {
      key: "_setReadyState",
      value: function _setReadyState(newState) {
        this._readyState = newState;
        this.dispatchEvent({
          type: 'readystatechange'
        });

        if (newState === DONE) {
          if (this._aborted) {
            this.dispatchEvent({
              type: 'abort'
            });
          } else if (this._error) {
            this.dispatchEvent({
              type: 'error'
            });
          } else {
            this.dispatchEvent({
              type: 'load'
            });
          }

          this.dispatchEvent({
            type: 'loadend'
          });
        }
      }
    }, {
      key: "readAsArrayBuffer",
      value: function readAsArrayBuffer() {
        throw new Error('FileReader.readAsArrayBuffer is not implemented');
      }
    }, {
      key: "readAsDataURL",
      value: function readAsDataURL(blob) {
        var _this2 = this;

        this._aborted = false;

        _NativeFileReaderModule.default.readAsDataURL(blob.data).then(function (text) {
          if (_this2._aborted) {
            return;
          }

          _this2._result = text;

          _this2._setReadyState(DONE);
        }, function (error) {
          if (_this2._aborted) {
            return;
          }

          _this2._error = error;

          _this2._setReadyState(DONE);
        });
      }
    }, {
      key: "readAsText",
      value: function readAsText(blob) {
        var _this3 = this;

        var encoding = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'UTF-8';
        this._aborted = false;

        _NativeFileReaderModule.default.readAsText(blob.data, encoding).then(function (text) {
          if (_this3._aborted) {
            return;
          }

          _this3._result = text;

          _this3._setReadyState(DONE);
        }, function (error) {
          if (_this3._aborted) {
            return;
          }

          _this3._error = error;

          _this3._setReadyState(DONE);
        });
      }
    }, {
      key: "abort",
      value: function abort() {
        this._aborted = true;

        if (this._readyState !== EMPTY && this._readyState !== DONE) {
          this._reset();

          this._setReadyState(DONE);
        }

        this._reset();
      }
    }, {
      key: "readyState",
      get: function get() {
        return this._readyState;
      }
    }, {
      key: "error",
      get: function get() {
        return this._error;
      }
    }, {
      key: "result",
      get: function get() {
        return this._result;
      }
    }]);
    return FileReader;
  }(EventTarget.apply(void 0, READER_EVENTS));

  FileReader.EMPTY = EMPTY;
  FileReader.LOADING = LOADING;
  FileReader.DONE = DONE;
  module.exports = FileReader;
},143,[1,24,25,32,34,37,144,129,131],"node_modules/react-native/Libraries/Blob/FileReader.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireWildcard");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[1], "../TurboModule/TurboModuleRegistry"));

  var _default = TurboModuleRegistry.getEnforcing('FileReaderModule');

  exports.default = _default;
},144,[9,11],"node_modules/react-native/Libraries/Blob/NativeFileReaderModule.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.URL = exports.URLSearchParams = void 0;

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));

  var _NativeBlobModule = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "./NativeBlobModule"));

  var _Symbol$iterator;

  var Blob = _$$_REQUIRE(_dependencyMap[4], "./Blob");

  var BLOB_URL_PREFIX = null;

  if (_NativeBlobModule.default && typeof _NativeBlobModule.default.getConstants().BLOB_URI_SCHEME === 'string') {
    var constants = _NativeBlobModule.default.getConstants();

    BLOB_URL_PREFIX = constants.BLOB_URI_SCHEME + ':';

    if (typeof constants.BLOB_URI_HOST === 'string') {
      BLOB_URL_PREFIX += "//" + constants.BLOB_URI_HOST + "/";
    }
  }

  _Symbol$iterator = Symbol.iterator;

  var URLSearchParams = function () {
    function URLSearchParams(params) {
      var _this = this;

      (0, _classCallCheck2.default)(this, URLSearchParams);
      this._searchParams = [];

      if (typeof params === 'object') {
        Object.keys(params).forEach(function (key) {
          return _this.append(key, params[key]);
        });
      }
    }

    (0, _createClass2.default)(URLSearchParams, [{
      key: "append",
      value: function append(key, value) {
        this._searchParams.push([key, value]);
      }
    }, {
      key: "delete",
      value: function _delete(name) {
        throw new Error('not implemented');
      }
    }, {
      key: "get",
      value: function get(name) {
        throw new Error('not implemented');
      }
    }, {
      key: "getAll",
      value: function getAll(name) {
        throw new Error('not implemented');
      }
    }, {
      key: "has",
      value: function has(name) {
        throw new Error('not implemented');
      }
    }, {
      key: "set",
      value: function set(name, value) {
        throw new Error('not implemented');
      }
    }, {
      key: "sort",
      value: function sort() {
        throw new Error('not implemented');
      }
    }, {
      key: _Symbol$iterator,
      value: function value() {
        return this._searchParams[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"]();
      }
    }, {
      key: "toString",
      value: function toString() {
        if (this._searchParams.length === 0) {
          return '';
        }

        var last = this._searchParams.length - 1;
        return this._searchParams.reduce(function (acc, curr, index) {
          return acc + curr.join('=') + (index === last ? '' : '&');
        }, '');
      }
    }]);
    return URLSearchParams;
  }();

  exports.URLSearchParams = URLSearchParams;

  function validateBaseUrl(url) {
    return /^(?:(?:(?:https?|ftp):)?\/\/)(?:(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-z\u00a1-\uffff0-9]-*)*[a-z\u00a1-\uffff0-9]+)(?:\.(?:[a-z\u00a1-\uffff0-9]-*)*[a-z\u00a1-\uffff0-9]+)*(?:\.(?:[a-z\u00a1-\uffff]{2,})))(?::\d{2,5})?(?:[/?#]\S*)?$/i.test(url);
  }

  var URL = function () {
    (0, _createClass2.default)(URL, null, [{
      key: "createObjectURL",
      value: function createObjectURL(blob) {
        if (BLOB_URL_PREFIX === null) {
          throw new Error('Cannot create URL for blob!');
        }

        return "" + BLOB_URL_PREFIX + blob.data.blobId + "?offset=" + blob.data.offset + "&size=" + blob.size;
      }
    }, {
      key: "revokeObjectURL",
      value: function revokeObjectURL(url) {}
    }]);

    function URL(url, base) {
      (0, _classCallCheck2.default)(this, URL);
      this._searchParamsInstance = null;
      var baseUrl = null;

      if (!base || validateBaseUrl(url)) {
        this._url = url;

        if (!this._url.endsWith('/')) {
          this._url += '/';
        }
      } else {
        if (typeof base === 'string') {
          baseUrl = base;

          if (!validateBaseUrl(baseUrl)) {
            throw new TypeError("Invalid base URL: " + baseUrl);
          }
        } else if (typeof base === 'object') {
          baseUrl = base.toString();
        }

        if (baseUrl.endsWith('/') && url.startsWith('/')) {
          baseUrl = baseUrl.slice(0, baseUrl.length - 1);
        }

        if (baseUrl.endsWith(url)) {
          url = '';
        }

        this._url = "" + baseUrl + url;
      }
    }

    (0, _createClass2.default)(URL, [{
      key: "toJSON",
      value: function toJSON() {
        return this.toString();
      }
    }, {
      key: "toString",
      value: function toString() {
        if (this._searchParamsInstance === null) {
          return this._url;
        }

        var separator = this._url.indexOf('?') > -1 ? '&' : '?';
        return this._url + separator + this._searchParamsInstance.toString();
      }
    }, {
      key: "hash",
      get: function get() {
        throw new Error('not implemented');
      }
    }, {
      key: "host",
      get: function get() {
        throw new Error('not implemented');
      }
    }, {
      key: "hostname",
      get: function get() {
        throw new Error('not implemented');
      }
    }, {
      key: "href",
      get: function get() {
        return this.toString();
      }
    }, {
      key: "origin",
      get: function get() {
        throw new Error('not implemented');
      }
    }, {
      key: "password",
      get: function get() {
        throw new Error('not implemented');
      }
    }, {
      key: "pathname",
      get: function get() {
        throw new Error('not implemented');
      }
    }, {
      key: "port",
      get: function get() {
        throw new Error('not implemented');
      }
    }, {
      key: "protocol",
      get: function get() {
        throw new Error('not implemented');
      }
    }, {
      key: "search",
      get: function get() {
        throw new Error('not implemented');
      }
    }, {
      key: "searchParams",
      get: function get() {
        if (this._searchParamsInstance == null) {
          this._searchParamsInstance = new URLSearchParams();
        }

        return this._searchParamsInstance;
      }
    }, {
      key: "username",
      get: function get() {
        throw new Error('not implemented');
      }
    }]);
    return URL;
  }();

  exports.URL = URL;
},145,[1,24,25,128,129],"node_modules/react-native/Libraries/Blob/URL.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");

  var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");

  var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");

  var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");

  Object.defineProperty(exports, '__esModule', {
    value: true
  });

  var eventTargetShim = _$$_REQUIRE(_dependencyMap[5], "event-target-shim");

  var AbortSignal = function (_eventTargetShim$Even) {
    _inherits(AbortSignal, _eventTargetShim$Even);

    function AbortSignal() {
      var _this;

      _classCallCheck(this, AbortSignal);

      _this = _possibleConstructorReturn(this, _getPrototypeOf(AbortSignal).call(this));
      throw new TypeError("AbortSignal cannot be constructed directly");
      return _this;
    }

    _createClass(AbortSignal, [{
      key: "aborted",
      get: function get() {
        var aborted = abortedFlags.get(this);

        if (typeof aborted !== "boolean") {
          throw new TypeError("Expected 'this' to be an 'AbortSignal' object, but got " + (this === null ? "null" : typeof this));
        }

        return aborted;
      }
    }]);

    return AbortSignal;
  }(eventTargetShim.EventTarget);

  eventTargetShim.defineEventAttribute(AbortSignal.prototype, "abort");

  function createAbortSignal() {
    var signal = Object.create(AbortSignal.prototype);
    eventTargetShim.EventTarget.call(signal);
    abortedFlags.set(signal, false);
    return signal;
  }

  function abortSignal(signal) {
    if (abortedFlags.get(signal) !== false) {
      return;
    }

    abortedFlags.set(signal, true);
    signal.dispatchEvent({
      type: "abort"
    });
  }

  var abortedFlags = new WeakMap();
  Object.defineProperties(AbortSignal.prototype, {
    aborted: {
      enumerable: true
    }
  });

  if (typeof Symbol === "function" && typeof (typeof Symbol === "function" ? Symbol.toStringTag : "@@toStringTag") === "symbol") {
    Object.defineProperty(AbortSignal.prototype, typeof Symbol === "function" ? Symbol.toStringTag : "@@toStringTag", {
      configurable: true,
      value: "AbortSignal"
    });
  }

  var AbortController = function () {
    function AbortController() {
      _classCallCheck(this, AbortController);

      signals.set(this, createAbortSignal());
    }

    _createClass(AbortController, [{
      key: "abort",
      value: function abort() {
        abortSignal(getSignal(this));
      }
    }, {
      key: "signal",
      get: function get() {
        return getSignal(this);
      }
    }]);

    return AbortController;
  }();

  var signals = new WeakMap();

  function getSignal(controller) {
    var signal = signals.get(controller);

    if (signal == null) {
      throw new TypeError("Expected 'this' to be an 'AbortController' object, but got " + (controller === null ? "null" : typeof controller));
    }

    return signal;
  }

  Object.defineProperties(AbortController.prototype, {
    signal: {
      enumerable: true
    },
    abort: {
      enumerable: true
    }
  });

  if (typeof Symbol === "function" && typeof (typeof Symbol === "function" ? Symbol.toStringTag : "@@toStringTag") === "symbol") {
    Object.defineProperty(AbortController.prototype, typeof Symbol === "function" ? Symbol.toStringTag : "@@toStringTag", {
      configurable: true,
      value: "AbortController"
    });
  }

  exports.AbortController = AbortController;
  exports.AbortSignal = AbortSignal;
  exports.default = AbortController;
  module.exports = AbortController;
  module.exports.AbortController = module.exports["default"] = AbortController;
  module.exports.AbortSignal = AbortSignal;
},146,[24,25,32,34,37,131],"node_modules/abort-controller/dist/abort-controller.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  if (!global.alert) {
    global.alert = function (text) {
      _$$_REQUIRE(_dependencyMap[0], "../Alert/Alert").alert('Alert', '' + text);
    };
  }
},147,[148],"node_modules/react-native/Libraries/Core/setUpAlert.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));

  var _Platform = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../Utilities/Platform"));

  var _NativeDialogManagerAndroid = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "../NativeModules/specs/NativeDialogManagerAndroid"));

  var _RCTAlertManager = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "./RCTAlertManager"));

  var Alert = function () {
    function Alert() {
      (0, _classCallCheck2.default)(this, Alert);
    }

    (0, _createClass2.default)(Alert, null, [{
      key: "alert",
      value: function alert(title, message, buttons, options) {
        if (_Platform.default.OS === 'ios') {
          Alert.prompt(title, message, buttons, 'default');
        } else if (_Platform.default.OS === 'android') {
          if (!_NativeDialogManagerAndroid.default) {
            return;
          }

          var constants = _NativeDialogManagerAndroid.default.getConstants();

          var config = {
            title: title || '',
            message: message || '',
            cancelable: false
          };

          if (options && options.cancelable) {
            config.cancelable = options.cancelable;
          }

          var defaultPositiveText = 'OK';
          var validButtons = buttons ? buttons.slice(0, 3) : [{
            text: defaultPositiveText
          }];
          var buttonPositive = validButtons.pop();
          var buttonNegative = validButtons.pop();
          var buttonNeutral = validButtons.pop();

          if (buttonNeutral) {
            config.buttonNeutral = buttonNeutral.text || '';
          }

          if (buttonNegative) {
            config.buttonNegative = buttonNegative.text || '';
          }

          if (buttonPositive) {
            config.buttonPositive = buttonPositive.text || defaultPositiveText;
          }

          var onAction = function onAction(action, buttonKey) {
            if (action === constants.buttonClicked) {
              if (buttonKey === constants.buttonNeutral) {
                buttonNeutral.onPress && buttonNeutral.onPress();
              } else if (buttonKey === constants.buttonNegative) {
                buttonNegative.onPress && buttonNegative.onPress();
              } else if (buttonKey === constants.buttonPositive) {
                buttonPositive.onPress && buttonPositive.onPress();
              }
            } else if (action === constants.dismissed) {
              options && options.onDismiss && options.onDismiss();
            }
          };

          var onError = function onError(errorMessage) {
            return console.warn(errorMessage);
          };

          _NativeDialogManagerAndroid.default.showAlert(config, onError, onAction);
        }
      }
    }, {
      key: "prompt",
      value: function prompt(title, message, callbackOrButtons) {
        var type = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'plain-text';
        var defaultValue = arguments.length > 4 ? arguments[4] : undefined;
        var keyboardType = arguments.length > 5 ? arguments[5] : undefined;

        if (_Platform.default.OS === 'ios') {
          if (typeof type === 'function') {
            console.warn('You passed a callback function as the "type" argument to Alert.prompt(). React Native is ' + 'assuming  you want to use the deprecated Alert.prompt(title, defaultValue, buttons, callback) ' + 'signature. The current signature is Alert.prompt(title, message, callbackOrButtons, type, defaultValue, ' + 'keyboardType) and the old syntax will be removed in a future version.');
            var callback = type;

            _RCTAlertManager.default.alertWithArgs({
              title: title || '',
              type: 'plain-text',
              defaultValue: message || ''
            }, function (id, value) {
              callback(value);
            });

            return;
          }

          var callbacks = [];
          var buttons = [];
          var cancelButtonKey;
          var destructiveButtonKey;

          if (typeof callbackOrButtons === 'function') {
            callbacks = [callbackOrButtons];
          } else if (Array.isArray(callbackOrButtons)) {
            callbackOrButtons.forEach(function (btn, index) {
              callbacks[index] = btn.onPress;

              if (btn.style === 'cancel') {
                cancelButtonKey = String(index);
              } else if (btn.style === 'destructive') {
                destructiveButtonKey = String(index);
              }

              if (btn.text || index < (callbackOrButtons || []).length - 1) {
                var btnDef = {};
                btnDef[index] = btn.text || '';
                buttons.push(btnDef);
              }
            });
          }

          _RCTAlertManager.default.alertWithArgs({
            title: title || '',
            message: message || undefined,
            buttons: buttons,
            type: type || undefined,
            defaultValue: defaultValue,
            cancelButtonKey: cancelButtonKey,
            destructiveButtonKey: destructiveButtonKey,
            keyboardType: keyboardType
          }, function (id, value) {
            var cb = callbacks[id];
            cb && cb(value);
          });
        }
      }
    }]);
    return Alert;
  }();

  module.exports = Alert;
},148,[1,24,25,48,149,150],"node_modules/react-native/Libraries/Alert/Alert.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireWildcard");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[1], "../../TurboModule/TurboModuleRegistry"));

  var _default = TurboModuleRegistry.get('DialogManagerAndroid');

  exports.default = _default;
},149,[9,11],"node_modules/react-native/Libraries/NativeModules/specs/NativeDialogManagerAndroid.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _NativeDialogManagerAndroid = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../NativeModules/specs/NativeDialogManagerAndroid"));

  function emptyCallback() {}

  module.exports = {
    alertWithArgs: function alertWithArgs(args, callback) {
      if (!_NativeDialogManagerAndroid.default) {
        return;
      }

      _NativeDialogManagerAndroid.default.showAlert(args, emptyCallback, callback || emptyCallback);
    }
  };
},150,[1,149],"node_modules/react-native/Libraries/Alert/RCTAlertManager.android.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _require = _$$_REQUIRE(_dependencyMap[0], "../Utilities/PolyfillFunctions"),
      polyfillObjectProperty = _require.polyfillObjectProperty;

  var navigator = global.navigator;

  if (navigator === undefined) {
    global.navigator = navigator = {};
  }

  polyfillObjectProperty(navigator, 'product', function () {
    return 'ReactNative';
  });
},151,[110],"node_modules/react-native/Libraries/Core/setUpNavigator.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  if (!global.RN$Bridgeless) {
    var BatchedBridge = _$$_REQUIRE(_dependencyMap[0], "../BatchedBridge/BatchedBridge");

    BatchedBridge.registerLazyCallableModule('Systrace', function () {
      return _$$_REQUIRE(_dependencyMap[1], "../Performance/Systrace");
    });
    BatchedBridge.registerLazyCallableModule('JSTimers', function () {
      return _$$_REQUIRE(_dependencyMap[2], "./Timers/JSTimers");
    });
    BatchedBridge.registerLazyCallableModule('HeapCapture', function () {
      return _$$_REQUIRE(_dependencyMap[3], "../HeapCapture/HeapCapture");
    });
    BatchedBridge.registerLazyCallableModule('SamplingProfiler', function () {
      return _$$_REQUIRE(_dependencyMap[4], "../Performance/SamplingProfiler");
    });
    BatchedBridge.registerLazyCallableModule('RCTLog', function () {
      return _$$_REQUIRE(_dependencyMap[5], "../Utilities/RCTLog");
    });
    BatchedBridge.registerLazyCallableModule('RCTDeviceEventEmitter', function () {
      return _$$_REQUIRE(_dependencyMap[6], "../EventEmitter/RCTDeviceEventEmitter");
    });
    BatchedBridge.registerLazyCallableModule('RCTNativeAppEventEmitter', function () {
      return _$$_REQUIRE(_dependencyMap[7], "../EventEmitter/RCTNativeAppEventEmitter");
    });
    BatchedBridge.registerLazyCallableModule('GlobalPerformanceLogger', function () {
      return _$$_REQUIRE(_dependencyMap[8], "../Utilities/GlobalPerformanceLogger");
    });
    BatchedBridge.registerLazyCallableModule('JSDevSupportModule', function () {
      return _$$_REQUIRE(_dependencyMap[9], "../Utilities/JSDevSupportModule");
    });

    if (__DEV__ && !global.__RCTProfileIsProfiling) {
      BatchedBridge.registerCallableModule('HMRClient', _$$_REQUIRE(_dependencyMap[10], "../Utilities/HMRClient"));
    } else {
      BatchedBridge.registerCallableModule('HMRClient', _$$_REQUIRE(_dependencyMap[11], "../Utilities/HMRClientProdShim"));
    }
  }
},152,[18,27,120,153,155,157,31,158,159,162,164,173],"node_modules/react-native/Libraries/Core/setUpBatchedBridge.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _NativeHeapCapture = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./NativeHeapCapture"));

  var HeapCapture = {
    captureHeap: function captureHeap(path) {
      var error = null;

      try {
        global.nativeCaptureHeap(path);
        console.log('HeapCapture.captureHeap succeeded: ' + path);
      } catch (e) {
        console.log('HeapCapture.captureHeap error: ' + e.toString());
        error = e.toString();
      }

      if (_NativeHeapCapture.default) {
        _NativeHeapCapture.default.captureComplete(path, error);
      }
    }
  };
  module.exports = HeapCapture;
},153,[1,154],"node_modules/react-native/Libraries/HeapCapture/HeapCapture.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireWildcard");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[1], "../TurboModule/TurboModuleRegistry"));

  var _default = TurboModuleRegistry.get('HeapCapture');

  exports.default = _default;
},154,[9,11],"node_modules/react-native/Libraries/HeapCapture/NativeHeapCapture.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var SamplingProfiler = {
    poke: function poke(token) {
      var error = null;
      var result = null;

      try {
        result = global.pokeSamplingProfiler();

        if (result === null) {
          console.log('The JSC Sampling Profiler has started');
        } else {
          console.log('The JSC Sampling Profiler has stopped');
        }
      } catch (e) {
        console.log('Error occurred when restarting Sampling Profiler: ' + e.toString());
        error = e.toString();
      }

      var NativeJSCSamplingProfiler = _$$_REQUIRE(_dependencyMap[0], "./NativeJSCSamplingProfiler").default;

      if (NativeJSCSamplingProfiler) {
        NativeJSCSamplingProfiler.operationComplete(token, result, error);
      }
    }
  };
  module.exports = SamplingProfiler;
},155,[156],"node_modules/react-native/Libraries/Performance/SamplingProfiler.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireWildcard");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[1], "../TurboModule/TurboModuleRegistry"));

  var _default = TurboModuleRegistry.get('JSCSamplingProfiler');

  exports.default = _default;
},156,[9,11],"node_modules/react-native/Libraries/Performance/NativeJSCSamplingProfiler.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var invariant = _$$_REQUIRE(_dependencyMap[0], "invariant");

  var levelsMap = {
    log: 'log',
    info: 'info',
    warn: 'warn',
    error: 'error',
    fatal: 'error'
  };
  var warningHandler = null;
  var RCTLog = {
    logIfNoNativeHook: function logIfNoNativeHook(level) {
      for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
        args[_key - 1] = arguments[_key];
      }

      if (typeof global.nativeLoggingHook === 'undefined') {
        RCTLog.logToConsole.apply(RCTLog, [level].concat(args));
      } else {
        if (warningHandler && level === 'warn') {
          warningHandler.apply(void 0, args);
        }
      }
    },
    logToConsole: function logToConsole(level) {
      var _console;

      var logFn = levelsMap[level];
      invariant(logFn, 'Level "' + level + '" not one of ' + Object.keys(levelsMap).toString());

      for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
        args[_key2 - 1] = arguments[_key2];
      }

      (_console = console)[logFn].apply(_console, args);
    },
    setWarningHandler: function setWarningHandler(handler) {
      warningHandler = handler;
    }
  };
  module.exports = RCTLog;
},157,[3],"node_modules/react-native/Libraries/Utilities/RCTLog.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var RCTDeviceEventEmitter = _$$_REQUIRE(_dependencyMap[0], "./RCTDeviceEventEmitter");

  var RCTNativeAppEventEmitter = RCTDeviceEventEmitter;
  module.exports = RCTNativeAppEventEmitter;
},158,[31],"node_modules/react-native/Libraries/EventEmitter/RCTNativeAppEventEmitter.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var createPerformanceLogger = _$$_REQUIRE(_dependencyMap[0], "./createPerformanceLogger");

  var GlobalPerformanceLogger = createPerformanceLogger();
  module.exports = GlobalPerformanceLogger;
},159,[160],"node_modules/react-native/Libraries/Utilities/GlobalPerformanceLogger.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var Systrace = _$$_REQUIRE(_dependencyMap[0], "../Performance/Systrace");

  var infoLog = _$$_REQUIRE(_dependencyMap[1], "./infoLog");

  var performanceNow = global.nativeQPLTimestamp || global.nativePerformanceNow || _$$_REQUIRE(_dependencyMap[2], "fbjs/lib/performanceNow");

  var _cookies = {};
  var PRINT_TO_CONSOLE = false;

  function createPerformanceLogger() {
    var result = {
      _timespans: {},
      _extras: {},
      _points: {},
      addTimespan: function addTimespan(key, lengthInMs, description) {
        if (this._timespans[key]) {
          if (PRINT_TO_CONSOLE && __DEV__) {
            infoLog('PerformanceLogger: Attempting to add a timespan that already exists ', key);
          }

          return;
        }

        this._timespans[key] = {
          description: description,
          totalTime: lengthInMs
        };
      },
      startTimespan: function startTimespan(key, description) {
        if (this._timespans[key]) {
          if (PRINT_TO_CONSOLE && __DEV__) {
            infoLog('PerformanceLogger: Attempting to start a timespan that already exists ', key);
          }

          return;
        }

        this._timespans[key] = {
          description: description,
          startTime: performanceNow()
        };
        _cookies[key] = Systrace.beginAsyncEvent(key);

        if (PRINT_TO_CONSOLE) {
          infoLog('PerformanceLogger.js', 'start: ' + key);
        }
      },
      stopTimespan: function stopTimespan(key) {
        var timespan = this._timespans[key];

        if (!timespan || !timespan.startTime) {
          if (PRINT_TO_CONSOLE && __DEV__) {
            infoLog('PerformanceLogger: Attempting to end a timespan that has not started ', key);
          }

          return;
        }

        if (timespan.endTime) {
          if (PRINT_TO_CONSOLE && __DEV__) {
            infoLog('PerformanceLogger: Attempting to end a timespan that has already ended ', key);
          }

          return;
        }

        timespan.endTime = performanceNow();
        timespan.totalTime = timespan.endTime - (timespan.startTime || 0);

        if (PRINT_TO_CONSOLE) {
          infoLog('PerformanceLogger.js', 'end: ' + key);
        }

        Systrace.endAsyncEvent(key, _cookies[key]);
        delete _cookies[key];
      },
      clear: function clear() {
        this._timespans = {};
        this._extras = {};
        this._points = {};

        if (PRINT_TO_CONSOLE) {
          infoLog('PerformanceLogger.js', 'clear');
        }
      },
      clearCompleted: function clearCompleted() {
        for (var _key in this._timespans) {
          if (this._timespans[_key].totalTime) {
            delete this._timespans[_key];
          }
        }

        this._extras = {};
        this._points = {};

        if (PRINT_TO_CONSOLE) {
          infoLog('PerformanceLogger.js', 'clearCompleted');
        }
      },
      clearExceptTimespans: function clearExceptTimespans(keys) {
        this._timespans = Object.keys(this._timespans).reduce(function (previous, key) {
          if (keys.indexOf(key) !== -1) {
            previous[key] = this._timespans[key];
          }

          return previous;
        }, {});
        this._extras = {};
        this._points = {};

        if (PRINT_TO_CONSOLE) {
          infoLog('PerformanceLogger.js', 'clearExceptTimespans', keys);
        }
      },
      currentTimestamp: function currentTimestamp() {
        return performanceNow();
      },
      getTimespans: function getTimespans() {
        return this._timespans;
      },
      hasTimespan: function hasTimespan(key) {
        return !!this._timespans[key];
      },
      logTimespans: function logTimespans() {
        if (PRINT_TO_CONSOLE) {
          for (var _key2 in this._timespans) {
            if (this._timespans[_key2].totalTime) {
              infoLog(_key2 + ': ' + this._timespans[_key2].totalTime + 'ms');
            }
          }
        }
      },
      addTimespans: function addTimespans(newTimespans, labels) {
        for (var ii = 0, l = newTimespans.length; ii < l; ii += 2) {
          var label = labels[ii / 2];
          this.addTimespan(label, newTimespans[ii + 1] - newTimespans[ii], label);
        }
      },
      setExtra: function setExtra(key, value) {
        if (this._extras[key]) {
          if (PRINT_TO_CONSOLE && __DEV__) {
            infoLog('PerformanceLogger: Attempting to set an extra that already exists ', {
              key: key,
              currentValue: this._extras[key],
              attemptedValue: value
            });
          }

          return;
        }

        this._extras[key] = value;
      },
      getExtras: function getExtras() {
        return this._extras;
      },
      removeExtra: function removeExtra(key) {
        var value = this._extras[key];
        delete this._extras[key];
        return value;
      },
      logExtras: function logExtras() {
        if (PRINT_TO_CONSOLE) {
          infoLog(this._extras);
        }
      },
      markPoint: function markPoint(key, timestamp) {
        if (this._points[key]) {
          if (PRINT_TO_CONSOLE && __DEV__) {
            infoLog('PerformanceLogger: Attempting to mark a point that has been already logged ', key);
          }

          return;
        }

        this._points[key] = timestamp != null ? timestamp : performanceNow();
      },
      getPoints: function getPoints() {
        return this._points;
      },
      logPoints: function logPoints() {
        if (PRINT_TO_CONSOLE) {
          for (var _key3 in this._points) {
            infoLog(_key3 + ': ' + this._points[_key3] + 'ms');
          }
        }
      },
      logEverything: function logEverything() {
        this.logTimespans();
        this.logExtras();
        this.logPoints();
      }
    };
    return result;
  }

  module.exports = createPerformanceLogger;
},160,[27,161,122],"node_modules/react-native/Libraries/Utilities/createPerformanceLogger.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  function infoLog() {
    var _console;

    return (_console = console).log.apply(_console, arguments);
  }

  module.exports = infoLog;
},161,[],"node_modules/react-native/Libraries/Utilities/infoLog.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _NativeJSDevSupport = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./NativeJSDevSupport"));

  var ReactNative = _$$_REQUIRE(_dependencyMap[2], "../Renderer/shims/ReactNative");

  var JSDevSupportModule = {
    getJSHierarchy: function getJSHierarchy(tag) {
      if (_NativeJSDevSupport.default) {
        var constants = _NativeJSDevSupport.default.getConstants();

        try {
          var computeComponentStackForErrorReporting = ReactNative.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.computeComponentStackForErrorReporting;
          var componentStack = computeComponentStackForErrorReporting(tag);

          if (!componentStack) {
            _NativeJSDevSupport.default.onFailure(constants.ERROR_CODE_VIEW_NOT_FOUND, "Component stack doesn't exist for tag " + tag);
          } else {
            _NativeJSDevSupport.default.onSuccess(componentStack);
          }
        } catch (e) {
          _NativeJSDevSupport.default.onFailure(constants.ERROR_CODE_EXCEPTION, e.message);
        }
      }
    }
  };
  module.exports = JSDevSupportModule;
},162,[1,163,88],"node_modules/react-native/Libraries/Utilities/JSDevSupportModule.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireWildcard");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[1], "../TurboModule/TurboModuleRegistry"));

  var _default = TurboModuleRegistry.get('JSDevSupport');

  exports.default = _default;
},163,[9,11],"node_modules/react-native/Libraries/Utilities/NativeJSDevSupport.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _NativeRedBox = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../NativeModules/specs/NativeRedBox"));

  var Platform = _$$_REQUIRE(_dependencyMap[2], "./Platform");

  var invariant = _$$_REQUIRE(_dependencyMap[3], "invariant");

  var MetroHMRClient = _$$_REQUIRE(_dependencyMap[4], "metro/src/lib/bundle-modules/HMRClient");

  var pendingEntryPoints = [];
  var hmrClient = null;
  var hmrUnavailableReason = null;
  var currentCompileErrorMessage = null;
  var didConnect = false;
  var HMRClient = {
    enable: function enable() {
      if (hmrUnavailableReason !== null) {
        throw new Error(hmrUnavailableReason);
      }

      invariant(hmrClient, 'Expected HMRClient.setup() call at startup.');

      var LoadingView = _$$_REQUIRE(_dependencyMap[5], "./LoadingView");

      hmrClient.send(JSON.stringify({
        type: 'log-opt-in'
      }));
      var hasUpdates = hmrClient.hasPendingUpdates();

      if (hasUpdates) {
        LoadingView.showMessage('Refreshing...', 'refresh');
      }

      try {
        hmrClient.enable();
      } finally {
        if (hasUpdates) {
          LoadingView.hide();
        }
      }

      showCompileError();
    },
    disable: function disable() {
      invariant(hmrClient, 'Expected HMRClient.setup() call at startup.');
      hmrClient.disable();
    },
    registerBundle: function registerBundle(requestUrl) {
      invariant(hmrClient, 'Expected HMRClient.setup() call at startup.');
      pendingEntryPoints.push(requestUrl);
      registerBundleEntryPoints(hmrClient);
    },
    log: function log(level, data) {
      try {
        if (hmrClient) {
          var message;

          if (global.Symbol) {
            message = JSON.stringify({
              type: 'log',
              level: level,
              data: data.map(function (item) {
                return typeof item === 'string' ? item : _$$_REQUIRE(_dependencyMap[6], "pretty-format")(item, {
                  escapeString: true,
                  highlight: true,
                  maxDepth: 3,
                  min: true,
                  plugins: [_$$_REQUIRE(_dependencyMap[6], "pretty-format").plugins.ReactElement]
                });
              })
            });
          } else {
            try {
              message = JSON.stringify({
                type: 'log',
                level: level,
                data: data
              });
            } catch (error) {
              message = JSON.stringify({
                type: 'log',
                level: level,
                data: [error.message]
              });
            }
          }

          hmrClient.send(message);
        }
      } catch (error) {}
    },
    setup: function setup(platform, bundleEntry, host, port, isEnabled) {
      invariant(platform, 'Missing required parameter `platform`');
      invariant(bundleEntry, 'Missing required paramenter `bundleEntry`');
      invariant(host, 'Missing required paramenter `host`');
      invariant(!hmrClient, 'Cannot initialize hmrClient twice');

      var LoadingView = _$$_REQUIRE(_dependencyMap[5], "./LoadingView");

      var wsHost = port !== null && port !== '' ? host + ":" + port : host;
      var client = new MetroHMRClient("ws://" + wsHost + "/hot");
      hmrClient = client;
      pendingEntryPoints.push("ws://" + wsHost + "/hot?bundleEntry=" + bundleEntry + "&platform=" + platform);
      client.on('connection-error', function (e) {
        var error = "Cannot connect to the Metro server.\n\nTry the following to fix the issue:\n- Ensure that the Metro server is running and available on the same network";

        if ("android" === 'ios') {
          error += "\n- Ensure that the Metro server URL is correctly set in AppDelegate";
        } else {
          error += "\n- Ensure that your device/emulator is connected to your machine and has USB debugging enabled - run 'adb devices' to see a list of connected devices\n- If you're on a physical device connected to the same machine, run 'adb reverse tcp:8081 tcp:8081' to forward requests from your device\n- If your device is on the same Wi-Fi network, set 'Debug server host & port for device' in 'Dev settings' to your machine's IP address and the port of the local dev server - e.g. 10.0.1.1:8081";
        }

        error += "\n\nURL: " + host + ":" + port + "\n\nError: " + e.message;
        setHMRUnavailableReason(error);
      });
      client.on('update-start', function (_ref) {
        var isInitialUpdate = _ref.isInitialUpdate;
        currentCompileErrorMessage = null;
        didConnect = true;

        if (client.isEnabled() && !isInitialUpdate) {
          LoadingView.showMessage('Refreshing...', 'refresh');
        }
      });
      client.on('update', function (_ref2) {
        var isInitialUpdate = _ref2.isInitialUpdate;

        if (client.isEnabled() && !isInitialUpdate) {
          dismissRedbox();
        }
      });
      client.on('update-done', function () {
        LoadingView.hide();
      });
      client.on('error', function (data) {
        LoadingView.hide();

        if (data.type === 'GraphNotFoundError') {
          client.close();
          setHMRUnavailableReason('The Metro server has restarted since the last edit. Reload to reconnect.');
        } else if (data.type === 'RevisionNotFoundError') {
          client.close();
          setHMRUnavailableReason('The Metro server and the client are out of sync. Reload to reconnect.');
        } else {
          currentCompileErrorMessage = data.type + " " + data.message;

          if (client.isEnabled()) {
            showCompileError();
          }
        }
      });
      client.on('close', function (data) {
        LoadingView.hide();
        setHMRUnavailableReason('Disconnected from the Metro server. Reload to reconnect.');
      });

      if (isEnabled) {
        HMRClient.enable();
      } else {
        HMRClient.disable();
      }

      registerBundleEntryPoints(hmrClient);
    }
  };

  function setHMRUnavailableReason(reason) {
    invariant(hmrClient, 'Expected HMRClient.setup() call at startup.');

    if (hmrUnavailableReason !== null) {
      return;
    }

    hmrUnavailableReason = reason;

    if (hmrClient.isEnabled() && didConnect) {
      console.warn(reason);
    }
  }

  function registerBundleEntryPoints(client) {
    if (pendingEntryPoints.length > 0) {
      client.send(JSON.stringify({
        type: 'register-entrypoints',
        entryPoints: pendingEntryPoints
      }));
      pendingEntryPoints.length = 0;
    }
  }

  function dismissRedbox() {
    if ("android" === 'ios' && _NativeRedBox.default != null && _NativeRedBox.default.dismiss != null) {
      _NativeRedBox.default.dismiss();
    } else {
      var NativeExceptionsManager = _$$_REQUIRE(_dependencyMap[7], "../Core/NativeExceptionsManager").default;

      NativeExceptionsManager && NativeExceptionsManager.dismissRedbox && NativeExceptionsManager.dismissRedbox();
    }
  }

  function showCompileError() {
    if (currentCompileErrorMessage === null) {
      return;
    }

    dismissRedbox();
    var message = currentCompileErrorMessage;
    currentCompileErrorMessage = null;
    var error = new Error(message);
    error.preventSymbolication = true;
    throw error;
  }

  module.exports = HMRClient;
},164,[1,165,48,3,166,170,117,99],"node_modules/react-native/Libraries/Utilities/HMRClient.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireWildcard");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[1], "../../TurboModule/TurboModuleRegistry"));

  var _default = TurboModuleRegistry.get('RedBox');

  exports.default = _default;
},165,[9,11],"node_modules/react-native/Libraries/NativeModules/specs/NativeRedBox.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  "use strict";

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");

  var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");

  var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");

  var _assertThisInitialized = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/assertThisInitialized");

  var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");

  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;
  }

  var WebSocketHMRClient = _$$_REQUIRE(_dependencyMap[6], "./WebSocketHMRClient");

  var injectUpdate = _$$_REQUIRE(_dependencyMap[7], "./injectUpdate");

  var HMRClient = function (_WebSocketHMRClient) {
    _inherits(HMRClient, _WebSocketHMRClient);

    function HMRClient(url) {
      var _this;

      _classCallCheck(this, HMRClient);

      _this = _possibleConstructorReturn(this, _getPrototypeOf(HMRClient).call(this, url));

      _defineProperty(_assertThisInitialized(_this), "_isEnabled", false);

      _defineProperty(_assertThisInitialized(_this), "_pendingUpdate", null);

      _this.on("update", function (update) {
        if (_this._isEnabled) {
          injectUpdate(update);
        } else if (_this._pendingUpdate == null) {
          _this._pendingUpdate = update;
        } else {
          _this._pendingUpdate = mergeUpdates(_this._pendingUpdate, update);
        }
      });

      return _this;
    }

    _createClass(HMRClient, [{
      key: "enable",
      value: function enable() {
        this._isEnabled = true;
        var update = this._pendingUpdate;
        this._pendingUpdate = null;

        if (update != null) {
          injectUpdate(update);
        }
      }
    }, {
      key: "disable",
      value: function disable() {
        this._isEnabled = false;
      }
    }, {
      key: "isEnabled",
      value: function isEnabled() {
        return this._isEnabled;
      }
    }, {
      key: "hasPendingUpdates",
      value: function hasPendingUpdates() {
        return this._pendingUpdate != null;
      }
    }]);

    return HMRClient;
  }(WebSocketHMRClient);

  function mergeUpdates(base, next) {
    var addedIDs = new Set();
    var deletedIDs = new Set();
    var moduleMap = new Map();
    applyUpdateLocally(base);
    applyUpdateLocally(next);

    function applyUpdateLocally(update) {
      update.deleted.forEach(function (id) {
        if (addedIDs.has(id)) {
          addedIDs.delete(id);
        } else {
          deletedIDs.add(id);
        }

        moduleMap.delete(id);
      });
      update.added.forEach(function (item) {
        var id = item.module[0];

        if (deletedIDs.has(id)) {
          deletedIDs.delete(id);
        } else {
          addedIDs.add(id);
        }

        moduleMap.set(id, item);
      });
      update.modified.forEach(function (item) {
        var id = item.module[0];
        moduleMap.set(id, item);
      });
    }

    var result = {
      isInitialUpdate: next.isInitialUpdate,
      revisionId: next.revisionId,
      added: [],
      modified: [],
      deleted: []
    };
    deletedIDs.forEach(function (id) {
      result.deleted.push(id);
    });
    moduleMap.forEach(function (item, id) {
      if (deletedIDs.has(id)) {
        return;
      }

      if (addedIDs.has(id)) {
        result.added.push(item);
      } else {
        result.modified.push(item);
      }
    });
    return result;
  }

  module.exports = HMRClient;
},166,[24,25,32,34,33,37,167,169],"node_modules/metro/src/lib/bundle-modules/HMRClient.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  "use strict";

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");

  var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");

  var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");

  var _assertThisInitialized = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/assertThisInitialized");

  var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");

  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;
  }

  var EventEmitter = _$$_REQUIRE(_dependencyMap[6], "eventemitter3");

  var WebSocketHMRClient = function (_EventEmitter) {
    _inherits(WebSocketHMRClient, _EventEmitter);

    function WebSocketHMRClient(url) {
      var _this;

      _classCallCheck(this, WebSocketHMRClient);

      _this = _possibleConstructorReturn(this, _getPrototypeOf(WebSocketHMRClient).call(this));

      _defineProperty(_assertThisInitialized(_this), "_queue", []);

      _defineProperty(_assertThisInitialized(_this), "_state", "opening");

      _this._ws = new global.WebSocket(url);

      _this._ws.onopen = function () {
        _this._state = "open";

        _this.emit("open");

        _this._flushQueue();
      };

      _this._ws.onerror = function (error) {
        _this.emit("connection-error", error);
      };

      _this._ws.onclose = function () {
        _this._state = "closed";

        _this.emit("close");
      };

      _this._ws.onmessage = function (message) {
        var data = JSON.parse(message.data);

        switch (data.type) {
          case "bundle-registered":
            _this.emit("bundle-registered");

            break;

          case "update-start":
            _this.emit("update-start", data.body);

            break;

          case "update":
            _this.emit("update", data.body);

            break;

          case "update-done":
            _this.emit("update-done");

            break;

          case "error":
            _this.emit("error", data.body);

            break;

          default:
            _this.emit("error", {
              type: "unknown-message",
              message: data
            });

        }
      };

      return _this;
    }

    _createClass(WebSocketHMRClient, [{
      key: "close",
      value: function close() {
        this._ws.close();
      }
    }, {
      key: "send",
      value: function send(message) {
        switch (this._state) {
          case "opening":
            this._queue.push(message);

            break;

          case "open":
            this._ws.send(message);

            break;

          case "closed":
            break;

          default:
            throw new Error("[WebSocketHMRClient] Unknown state: " + this._state);
        }
      }
    }, {
      key: "_flushQueue",
      value: function _flushQueue() {
        var _this2 = this;

        this._queue.forEach(function (message) {
          return _this2.send(message);
        });

        this._queue.length = 0;
      }
    }]);

    return WebSocketHMRClient;
  }(EventEmitter);

  module.exports = WebSocketHMRClient;
},167,[24,25,32,34,33,37,168],"node_modules/metro/src/lib/bundle-modules/WebSocketHMRClient.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var has = Object.prototype.hasOwnProperty,
      prefix = '~';

  function Events() {}

  if (Object.create) {
    Events.prototype = Object.create(null);
    if (!new Events().__proto__) prefix = false;
  }

  function EE(fn, context, once) {
    this.fn = fn;
    this.context = context;
    this.once = once || false;
  }

  function addListener(emitter, event, fn, context, once) {
    if (typeof fn !== 'function') {
      throw new TypeError('The listener must be a function');
    }

    var listener = new EE(fn, context || emitter, once),
        evt = prefix ? prefix + event : event;
    if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++;else if (!emitter._events[evt].fn) emitter._events[evt].push(listener);else emitter._events[evt] = [emitter._events[evt], listener];
    return emitter;
  }

  function clearEvent(emitter, evt) {
    if (--emitter._eventsCount === 0) emitter._events = new Events();else delete emitter._events[evt];
  }

  function EventEmitter() {
    this._events = new Events();
    this._eventsCount = 0;
  }

  EventEmitter.prototype.eventNames = function eventNames() {
    var names = [],
        events,
        name;
    if (this._eventsCount === 0) return names;

    for (name in events = this._events) {
      if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);
    }

    if (Object.getOwnPropertySymbols) {
      return names.concat(Object.getOwnPropertySymbols(events));
    }

    return names;
  };

  EventEmitter.prototype.listeners = function listeners(event) {
    var evt = prefix ? prefix + event : event,
        handlers = this._events[evt];
    if (!handlers) return [];
    if (handlers.fn) return [handlers.fn];

    for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) {
      ee[i] = handlers[i].fn;
    }

    return ee;
  };

  EventEmitter.prototype.listenerCount = function listenerCount(event) {
    var evt = prefix ? prefix + event : event,
        listeners = this._events[evt];
    if (!listeners) return 0;
    if (listeners.fn) return 1;
    return listeners.length;
  };

  EventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
    var evt = prefix ? prefix + event : event;
    if (!this._events[evt]) return false;
    var listeners = this._events[evt],
        len = arguments.length,
        args,
        i;

    if (listeners.fn) {
      if (listeners.once) this.removeListener(event, listeners.fn, undefined, true);

      switch (len) {
        case 1:
          return listeners.fn.call(listeners.context), true;

        case 2:
          return listeners.fn.call(listeners.context, a1), true;

        case 3:
          return listeners.fn.call(listeners.context, a1, a2), true;

        case 4:
          return listeners.fn.call(listeners.context, a1, a2, a3), true;

        case 5:
          return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;

        case 6:
          return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
      }

      for (i = 1, args = new Array(len - 1); i < len; i++) {
        args[i - 1] = arguments[i];
      }

      listeners.fn.apply(listeners.context, args);
    } else {
      var length = listeners.length,
          j;

      for (i = 0; i < length; i++) {
        if (listeners[i].once) this.removeListener(event, listeners[i].fn, undefined, true);

        switch (len) {
          case 1:
            listeners[i].fn.call(listeners[i].context);
            break;

          case 2:
            listeners[i].fn.call(listeners[i].context, a1);
            break;

          case 3:
            listeners[i].fn.call(listeners[i].context, a1, a2);
            break;

          case 4:
            listeners[i].fn.call(listeners[i].context, a1, a2, a3);
            break;

          default:
            if (!args) for (j = 1, args = new Array(len - 1); j < len; j++) {
              args[j - 1] = arguments[j];
            }
            listeners[i].fn.apply(listeners[i].context, args);
        }
      }
    }

    return true;
  };

  EventEmitter.prototype.on = function on(event, fn, context) {
    return addListener(this, event, fn, context, false);
  };

  EventEmitter.prototype.once = function once(event, fn, context) {
    return addListener(this, event, fn, context, true);
  };

  EventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {
    var evt = prefix ? prefix + event : event;
    if (!this._events[evt]) return this;

    if (!fn) {
      clearEvent(this, evt);
      return this;
    }

    var listeners = this._events[evt];

    if (listeners.fn) {
      if (listeners.fn === fn && (!once || listeners.once) && (!context || listeners.context === context)) {
        clearEvent(this, evt);
      }
    } else {
      for (var i = 0, events = [], length = listeners.length; i < length; i++) {
        if (listeners[i].fn !== fn || once && !listeners[i].once || context && listeners[i].context !== context) {
          events.push(listeners[i]);
        }
      }

      if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;else clearEvent(this, evt);
    }

    return this;
  };

  EventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {
    var evt;

    if (event) {
      evt = prefix ? prefix + event : event;
      if (this._events[evt]) clearEvent(this, evt);
    } else {
      this._events = new Events();
      this._eventsCount = 0;
    }

    return this;
  };

  EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
  EventEmitter.prototype.addListener = EventEmitter.prototype.on;
  EventEmitter.prefixed = prefix;
  EventEmitter.EventEmitter = EventEmitter;

  if ('undefined' !== typeof module) {
    module.exports = EventEmitter;
  }
},168,[],"node_modules/eventemitter3/index.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  "use strict";

  function _slicedToArray(arr, i) {
    return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest();
  }

  function _nonIterableRest() {
    throw new TypeError("Invalid attempt to destructure non-iterable instance");
  }

  function _iterableToArrayLimit(arr, i) {
    var _arr = [];
    var _n = true;
    var _d = false;
    var _e = undefined;

    try {
      for (var _i = arr[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"](), _s; !(_n = (_s = _i.next()).done); _n = true) {
        _arr.push(_s.value);

        if (i && _arr.length === i) break;
      }
    } catch (err) {
      _d = true;
      _e = err;
    } finally {
      try {
        if (!_n && _i["return"] != null) _i["return"]();
      } finally {
        if (_d) throw _e;
      }
    }

    return _arr;
  }

  function _arrayWithHoles(arr) {
    if (Array.isArray(arr)) return arr;
  }

  var inject = function inject(_ref) {
    var _ref$module = _slicedToArray(_ref.module, 2),
        id = _ref$module[0],
        code = _ref$module[1],
        sourceURL = _ref.sourceURL;

    if (global.globalEvalWithSourceUrl) {
      global.globalEvalWithSourceUrl(code, sourceURL);
    } else {
      eval(code);
    }
  };

  function injectUpdate(update) {
    update.added.forEach(inject);
    update.modified.forEach(inject);
  }

  module.exports = injectUpdate;
},169,[],"node_modules/metro/src/lib/bundle-modules/injectUpdate.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _ToastAndroid = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../Components/ToastAndroid/ToastAndroid"));

  var TOAST_SHORT_DELAY = 2000;
  var isVisible = false;
  module.exports = {
    showMessage: function showMessage(message, type) {
      if (!isVisible) {
        _ToastAndroid.default.show(message, _ToastAndroid.default.SHORT);

        isVisible = true;
        setTimeout(function () {
          isVisible = false;
        }, TOAST_SHORT_DELAY);
      }
    },
    hide: function hide() {}
  };
},170,[1,171],"node_modules/react-native/Libraries/Utilities/LoadingView.android.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _NativeToastAndroid = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./NativeToastAndroid"));

  var ToastAndroid = {
    SHORT: _NativeToastAndroid.default.getConstants().SHORT,
    LONG: _NativeToastAndroid.default.getConstants().LONG,
    TOP: _NativeToastAndroid.default.getConstants().TOP,
    BOTTOM: _NativeToastAndroid.default.getConstants().BOTTOM,
    CENTER: _NativeToastAndroid.default.getConstants().CENTER,
    show: function show(message, duration) {
      _NativeToastAndroid.default.show(message, duration);
    },
    showWithGravity: function showWithGravity(message, duration, gravity) {
      _NativeToastAndroid.default.showWithGravity(message, duration, gravity);
    },
    showWithGravityAndOffset: function showWithGravityAndOffset(message, duration, gravity, xOffset, yOffset) {
      _NativeToastAndroid.default.showWithGravityAndOffset(message, duration, gravity, xOffset, yOffset);
    }
  };
  module.exports = ToastAndroid;
},171,[1,172],"node_modules/react-native/Libraries/Components/ToastAndroid/ToastAndroid.android.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireWildcard");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[1], "../../TurboModule/TurboModuleRegistry"));

  var _default = TurboModuleRegistry.getEnforcing('ToastAndroid');

  exports.default = _default;
},172,[9,11],"node_modules/react-native/Libraries/Components/ToastAndroid/NativeToastAndroid.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var HMRClientProdShim = {
    setup: function setup() {},
    enable: function enable() {
      console.error('Fast Refresh is disabled in JavaScript bundles built in production mode. ' + 'Did you forget to run Metro?');
    },
    disable: function disable() {},
    registerBundle: function registerBundle() {},
    log: function log() {}
  };
  module.exports = HMRClientProdShim;
},173,[],"node_modules/react-native/Libraries/Utilities/HMRClientProdShim.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  function __fetchSegment(segmentId, options, callback) {
    var SegmentFetcher = _$$_REQUIRE(_dependencyMap[0], "./SegmentFetcher/NativeSegmentFetcher").default;

    SegmentFetcher.fetchSegment(segmentId, options, function (errorObject) {
      if (errorObject) {
        var error = new Error(errorObject.message);
        error.code = errorObject.code;
        callback(error);
      }

      callback(null);
    });
  }

  global.__fetchSegment = __fetchSegment;

  function __getSegment(segmentId, options, callback) {
    var SegmentFetcher = _$$_REQUIRE(_dependencyMap[0], "./SegmentFetcher/NativeSegmentFetcher").default;

    if (!SegmentFetcher.getSegment) {
      throw new Error('SegmentFetcher.getSegment must be defined');
    }

    SegmentFetcher.getSegment(segmentId, options, function (errorObject, path) {
      if (errorObject) {
        var error = new Error(errorObject.message);
        error.code = errorObject.code;
        callback(error);
      }

      callback(null, path);
    });
  }

  global.__getSegment = __getSegment;
},174,[175],"node_modules/react-native/Libraries/Core/setUpSegmentFetcher.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireWildcard");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[1], "../../TurboModule/TurboModuleRegistry"));

  var _default = TurboModuleRegistry.getEnforcing('SegmentFetcher');

  exports.default = _default;
},175,[9,11],"node_modules/react-native/Libraries/Core/SegmentFetcher/NativeSegmentFetcher.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var ReactNativeVersionCheck = _$$_REQUIRE(_dependencyMap[0], "./ReactNativeVersionCheck");

  ReactNativeVersionCheck.checkVersions();
},176,[177],"node_modules/react-native/Libraries/Core/checkNativeVersion.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _Platform = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../Utilities/Platform"));

  var ReactNativeVersion = _$$_REQUIRE(_dependencyMap[2], "./ReactNativeVersion");

  exports.checkVersions = function checkVersions() {
    var nativeVersion = _Platform.default.constants.reactNativeVersion;

    if (ReactNativeVersion.version.major !== nativeVersion.major || ReactNativeVersion.version.minor !== nativeVersion.minor) {
      console.error("React Native version mismatch.\n\nJavaScript version: " + _formatVersion(ReactNativeVersion.version) + "\n" + ("Native version: " + _formatVersion(nativeVersion) + "\n\n") + 'Make sure that you have rebuilt the native code. If the problem ' + 'persists try clearing the Watchman and packager caches with ' + '`watchman watch-del-all && react-native start --reset-cache`.');
    }
  };

  function _formatVersion(version) {
    return version.major + "." + version.minor + "." + version.patch + (version.prerelease != undefined ? "-" + version.prerelease : '');
  }
},177,[1,48,178],"node_modules/react-native/Libraries/Core/ReactNativeVersionCheck.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  exports.version = {
    major: 0,
    minor: 61,
    patch: 5,
    prerelease: null
  };
},178,[],"node_modules/react-native/Libraries/Core/ReactNativeVersion.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _Platform = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../Utilities/Platform"));

  if (__DEV__) {
    if (!global.RN$Bridgeless) {
      if (!global.__RCTProfileIsProfiling) {
        if (!window.document) {
          var AppState = _$$_REQUIRE(_dependencyMap[2], "../AppState/AppState");

          var reactDevTools = _$$_REQUIRE(_dependencyMap[3], "react-devtools-core");

          var getDevServer = _$$_REQUIRE(_dependencyMap[4], "./Devtools/getDevServer");

          var isAppActive = function isAppActive() {
            return AppState.currentState !== 'background';
          };

          var devServer = getDevServer();
          var host = devServer.bundleLoadedFromServer ? devServer.url.replace(/https?:\/\//, '').split(':')[0] : 'localhost';
          reactDevTools.connectToDevTools({
            isAppActive: isAppActive,
            host: host,
            port: window.__REACT_DEVTOOLS_PORT__,
            resolveRNStyle: _$$_REQUIRE(_dependencyMap[5], "../StyleSheet/flattenStyle")
          });
        }

        var JSInspector = _$$_REQUIRE(_dependencyMap[6], "../JSInspector/JSInspector");

        JSInspector.registerAgent(_$$_REQUIRE(_dependencyMap[7], "../JSInspector/NetworkAgent"));
      }

      var isLikelyARealBrowser = global.navigator != null && global.navigator.appName === 'Netscape';

      if (!_Platform.default.isTesting) {
        var HMRClient = _$$_REQUIRE(_dependencyMap[8], "../Utilities/HMRClient");

        if (console._isPolyfilled) {
          ['trace', 'info', 'warn', 'log', 'group', 'groupCollapsed', 'groupEnd', 'debug'].forEach(function (level) {
            var originalFunction = console[level];

            console[level] = function () {
              for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
                args[_key] = arguments[_key];
              }

              HMRClient.log(level, args);
              originalFunction.apply(console, args);
            };
          });
        } else {
          HMRClient.log('log', ["JavaScript logs will appear in your " + (isLikelyARealBrowser ? 'browser' : 'environment') + " console"]);
        }
      }

      _$$_REQUIRE(_dependencyMap[9], "./setUpReactRefresh");
    }
  }
},179,[1,48,180,183,106,85,184,185,164,187],"node_modules/react-native/Libraries/Core/setUpDeveloperTools.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf3 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits"));

  var _NativeAppState = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "./NativeAppState"));

  var EventEmitter = _$$_REQUIRE(_dependencyMap[7], "../vendor/emitter/EventEmitter");

  var NativeEventEmitter = _$$_REQUIRE(_dependencyMap[8], "../EventEmitter/NativeEventEmitter");

  var logError = _$$_REQUIRE(_dependencyMap[9], "../Utilities/logError");

  var invariant = _$$_REQUIRE(_dependencyMap[10], "invariant");

  var AppState = function (_NativeEventEmitter) {
    (0, _inherits2.default)(AppState, _NativeEventEmitter);

    function AppState() {
      var _this;

      (0, _classCallCheck2.default)(this, AppState);
      _this = (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf3.default)(AppState).call(this, _NativeAppState.default));
      _this._supportedEvents = ['change', 'memoryWarning', 'blur', 'focus'];
      _this.isAvailable = true;
      _this._eventHandlers = _this._supportedEvents.reduce(function (handlers, key) {
        handlers[key] = new Map();
        return handlers;
      }, {});
      _this.currentState = _NativeAppState.default.getConstants().initialAppState;
      var eventUpdated = false;

      _this.addListener('appStateDidChange', function (appStateData) {
        eventUpdated = true;
        _this.currentState = appStateData.app_state;
      });

      _NativeAppState.default.getCurrentAppState(function (appStateData) {
        if (!eventUpdated && _this.currentState !== appStateData.app_state) {
          _this.currentState = appStateData.app_state;

          _this.emit('appStateDidChange', appStateData);
        }
      }, logError);

      return _this;
    }

    (0, _createClass2.default)(AppState, [{
      key: "addEventListener",
      value: function addEventListener(type, handler) {
        invariant(this._supportedEvents.indexOf(type) !== -1, 'Trying to subscribe to unknown event: "%s"', type);

        switch (type) {
          case 'change':
            {
              this._eventHandlers[type].set(handler, this.addListener('appStateDidChange', function (appStateData) {
                handler(appStateData.app_state);
              }));

              break;
            }

          case 'memoryWarning':
            {
              this._eventHandlers[type].set(handler, this.addListener('memoryWarning', handler));

              break;
            }

          case 'blur':
          case 'focus':
            {
              this._eventHandlers[type].set(handler, this.addListener('appStateFocusChange', function (hasFocus) {
                if (type === 'blur' && !hasFocus) {
                  handler();
                }

                if (type === 'focus' && hasFocus) {
                  handler();
                }
              }));
            }
        }
      }
    }, {
      key: "removeEventListener",
      value: function removeEventListener(type, handler) {
        invariant(this._supportedEvents.indexOf(type) !== -1, 'Trying to remove listener for unknown event: "%s"', type);

        if (!this._eventHandlers[type].has(handler)) {
          return;
        }

        this._eventHandlers[type].get(handler).remove();

        this._eventHandlers[type].delete(handler);
      }
    }]);
    return AppState;
  }(NativeEventEmitter);

  function throwMissingNativeModule() {
    invariant(false, 'Cannot use AppState module when native RCTAppState is not included in the build.\n' + 'Either include it, or check AppState.isAvailable before calling any methods.');
  }

  var MissingNativeAppStateShim = function (_EventEmitter) {
    (0, _inherits2.default)(MissingNativeAppStateShim, _EventEmitter);

    function MissingNativeAppStateShim() {
      var _getPrototypeOf2;

      var _this2;

      (0, _classCallCheck2.default)(this, MissingNativeAppStateShim);

      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
        args[_key] = arguments[_key];
      }

      _this2 = (0, _possibleConstructorReturn2.default)(this, (_getPrototypeOf2 = (0, _getPrototypeOf3.default)(MissingNativeAppStateShim)).call.apply(_getPrototypeOf2, [this].concat(args)));
      _this2.isAvailable = false;
      _this2.currentState = null;
      return _this2;
    }

    (0, _createClass2.default)(MissingNativeAppStateShim, [{
      key: "addEventListener",
      value: function addEventListener() {
        throwMissingNativeModule();
      }
    }, {
      key: "removeEventListener",
      value: function removeEventListener() {
        throwMissingNativeModule();
      }
    }, {
      key: "addListener",
      value: function addListener() {
        throwMissingNativeModule();
      }
    }, {
      key: "removeAllListeners",
      value: function removeAllListeners() {
        throwMissingNativeModule();
      }
    }, {
      key: "removeSubscription",
      value: function removeSubscription() {
        throwMissingNativeModule();
      }
    }]);
    return MissingNativeAppStateShim;
  }(EventEmitter);

  if (_NativeAppState.default) {
    AppState = new AppState();
  } else {
    AppState = new MissingNativeAppStateShim();
  }

  module.exports = AppState;
},180,[1,24,25,32,34,37,181,39,134,182,3],"node_modules/react-native/Libraries/AppState/AppState.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireWildcard");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[1], "../TurboModule/TurboModuleRegistry"));

  var _default = TurboModuleRegistry.getEnforcing('AppState');

  exports.default = _default;
},181,[9,11],"node_modules/react-native/Libraries/AppState/NativeAppState.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var logError = function logError() {
    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
      args[_key] = arguments[_key];
    }

    if (args.length === 1 && args[0] instanceof Error) {
      var err = args[0];
      console.error('Error: "' + err.message + '".  Stack:\n' + err.stack);
    } else {
      console.error.apply(console, args);
    }
  };

  module.exports = logError;
},182,[],"node_modules/react-native/Libraries/Utilities/logError.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");

  !function (e, t) {
    "object" == typeof exports && "object" == typeof module ? module.exports = t() : "function" == typeof define && define.amd ? define([], t) : "object" == typeof exports ? exports.ReactDevToolsBackend = t() : e.ReactDevToolsBackend = t();
  }(window, function () {
    return function (e) {
      var t = {};

      function n(r) {
        if (t[r]) return t[r].exports;
        var o = t[r] = {
          i: r,
          l: !1,
          exports: {}
        };
        return e[r].call(o.exports, o, o.exports, n), o.l = !0, o.exports;
      }

      return n.m = e, n.c = t, n.d = function (e, t, r) {
        n.o(e, t) || Object.defineProperty(e, t, {
          enumerable: !0,
          get: r
        });
      }, n.r = function (e) {
        "undefined" != typeof Symbol && (typeof Symbol === "function" ? Symbol.toStringTag : "@@toStringTag") && Object.defineProperty(e, typeof Symbol === "function" ? Symbol.toStringTag : "@@toStringTag", {
          value: "Module"
        }), Object.defineProperty(e, "__esModule", {
          value: !0
        });
      }, n.t = function (e, t) {
        if (1 & t && (e = n(e)), 8 & t) return e;
        if (4 & t && "object" == typeof e && e && e.__esModule) return e;
        var r = Object.create(null);
        if (n.r(r), Object.defineProperty(r, "default", {
          enumerable: !0,
          value: e
        }), 2 & t && "string" != typeof e) for (var o in e) {
          n.d(r, o, function (t) {
            return e[t];
          }.bind(null, o));
        }
        return r;
      }, n.n = function (e) {
        var t = e && e.__esModule ? function () {
          return e.default;
        } : function () {
          return e;
        };
        return n.d(t, "a", t), t;
      }, n.o = function (e, t) {
        return Object.prototype.hasOwnProperty.call(e, t);
      }, n.p = "", n(n.s = 8);
    }([function (e, t, n) {
      var r, o, i;
      !function (a, s) {
        "use strict";

        o = [n(54)], void 0 === (i = "function" == typeof (r = function r(e) {
          var t = /(^|@)\S+\:\d+/,
              n = /^\s*at .*(\S+\:\d+|\(native\))/m,
              r = /^(eval@)?(\[native code\])?$/;
          return {
            parse: function parse(e) {
              if (void 0 !== e.stacktrace || void 0 !== e["opera#sourceloc"]) return this.parseOpera(e);
              if (e.stack && e.stack.match(n)) return this.parseV8OrIE(e);
              if (e.stack) return this.parseFFOrSafari(e);
              throw new Error("Cannot parse given Error object");
            },
            extractLocation: function extractLocation(e) {
              if (-1 === e.indexOf(":")) return [e];
              var t = /(.+?)(?:\:(\d+))?(?:\:(\d+))?$/.exec(e.replace(/[\(\)]/g, ""));
              return [t[1], t[2] || void 0, t[3] || void 0];
            },
            parseV8OrIE: function parseV8OrIE(t) {
              var r = t.stack.split("\n").filter(function (e) {
                return !!e.match(n);
              }, this);
              return r.map(function (t) {
                t.indexOf("(eval ") > -1 && (t = t.replace(/eval code/g, "eval").replace(/(\(eval at [^\()]*)|(\)\,.*$)/g, ""));
                var n = t.replace(/^\s+/, "").replace(/\(eval code/g, "(").split(/\s+/).slice(1),
                    r = this.extractLocation(n.pop()),
                    o = n.join(" ") || void 0,
                    i = ["eval", "<anonymous>"].indexOf(r[0]) > -1 ? void 0 : r[0];
                return new e({
                  functionName: o,
                  fileName: i,
                  lineNumber: r[1],
                  columnNumber: r[2],
                  source: t
                });
              }, this);
            },
            parseFFOrSafari: function parseFFOrSafari(t) {
              var n = t.stack.split("\n").filter(function (e) {
                return !e.match(r);
              }, this);
              return n.map(function (t) {
                if (t.indexOf(" > eval") > -1 && (t = t.replace(/ line (\d+)(?: > eval line \d+)* > eval\:\d+\:\d+/g, ":$1")), -1 === t.indexOf("@") && -1 === t.indexOf(":")) return new e({
                  functionName: t
                });
                var n = /((.*".+"[^@]*)?[^@]*)(?:@)/,
                    r = t.match(n),
                    o = r && r[1] ? r[1] : void 0,
                    i = this.extractLocation(t.replace(n, ""));
                return new e({
                  functionName: o,
                  fileName: i[0],
                  lineNumber: i[1],
                  columnNumber: i[2],
                  source: t
                });
              }, this);
            },
            parseOpera: function parseOpera(e) {
              return !e.stacktrace || e.message.indexOf("\n") > -1 && e.message.split("\n").length > e.stacktrace.split("\n").length ? this.parseOpera9(e) : e.stack ? this.parseOpera11(e) : this.parseOpera10(e);
            },
            parseOpera9: function parseOpera9(t) {
              for (var n = /Line (\d+).*script (?:in )?(\S+)/i, r = t.message.split("\n"), o = [], i = 2, a = r.length; i < a; i += 2) {
                var s = n.exec(r[i]);
                s && o.push(new e({
                  fileName: s[2],
                  lineNumber: s[1],
                  source: r[i]
                }));
              }

              return o;
            },
            parseOpera10: function parseOpera10(t) {
              for (var n = /Line (\d+).*script (?:in )?(\S+)(?:: In function (\S+))?$/i, r = t.stacktrace.split("\n"), o = [], i = 0, a = r.length; i < a; i += 2) {
                var s = n.exec(r[i]);
                s && o.push(new e({
                  functionName: s[3] || void 0,
                  fileName: s[2],
                  lineNumber: s[1],
                  source: r[i]
                }));
              }

              return o;
            },
            parseOpera11: function parseOpera11(n) {
              var r = n.stack.split("\n").filter(function (e) {
                return !!e.match(t) && !e.match(/^Error created at/);
              }, this);
              return r.map(function (t) {
                var n,
                    r = t.split("@"),
                    o = this.extractLocation(r.pop()),
                    i = r.shift() || "",
                    a = i.replace(/<anonymous function(: (\w+))?>/, "$2").replace(/\([^\)]*\)/g, "") || void 0;
                i.match(/\(([^\)]*)\)/) && (n = i.replace(/^[^\(]+\(([^\)]*)\)$/, "$1"));
                var s = void 0 === n || "[arguments not available]" === n ? void 0 : n.split(",");
                return new e({
                  functionName: a,
                  args: s,
                  fileName: o[0],
                  lineNumber: o[1],
                  columnNumber: o[2],
                  source: t
                });
              }, this);
            }
          };
        }) ? r.apply(t, o) : r) || (e.exports = i);
      }();
    }, function (e, t, n) {
      "use strict";

      var r = Object.prototype.hasOwnProperty,
          o = Object.prototype.propertyIsEnumerable;

      e.exports = Object.assign || function (e, t) {
        for (var n, i, a = function (e) {
          if (null == e) throw new TypeError("Object.assign cannot be called with null or undefined");
          return Object(e);
        }(e), s = 1; s < arguments.length; s++) {
          for (var u in n = Object(arguments[s])) {
            r.call(n, u) && (a[u] = n[u]);
          }

          if (Object.getOwnPropertySymbols) {
            i = Object.getOwnPropertySymbols(n);

            for (var c = 0; c < i.length; c++) {
              o.call(n, i[c]) && (a[i[c]] = n[i[c]]);
            }
          }
        }

        return a;
      };
    }, function (e, t, n) {
      "use strict";

      function r(e, t, n) {
        return t in e ? Object.defineProperty(e, t, {
          value: n,
          enumerable: !0,
          configurable: !0,
          writable: !0
        }) : e[t] = n, e;
      }

      function o(e, t, n, i) {
        if (n >= t.length) return i;
        var a = t[n],
            s = Array.isArray(e) ? e.slice() : function (e) {
          for (var t = 1; t < arguments.length; t++) {
            var n = null != arguments[t] ? arguments[t] : {},
                o = Object.keys(n);
            "function" == typeof Object.getOwnPropertySymbols && (o = o.concat(Object.getOwnPropertySymbols(n).filter(function (e) {
              return Object.getOwnPropertyDescriptor(n, e).enumerable;
            }))), o.forEach(function (t) {
              r(e, t, n[t]);
            });
          }

          return e;
        }({}, e);
        return s[a] = o(e[a], t, n + 1, i), s;
      }

      e.exports = function (e, t, n) {
        return o(e, t, 0, n);
      };
    }, function (e, t) {
      function n(e) {
        return function (e) {
          if (Array.isArray(e)) {
            for (var t = 0, n = new Array(e.length); t < e.length; t++) {
              n[t] = e[t];
            }

            return n;
          }
        }(e) || function (e) {
          if ((typeof Symbol === "function" ? Symbol.iterator : "@@iterator") in Object(e) || "[object Arguments]" === Object.prototype.toString.call(e)) return Array.from(e);
        }(e) || function () {
          throw new TypeError("Invalid attempt to spread non-iterable instance");
        }();
      }

      var r = Object.prototype.hasOwnProperty;

      e.exports = function (e, t) {
        return t.reduce(function (e, t) {
          if (e) {
            if (r.call(e, t)) return e[t];
            if ("function" == typeof e[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"]) return n(e)[t];
          }

          return null;
        }, e);
      };
    }, function (e, t, n) {
      "use strict";

      var r = n(14);
      e.exports = {
        name: r("name"),
        type: r("type"),
        inspected: r("inspected"),
        meta: r("meta"),
        proto: r("proto")
      };
    }, function (e, t, n) {
      "use strict";

      var r = /^(.*) \[from (.*)\]$/,
          o = new WeakMap();

      e.exports = function (e) {
        var t,
            n = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : "Unknown",
            i = o.get(e);
        if (null != i) return i;
        "string" == typeof e.displayName && (t = e.displayName), t || (t = e.name || n);
        var a = t.match(r);

        if (a) {
          var s = a[1],
              u = a[2];
          s && u && (u === s || u.startsWith(s + ".")) && (t = s);
        }

        return o.set(e, t), t;
      };
    }, function (e, t) {
      var n,
          r,
          o = e.exports = {};

      function i() {
        throw new Error("setTimeout has not been defined");
      }

      function a() {
        throw new Error("clearTimeout has not been defined");
      }

      function s(e) {
        if (n === setTimeout) return setTimeout(e, 0);
        if ((n === i || !n) && setTimeout) return n = setTimeout, setTimeout(e, 0);

        try {
          return n(e, 0);
        } catch (t) {
          try {
            return n.call(null, e, 0);
          } catch (t) {
            return n.call(this, e, 0);
          }
        }
      }

      !function () {
        try {
          n = "function" == typeof setTimeout ? setTimeout : i;
        } catch (e) {
          n = i;
        }

        try {
          r = "function" == typeof clearTimeout ? clearTimeout : a;
        } catch (e) {
          r = a;
        }
      }();
      var u,
          c = [],
          l = !1,
          f = -1;

      function p() {
        l && u && (l = !1, u.length ? c = u.concat(c) : f = -1, c.length && d());
      }

      function d() {
        if (!l) {
          var e = s(p);
          l = !0;

          for (var t = c.length; t;) {
            for (u = c, c = []; ++f < t;) {
              u && u[f].run();
            }

            f = -1, t = c.length;
          }

          u = null, l = !1, function (e) {
            if (r === clearTimeout) return clearTimeout(e);
            if ((r === a || !r) && clearTimeout) return r = clearTimeout, clearTimeout(e);

            try {
              r(e);
            } catch (t) {
              try {
                return r.call(null, e);
              } catch (t) {
                return r.call(this, e);
              }
            }
          }(e);
        }
      }

      function h(e, t) {
        this.fun = e, this.array = t;
      }

      function m() {}

      o.nextTick = function (e) {
        var t = new Array(arguments.length - 1);
        if (arguments.length > 1) for (var n = 1; n < arguments.length; n++) {
          t[n - 1] = arguments[n];
        }
        c.push(new h(e, t)), 1 !== c.length || l || s(d);
      }, h.prototype.run = function () {
        this.fun.apply(null, this.array);
      }, o.title = "browser", o.browser = !0, o.env = {}, o.argv = [], o.version = "", o.versions = {}, o.on = m, o.addListener = m, o.once = m, o.off = m, o.removeListener = m, o.removeAllListeners = m, o.emit = m, o.prependListener = m, o.prependOnceListener = m, o.listeners = function (e) {
        return [];
      }, o.binding = function (e) {
        throw new Error("process.binding is not supported");
      }, o.cwd = function () {
        return "/";
      }, o.chdir = function (e) {
        throw new Error("process.chdir is not supported");
      }, o.umask = function () {
        return 0;
      };
    }, function (e, t) {
      function n(e) {
        return (n = "function" == typeof Symbol && "symbol" == typeof (typeof Symbol === "function" ? Symbol.iterator : "@@iterator") ? function (e) {
          return typeof e;
        } : function (e) {
          return e && "function" == typeof Symbol && e.constructor === Symbol && e !== (typeof Symbol === "function" ? Symbol.prototype : "@@prototype") ? "symbol" : typeof e;
        })(e);
      }

      var r;

      r = function () {
        return this;
      }();

      try {
        r = r || Function("return this")() || (0, eval)("this");
      } catch (e) {
        "object" === ("undefined" == typeof window ? "undefined" : n(window)) && (r = window);
      }

      e.exports = r;
    }, function (e, t, n) {
      "use strict";

      var r = n(9),
          o = n(13),
          i = n(37),
          a = n(38),
          s = n(39),
          u = n(48),
          c = n(52),
          l = n(61).default,
          f = n(55);
      a(window), window.document && window.__REACT_DEVTOOLS_GLOBAL_HOOK__.on("react-devtools", function (e) {
        n(56)(e);
      }), e.exports = {
        connectToDevTools: function e(t) {
          var n = t || {},
              a = n.host,
              p = void 0 === a ? "localhost" : a,
              d = n.port,
              h = void 0 === d ? 8097 : d,
              m = n.websocket,
              y = n.resolveRNStyle,
              v = void 0 === y ? null : y,
              g = n.isAppActive;

          function b() {
            setTimeout(function () {
              return e(t);
            }, 2e3);
          }

          if ((void 0 === g ? function () {
            return !0;
          } : g)()) {
            var _ = [],
                w = [],
                S = "ws://" + p + ":" + h,
                E = m || new window.WebSocket(S);
            E.onclose = function () {
              O || (O = !0, b(), w.forEach(function (e) {
                return e();
              }));
            }, E.onerror = function () {
              O || (O = !0, w.forEach(function (e) {
                return e();
              }));
            }, E.onmessage = function (e) {
              var t;

              try {
                u("string" == typeof e.data), t = JSON.parse(e.data);
              } catch (t) {
                return void console.error("failed to parse json: " + String(e.data));
              }

              _.forEach(function (e) {
                try {
                  e(t);
                } catch (e) {
                  throw console.log(t), e;
                }
              });
            }, E.onopen = function () {
              !function (e, t) {
                e.onClose(function () {
                  a && a.emit("shutdown"), window.__REACT_DEVTOOLS_GLOBAL_HOOK__.emit("shutdown"), n = null, a = null, console.log("closing devtools");
                });
                var n = new o(e),
                    a = new r(window, {
                  rnStyle: !!t,
                  rnStyleMeasure: !!t
                });
                a.addBridge(n), t && c(n, a, t), f(n, a, window.__REACT_DEVTOOLS_GLOBAL_HOOK__), l(n, a);
                var u = setTimeout(function () {
                  console.warn("react-devtools agent got no connection");
                }, 2e4);
                a.once("connected", function () {
                  a && (s(window.__REACT_DEVTOOLS_GLOBAL_HOOK__, a), clearTimeout(u));
                }), i.init(a);
              }({
                listen: function listen(e) {
                  _.push(e);
                },
                onClose: function onClose(e) {
                  w.push(e);
                },
                send: function send(e) {
                  E.send(JSON.stringify(e));
                }
              }, v);
            };
            var O = !1;
          } else b();
        }
      };
    }, function (e, t, n) {
      "use strict";

      function r(e) {
        return (r = "function" == typeof Symbol && "symbol" == typeof (typeof Symbol === "function" ? Symbol.iterator : "@@iterator") ? function (e) {
          return typeof e;
        } : function (e) {
          return e && "function" == typeof Symbol && e.constructor === Symbol && e !== (typeof Symbol === "function" ? Symbol.prototype : "@@prototype") ? "symbol" : typeof e;
        })(e);
      }

      function o(e, t) {
        for (var n = 0; n < t.length; n++) {
          var r = t[n];
          r.enumerable = r.enumerable || !1, r.configurable = !0, "value" in r && (r.writable = !0), Object.defineProperty(e, r.key, r);
        }
      }

      function i(e) {
        return (i = Object.setPrototypeOf ? Object.getPrototypeOf : function (e) {
          return e.__proto__ || Object.getPrototypeOf(e);
        })(e);
      }

      function a(e, t) {
        return (a = Object.setPrototypeOf || function (e, t) {
          return e.__proto__ = t, e;
        })(e, t);
      }

      function s(e) {
        if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
        return e;
      }

      var u = n(10).EventEmitter,
          c = n(1),
          l = n(11).default,
          f = n(12),
          p = n(3),
          d = function (e) {
        function t(e, n) {
          var o, a, u, l;
          !function (e, t) {
            if (!(e instanceof t)) throw new TypeError("Cannot call a class as a function");
          }(this, t), a = this, u = i(t).call(this), (o = !u || "object" !== r(u) && "function" != typeof u ? s(a) : u).global = e, o.internalInstancesById = new Map(), o.idsByInternalInstances = new WeakMap(), o.renderers = new Map(), o.elementData = new Map(), o.roots = new Set(), o.reactInternals = {}, o.on("selected", function (e) {
            var t = o.elementData.get(e);
            t && t.publicInstance && o.global.$r === l && (o.global.$r = t.publicInstance, l = t.publicInstance);
          }), o._prevSelected = null, o._scrollUpdate = !1;
          var f = window.document && "function" == typeof window.document.createElement;
          return o.capabilities = c({
            scroll: f && "function" == typeof window.document.body.scrollIntoView,
            dom: f,
            editTextContent: !1
          }, n), f && (o._updateScroll = o._updateScroll.bind(s(s(o))), window.addEventListener("scroll", o._onScroll.bind(s(s(o))), !0), window.addEventListener("click", o._onClick.bind(s(s(o))), !0), window.addEventListener("mouseover", o._onMouseOver.bind(s(s(o))), !0), window.addEventListener("resize", o._onResize.bind(s(s(o))), !0)), o;
        }

        var n, d, h;
        return function (e, t) {
          if ("function" != typeof t && null !== t) throw new TypeError("Super expression must either be null or a function");
          e.prototype = Object.create(t && t.prototype, {
            constructor: {
              value: e,
              writable: !0,
              configurable: !0
            }
          }), t && a(e, t);
        }(t, u), n = t, (d = [{
          key: "sub",
          value: function value(e, t) {
            var n = this;
            return this.on(e, t), function () {
              n.removeListener(e, t);
            };
          }
        }, {
          key: "setReactInternals",
          value: function value(e, t) {
            this.reactInternals[e] = t;
          }
        }, {
          key: "addBridge",
          value: function value(e) {
            var t = this;
            e.on("requestCapabilities", function () {
              e.send("capabilities", t.capabilities), t.emit("connected");
            }), e.on("setState", this._setState.bind(this)), e.on("setProps", this._setProps.bind(this)), e.on("setContext", this._setContext.bind(this)), e.on("makeGlobal", this._makeGlobal.bind(this)), e.on("highlight", function (e) {
              return t.highlight(e);
            }), e.on("highlightMany", function (e) {
              return t.highlightMany(e);
            }), e.on("hideHighlight", function () {
              return t.emit("hideHighlight");
            }), e.on("startInspecting", function () {
              return t.emit("startInspecting");
            }), e.on("stopInspecting", function () {
              return t.emit("stopInspecting");
            }), e.on("selected", function (e) {
              return t.emit("selected", e);
            }), e.on("isRecording", function (e) {
              return t.emit("isRecording", e);
            }), e.on("setInspectEnabled", function (e) {
              t._inspectEnabled = e, t.emit("stopInspecting");
            }), e.on("shutdown", function () {
              return t.emit("shutdown");
            }), e.on("changeTextContent", function (e) {
              var n = e.id,
                  r = e.text,
                  o = t.getNodeForID(n);
              o && (o.textContent = r);
            }), e.on("putSelectedNode", function (e) {
              window.__REACT_DEVTOOLS_GLOBAL_HOOK__.$node = t.getNodeForID(e);
            }), e.on("putSelectedInstance", function (e) {
              var n = t.elementData.get(e);
              window.__REACT_DEVTOOLS_GLOBAL_HOOK__.$type = n ? n.type : null, n && n.publicInstance ? window.__REACT_DEVTOOLS_GLOBAL_HOOK__.$inst = n.publicInstance : window.__REACT_DEVTOOLS_GLOBAL_HOOK__.$inst = null;
            }), e.on("checkSelection", function () {
              var e = window.__REACT_DEVTOOLS_GLOBAL_HOOK__.$0;
              e !== t._prevSelected && (t._prevSelected = e, e !== window.__REACT_DEVTOOLS_GLOBAL_HOOK__.$node && t.selectFromDOMNode(e, !0));
            }), e.on("scrollToNode", function (e) {
              return t.scrollToNode(e);
            }), e.on("traceupdatesstatechange", function (e) {
              return t.emit("traceupdatesstatechange", e);
            }), e.on("colorizerchange", function (e) {
              return t.emit("colorizerchange", e);
            }), this.on("root", function (t) {
              return e.send("root", t);
            }), this.on("mount", function (t) {
              return e.send("mount", t);
            }), this.on("update", function (t) {
              return e.send("update", t);
            }), this.on("updateProfileTimes", function (t) {
              return e.send("updateProfileTimes", t);
            }), this.on("unmount", function (t) {
              e.send("unmount", t), e.forget(t);
            }), this.on("setSelection", function (t) {
              return e.send("select", t);
            }), this.on("setInspectEnabled", function (t) {
              return e.send("setInspectEnabled", t);
            }), this.on("isRecording", function (t) {
              return e.send("isRecording", t);
            }), this.on("storeSnapshot", function (t) {
              return e.send("storeSnapshot", t);
            }), this.on("clearSnapshots", function () {
              return e.send("clearSnapshots");
            });
          }
        }, {
          key: "scrollToNode",
          value: function value(e) {
            var t = this.getNodeForID(e);

            if (t) {
              var n = t.nodeType === Node.ELEMENT_NODE ? t : t.parentElement;
              n ? ("function" == typeof n.scrollIntoViewIfNeeded ? n.scrollIntoViewIfNeeded() : "function" == typeof n.scrollIntoView && n.scrollIntoView(), this.highlight(e)) : console.warn("unable to get the domElement for scrolling");
            } else console.warn("unable to get the node for scrolling");
          }
        }, {
          key: "highlight",
          value: function value(e) {
            var t = this.elementData.get(e),
                n = this.getNodeForID(e);
            t && n && this.emit("highlight", {
              node: n,
              name: t.name,
              props: t.props
            });
          }
        }, {
          key: "highlightMany",
          value: function value(e) {
            var t = this,
                n = [];
            e.forEach(function (e) {
              var r = t.getNodeForID(e);
              r && n.push(r);
            }), n.length && this.emit("highlightMany", n);
          }
        }, {
          key: "getNodeForID",
          value: function value(e) {
            var t = this.internalInstancesById.get(e);
            if (!t) return null;
            var n = this.renderers.get(e);
            return n && this.reactInternals[n].getNativeFromReactElement ? this.reactInternals[n].getNativeFromReactElement(t) : null;
          }
        }, {
          key: "selectFromDOMNode",
          value: function value(e, t) {
            var n = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : 0,
                r = this.getIDForNode(e);
            r && this.emit("setSelection", {
              id: r,
              quiet: t,
              offsetFromLeaf: n
            });
          }
        }, {
          key: "selectFromReactInstance",
          value: function value(e, t) {
            var n = this.getId(e);
            n ? this.emit("setSelection", {
              id: n,
              quiet: t
            }) : console.log("no instance id", e);
          }
        }, {
          key: "getIDForNode",
          value: function value(e) {
            if (!this.reactInternals) return null;
            var t;

            for (var n in this.reactInternals) {
              try {
                t = this.reactInternals[n].getReactElementFromNative(e);
              } catch (e) {}

              if (t) return this.getId(t);
            }

            return null;
          }
        }, {
          key: "_setProps",
          value: function value(e) {
            var t = e.id,
                n = e.path,
                r = e.value,
                o = this.elementData.get(t);
            o && o.updater && "function" == typeof o.updater.setInProps ? o.updater.setInProps(n, r) : console.warn("trying to set props on a component that doesn't support it");
          }
        }, {
          key: "_setState",
          value: function value(e) {
            var t = e.id,
                n = e.path,
                r = e.value,
                o = this.elementData.get(t);
            o && o.updater && "function" == typeof o.updater.setInState ? o.updater.setInState(n, r) : console.warn("trying to set state on a component that doesn't support it");
          }
        }, {
          key: "_setContext",
          value: function value(e) {
            var t = e.id,
                n = e.path,
                r = e.value,
                o = this.elementData.get(t);
            o && o.updater && "function" == typeof o.updater.setInContext ? o.updater.setInContext(n, r) : console.warn("trying to set context on a component that doesn't support it");
          }
        }, {
          key: "_makeGlobal",
          value: function value(e) {
            var t,
                n = e.id,
                r = e.path,
                o = this.elementData.get(n);
            o && (t = "instance" === r ? o.publicInstance : p(o, r), this.global.$tmp = t, console.log("$tmp =", t));
          }
        }, {
          key: "getId",
          value: function value(e) {
            return "object" === r(e) && e ? (this.idsByInternalInstances.has(e) || (this.idsByInternalInstances.set(e, f()), this.internalInstancesById.set(l(this.idsByInternalInstances.get(e)), e)), l(this.idsByInternalInstances.get(e))) : e;
          }
        }, {
          key: "addRoot",
          value: function value(e, t) {
            var n = this.getId(t);
            this.roots.add(n), this.emit("root", n);
          }
        }, {
          key: "rootCommitted",
          value: function value(e, t, n) {
            var r = this.getId(t);
            this.emit("rootCommitted", r, t, n);
          }
        }, {
          key: "onMounted",
          value: function value(e, t, n) {
            var r = this,
                o = this.getId(t);
            this.renderers.set(o, e), this.elementData.set(o, n);
            var i = c({}, n);
            i.children && i.children.map && (i.children = i.children.map(function (e) {
              return r.getId(e);
            })), i.id = o, i.canUpdate = i.updater && i.updater.canUpdate, delete i.type, delete i.updater, this.emit("mount", i);
          }
        }, {
          key: "onUpdated",
          value: function value(e, t) {
            var n = this,
                r = this.getId(e);
            this.elementData.set(r, t);
            var o = c({}, t);
            o.children && o.children.map && (o.children = o.children.map(function (e) {
              return n.getId(e);
            })), o.id = r, o.canUpdate = o.updater && o.updater.canUpdate, delete o.type, delete o.updater, this.emit("update", o);
          }
        }, {
          key: "onUpdatedProfileTimes",
          value: function value(e, t) {
            var n = this,
                r = this.getId(e);
            this.elementData.set(r, t);
            var o = c({}, t);
            o.children && o.children.map && (o.children = o.children.map(function (e) {
              return n.getId(e);
            })), o.id = r, o.canUpdate = o.updater && o.updater.canUpdate, delete o.type, delete o.updater, this.emit("updateProfileTimes", o);
          }
        }, {
          key: "onUnmounted",
          value: function value(e) {
            var t = this.getId(e);
            this.elementData.delete(t), this.roots.has(t) && (this.roots.delete(t), this.emit("rootUnmounted", t)), this.renderers.delete(t), this.emit("unmount", t), this.idsByInternalInstances.delete(e);
          }
        }, {
          key: "_onScroll",
          value: function value() {
            this._scrollUpdate || (this._scrollUpdate = !0, window.requestAnimationFrame(this._updateScroll));
          }
        }, {
          key: "_updateScroll",
          value: function value() {
            this.emit("refreshMultiOverlay"), this.emit("stopInspecting"), this._scrollUpdate = !1;
          }
        }, {
          key: "_onClick",
          value: function value(e) {
            if (this._inspectEnabled) {
              var t = this.getIDForNode(e.target);
              t && (e.stopPropagation(), e.preventDefault(), this.emit("setSelection", {
                id: t
              }), this.emit("setInspectEnabled", !1));
            }
          }
        }, {
          key: "_onMouseOver",
          value: function value(e) {
            if (this._inspectEnabled) {
              var t = this.getIDForNode(e.target);
              if (!t) return;
              this.highlight(t);
            }
          }
        }, {
          key: "_onResize",
          value: function value(e) {
            this.emit("stopInspecting");
          }
        }]) && o(n.prototype, d), h && o(n, h), t;
      }();

      e.exports = d;
    }, function (e, t) {
      function n(e) {
        return (n = "function" == typeof Symbol && "symbol" == typeof (typeof Symbol === "function" ? Symbol.iterator : "@@iterator") ? function (e) {
          return typeof e;
        } : function (e) {
          return e && "function" == typeof Symbol && e.constructor === Symbol && e !== (typeof Symbol === "function" ? Symbol.prototype : "@@prototype") ? "symbol" : typeof e;
        })(e);
      }

      function r() {
        this._events = this._events || {}, this._maxListeners = this._maxListeners || void 0;
      }

      function o(e) {
        return "function" == typeof e;
      }

      function i(e) {
        return "object" === n(e) && null !== e;
      }

      function a(e) {
        return void 0 === e;
      }

      e.exports = r, r.EventEmitter = r, r.prototype._events = void 0, r.prototype._maxListeners = void 0, r.defaultMaxListeners = 10, r.prototype.setMaxListeners = function (e) {
        if ("number" != typeof e || e < 0 || isNaN(e)) throw TypeError("n must be a positive number");
        return this._maxListeners = e, this;
      }, r.prototype.emit = function (e) {
        var t, n, r, s, u, c;

        if (this._events || (this._events = {}), "error" === e && (!this._events.error || i(this._events.error) && !this._events.error.length)) {
          if ((t = arguments[1]) instanceof Error) throw t;
          var l = new Error('Uncaught, unspecified "error" event. (' + t + ")");
          throw l.context = t, l;
        }

        if (a(n = this._events[e])) return !1;
        if (o(n)) switch (arguments.length) {
          case 1:
            n.call(this);
            break;

          case 2:
            n.call(this, arguments[1]);
            break;

          case 3:
            n.call(this, arguments[1], arguments[2]);
            break;

          default:
            s = Array.prototype.slice.call(arguments, 1), n.apply(this, s);
        } else if (i(n)) for (s = Array.prototype.slice.call(arguments, 1), r = (c = n.slice()).length, u = 0; u < r; u++) {
          c[u].apply(this, s);
        }
        return !0;
      }, r.prototype.addListener = function (e, t) {
        var n;
        if (!o(t)) throw TypeError("listener must be a function");
        return this._events || (this._events = {}), this._events.newListener && this.emit("newListener", e, o(t.listener) ? t.listener : t), this._events[e] ? i(this._events[e]) ? this._events[e].push(t) : this._events[e] = [this._events[e], t] : this._events[e] = t, i(this._events[e]) && !this._events[e].warned && (n = a(this._maxListeners) ? r.defaultMaxListeners : this._maxListeners) && n > 0 && this._events[e].length > n && (this._events[e].warned = !0, console.error("(node) warning: possible EventEmitter memory leak detected. %d listeners added. Use emitter.setMaxListeners() to increase limit.", this._events[e].length), "function" == typeof console.trace && console.trace()), this;
      }, r.prototype.on = r.prototype.addListener, r.prototype.once = function (e, t) {
        if (!o(t)) throw TypeError("listener must be a function");
        var n = !1;

        function r() {
          this.removeListener(e, r), n || (n = !0, t.apply(this, arguments));
        }

        return r.listener = t, this.on(e, r), this;
      }, r.prototype.removeListener = function (e, t) {
        var n, r, a, s;
        if (!o(t)) throw TypeError("listener must be a function");
        if (!this._events || !this._events[e]) return this;
        if (a = (n = this._events[e]).length, r = -1, n === t || o(n.listener) && n.listener === t) delete this._events[e], this._events.removeListener && this.emit("removeListener", e, t);else if (i(n)) {
          for (s = a; s-- > 0;) {
            if (n[s] === t || n[s].listener && n[s].listener === t) {
              r = s;
              break;
            }
          }

          if (r < 0) return this;
          1 === n.length ? (n.length = 0, delete this._events[e]) : n.splice(r, 1), this._events.removeListener && this.emit("removeListener", e, t);
        }
        return this;
      }, r.prototype.removeAllListeners = function (e) {
        var t, n;
        if (!this._events) return this;
        if (!this._events.removeListener) return 0 === arguments.length ? this._events = {} : this._events[e] && delete this._events[e], this;

        if (0 === arguments.length) {
          for (t in this._events) {
            "removeListener" !== t && this.removeAllListeners(t);
          }

          return this.removeAllListeners("removeListener"), this._events = {}, this;
        }

        if (o(n = this._events[e])) this.removeListener(e, n);else if (n) for (; n.length;) {
          this.removeListener(e, n[n.length - 1]);
        }
        return delete this._events[e], this;
      }, r.prototype.listeners = function (e) {
        return this._events && this._events[e] ? o(this._events[e]) ? [this._events[e]] : this._events[e].slice() : [];
      }, r.prototype.listenerCount = function (e) {
        if (this._events) {
          var t = this._events[e];
          if (o(t)) return 1;
          if (t) return t.length;
        }

        return 0;
      }, r.listenerCount = function (e, t) {
        return e.listenerCount(t);
      };
    }, function (e, t, n) {
      "use strict";

      Object.defineProperty(t, "__esModule", {
        value: !0
      }), t.default = function (e) {
        if (null != e) return e;
        throw new Error("Got unexpected null or undefined");
      };
    }, function (e, t, n) {
      "use strict";

      e.exports = function () {
        return "g" + Math.random().toString(16).substr(2);
      };
    }, function (e, t, n) {
      "use strict";

      function r(e) {
        return function (e) {
          if (Array.isArray(e)) {
            for (var t = 0, n = new Array(e.length); t < e.length; t++) {
              n[t] = e[t];
            }

            return n;
          }
        }(e) || function (e) {
          if ((typeof Symbol === "function" ? Symbol.iterator : "@@iterator") in Object(e) || "[object Arguments]" === Object.prototype.toString.call(e)) return Array.from(e);
        }(e) || function () {
          throw new TypeError("Invalid attempt to spread non-iterable instance");
        }();
      }

      function o(e, t, n) {
        return t in e ? Object.defineProperty(e, t, {
          value: n,
          enumerable: !0,
          configurable: !0,
          writable: !0
        }) : e[t] = n, e;
      }

      function i(e, t) {
        for (var n = 0; n < t.length; n++) {
          var r = t[n];
          r.enumerable = r.enumerable || !1, r.configurable = !0, "value" in r && (r.writable = !0), Object.defineProperty(e, r.key, r);
        }
      }

      var a = n(4),
          s = n(32),
          u = n(33),
          c = n(3),
          l = n(34);

      function f(e, t) {
        return -1 === String(window[e]).indexOf("[native code]") ? t : window[e];
      }

      var p = 5,
          d = f("cancelIdleCallback", clearTimeout),
          h = f("requestIdleCallback", function (e, t) {
        var n = 3e3 * p;
        return n > 500 && (n = 500), setTimeout(function () {
          var t = l();
          e({
            didTimeout: !1,
            timeRemaining: function timeRemaining() {
              return 1 / 0;
            }
          });
          var n = l();
          p = (n - t) / 1e3;
        }, n);
      }),
          m = function () {
        function e(t) {
          !function (e, t) {
            if (!(e instanceof t)) throw new TypeError("Cannot call a class as a function");
          }(this, e), this._cbs = new Map(), this._inspectables = new Map(), this._cid = 0, this._listeners = {}, this._buffer = [], this._flushHandle = null, this._callers = {}, this._paused = !1, this._wall = t, t.listen(this._handleMessage.bind(this));
        }

        var t, n, l;
        return t = e, (n = [{
          key: "inspect",
          value: function value(e, t, n) {
            var r = this._cid++;
            this._cbs.set(r, function (e, t, r, o) {
              t.length && s(e, t), r && o.length && s(r, o), r && (e[a.proto] = r), n(e);
            }), this._wall.send({
              type: "inspect",
              callback: r,
              path: t,
              id: e
            });
          }
        }, {
          key: "call",
          value: function value(e, t, n) {
            var r = this._cid++;
            this._cbs.set(r, n), this._wall.send({
              type: "call",
              callback: r,
              args: t,
              name: e
            });
          }
        }, {
          key: "onCall",
          value: function value(e, t) {
            if (this._callers[e]) throw new Error("only one call handler per call name allowed");
            this._callers[e] = t;
          }
        }, {
          key: "pause",
          value: function value() {
            this._wall.send({
              type: "pause"
            });
          }
        }, {
          key: "resume",
          value: function value() {
            this._wall.send({
              type: "resume"
            });
          }
        }, {
          key: "setInspectable",
          value: function value(e, t) {
            var n = this._inspectables.get(e);

            n ? this._inspectables.set(e, function (e) {
              for (var t = 1; t < arguments.length; t++) {
                var n = null != arguments[t] ? arguments[t] : {},
                    r = Object.keys(n);
                "function" == typeof Object.getOwnPropertySymbols && (r = r.concat(Object.getOwnPropertySymbols(n).filter(function (e) {
                  return Object.getOwnPropertyDescriptor(n, e).enumerable;
                }))), r.forEach(function (t) {
                  o(e, t, n[t]);
                });
              }

              return e;
            }({}, n, t)) : this._inspectables.set(e, t);
          }
        }, {
          key: "send",
          value: function value(e, t) {
            this._buffer.push({
              evt: e,
              data: t
            }), this.scheduleFlush();
          }
        }, {
          key: "scheduleFlush",
          value: function value() {
            if (!this._flushHandle && this._buffer.length) {
              var e = this._paused ? 5e3 : 500;
              this._flushHandle = h(this.flushBufferWhileIdle.bind(this), {
                timeout: e
              });
            }
          }
        }, {
          key: "cancelFlush",
          value: function value() {
            this._flushHandle && (d(this._flushHandle), this._flushHandle = null);
          }
        }, {
          key: "flushBufferWhileIdle",
          value: function value(e) {
            this._flushHandle = null;

            for (var t = this._paused ? 20 : 10, n = Math.round(this._buffer.length / t), r = this._paused ? 50 : 100; this._buffer.length && (e.timeRemaining() > 0 || e.didTimeout);) {
              var o = Math.min(this._buffer.length, Math.max(r, n)),
                  i = this._buffer.splice(0, o);

              this.flushBufferSlice(i);
            }

            this._buffer.length && this.scheduleFlush();
          }
        }, {
          key: "flushBufferSlice",
          value: function value(e) {
            var t = this,
                n = e.map(function (e) {
              var n = e.evt,
                  r = e.data,
                  o = [],
                  i = u(r, o);
              return o.length && t.setInspectable(r.id, r), {
                type: "event",
                evt: n,
                data: i,
                cleaned: o
              };
            });

            this._wall.send({
              type: "many-events",
              events: n
            });
          }
        }, {
          key: "forget",
          value: function value(e) {
            this._inspectables.delete(e);
          }
        }, {
          key: "on",
          value: function value(e, t) {
            this._listeners[e] ? this._listeners[e].push(t) : this._listeners[e] = [t];
          }
        }, {
          key: "off",
          value: function value(e, t) {
            if (this._listeners[e]) {
              var n = this._listeners[e].indexOf(t);

              -1 !== n && this._listeners[e].splice(n, 1);
            }
          }
        }, {
          key: "once",
          value: function value(e, t) {
            var n = this;
            this.on(e, function r() {
              t.apply(this, arguments), n.off(e, r);
            });
          }
        }, {
          key: "_handleMessage",
          value: function value(e) {
            var t = this;
            if ("resume" === e.type) return this._paused = !1, void this.scheduleFlush();
            if ("pause" === e.type) return this._paused = !0, void this.cancelFlush();
            if ("callback" !== e.type) {
              if ("call" !== e.type) {
                if ("inspect" !== e.type) {
                  if ("event" === e.type) {
                    e.cleaned && s(e.data, e.cleaned);
                    var n = this._listeners[e.evt],
                        o = e.data;
                    n && n.forEach(function (e) {
                      return e(o);
                    });
                  }

                  "many-events" === e.type && e.events.forEach(function (e) {
                    e.cleaned && s(e.data, e.cleaned);
                    var n = t._listeners[e.evt];
                    n && n.forEach(function (t) {
                      return t(e.data);
                    });
                  });
                } else this._inspectResponse(e.id, e.path, e.callback);
              } else this._handleCall(e.name, e.args, e.callback);
            } else {
              var i = this._cbs.get(e.id);

              i && (i.apply(void 0, r(e.args)), this._cbs.delete(e.id));
            }
          }
        }, {
          key: "_handleCall",
          value: function value(e, t, n) {
            if (this._callers[e]) {
              var r;
              t = Array.isArray(t) ? t : [t];

              try {
                r = this._callers[e].apply(null, t);
              } catch (e) {
                return void console.error("Failed to call", e);
              }

              this._wall.send({
                type: "callback",
                id: n,
                args: [r]
              });
            } else console.warn('unknown call: "' + e + '"');
          }
        }, {
          key: "_inspectResponse",
          value: function value(e, t, n) {
            var r = this._inspectables.get(e),
                o = {},
                i = [],
                a = null,
                s = [];

            if (r) {
              var l = c(r, t),
                  f = !1,
                  p = "function" == typeof l;

              if (l && "function" == typeof l[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"]) {
                var d = Object.create({}),
                    h = 0,
                    m = !0,
                    y = !1,
                    v = void 0;

                try {
                  for (var g, b = l[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"](); !(m = (g = b.next()).done); m = !0) {
                    var _ = g.value;
                    if (h > 100) break;
                    d[h] = _, h++;
                  }
                } catch (e) {
                  y = !0, v = e;
                } finally {
                  try {
                    m || null == b.return || b.return();
                  } finally {
                    if (y) throw v;
                  }
                }

                l = d;
              }

              if (Object.getOwnPropertyNames(l).forEach(function (e) {
                "__proto__" === e && (f = !0), (!p || "arguments" !== e && "callee" !== e && "caller" !== e) && (o[e] = u(l[e], i, [e]));
              }), !f && l.__proto__ && "Object" !== l.constructor.name) {
                var w = {},
                    S = "function" == typeof l.__proto__;
                Object.getOwnPropertyNames(l.__proto__).forEach(function (e) {
                  (!S || "arguments" !== e && "callee" !== e && "caller" !== e) && (w[e] = u(l.__proto__[e], s, [e]));
                }), a = w;
              }
            }

            this._wall.send({
              type: "callback",
              id: n,
              args: [o, i, a, s]
            });
          }
        }, {
          key: "wall",
          get: function get() {
            return this._wall;
          }
        }]) && i(t.prototype, n), l && i(t, l), e;
      }();

      e.exports = m;
    }, function (e, t, n) {
      "use strict";

      e.exports = n(15)() ? Symbol : n(16);
    }, function (e, t, n) {
      "use strict";

      function r(e) {
        return (r = "function" == typeof Symbol && "symbol" == typeof (typeof Symbol === "function" ? Symbol.iterator : "@@iterator") ? function (e) {
          return typeof e;
        } : function (e) {
          return e && "function" == typeof Symbol && e.constructor === Symbol && e !== (typeof Symbol === "function" ? Symbol.prototype : "@@prototype") ? "symbol" : typeof e;
        })(e);
      }

      e.exports = function () {
        var e;
        if ("function" != typeof Symbol) return !1;
        e = Symbol("test symbol");

        try {
          String(e);
        } catch (e) {
          return !1;
        }

        return "symbol" === r(typeof Symbol === "function" ? Symbol.iterator : "@@iterator") || "object" === r(typeof Symbol === "function" ? Symbol.isConcatSpreadable : "@@isConcatSpreadable") && "object" === r(typeof Symbol === "function" ? Symbol.iterator : "@@iterator") && "object" === r(typeof Symbol === "function" ? Symbol.toPrimitive : "@@toPrimitive") && "object" === r(typeof Symbol === "function" ? Symbol.toStringTag : "@@toStringTag") && "object" === r(typeof Symbol === "function" ? Symbol.unscopables : "@@unscopables");
      };
    }, function (e, t, n) {
      "use strict";

      var r,
          o,
          _i,
          a = n(17),
          s = n(30),
          u = Object.create,
          c = Object.defineProperties,
          l = Object.defineProperty,
          f = Object.prototype,
          p = u(null);

      "function" == typeof Symbol && (r = Symbol);
      var d,
          h = (d = u(null), function (e) {
        for (var t, n, r = 0; d[e + (r || "")];) {
          ++r;
        }

        return d[e += r || ""] = !0, l(f, t = "@@" + e, a.gs(null, function (e) {
          n || (n = !0, l(this, t, a(e)), n = !1);
        })), t;
      });
      _i = function i(e) {
        if (this instanceof _i) throw new TypeError("TypeError: Symbol is not a constructor");
        return o(e);
      }, e.exports = o = function e(t) {
        var n;
        if (this instanceof e) throw new TypeError("TypeError: Symbol is not a constructor");
        return n = u(_i.prototype), t = void 0 === t ? "" : String(t), c(n, {
          __description__: a("", t),
          __name__: a("", h(t))
        });
      }, c(o, {
        for: a(function (e) {
          return p[e] ? p[e] : p[e] = o(String(e));
        }),
        keyFor: a(function (e) {
          var t;

          for (t in s(e), p) {
            if (p[t] === e) return t;
          }
        }),
        hasInstance: a("", r && r.hasInstance || o("hasInstance")),
        isConcatSpreadable: a("", r && r.isConcatSpreadable || o("isConcatSpreadable")),
        iterator: a("", r && r.iterator || o("iterator")),
        match: a("", r && r.match || o("match")),
        replace: a("", r && r.replace || o("replace")),
        search: a("", r && r.search || o("search")),
        species: a("", r && r.species || o("species")),
        split: a("", r && r.split || o("split")),
        toPrimitive: a("", r && r.toPrimitive || o("toPrimitive")),
        toStringTag: a("", r && r.toStringTag || o("toStringTag")),
        unscopables: a("", r && r.unscopables || o("unscopables"))
      }), c(_i.prototype, {
        constructor: a(o),
        toString: a("", function () {
          return this.__name__;
        })
      }), c(o.prototype, {
        toString: a(function () {
          return "Symbol (" + s(this).__description__ + ")";
        }),
        valueOf: a(function () {
          return s(this);
        })
      }), l(o.prototype, o.toPrimitive, a("", function () {
        return s(this);
      })), l(o.prototype, o.toStringTag, a("c", "Symbol")), l(_i.prototype, o.toStringTag, a("c", o.prototype[o.toStringTag])), l(_i.prototype, o.toPrimitive, a("c", o.prototype[o.toPrimitive]));
    }, function (e, t, n) {
      "use strict";

      var r = n(18),
          o = n(25),
          i = n(26),
          a = n(27);

      (e.exports = function (e, t) {
        var n, i, s, u, c;
        return arguments.length < 2 || "string" != typeof e ? (u = t, t = e, e = null) : u = arguments[2], null == e ? (n = s = !0, i = !1) : (n = a.call(e, "c"), i = a.call(e, "e"), s = a.call(e, "w")), c = {
          value: t,
          configurable: n,
          enumerable: i,
          writable: s
        }, u ? r(o(u), c) : c;
      }).gs = function (e, t, n) {
        var s, u, c, l;
        return "string" != typeof e ? (c = n, n = t, t = e, e = null) : c = arguments[3], null == t ? t = void 0 : i(t) ? null == n ? n = void 0 : i(n) || (c = n, n = void 0) : (c = t, t = n = void 0), null == e ? (s = !0, u = !1) : (s = a.call(e, "c"), u = a.call(e, "e")), l = {
          get: t,
          set: n,
          configurable: s,
          enumerable: u
        }, c ? r(o(c), l) : l;
      };
    }, function (e, t, n) {
      "use strict";

      e.exports = n(19)() ? Object.assign : n(20);
    }, function (e, t, n) {
      "use strict";

      e.exports = function () {
        var e,
            t = Object.assign;
        return "function" == typeof t && (t(e = {
          foo: "raz"
        }, {
          bar: "dwa"
        }, {
          trzy: "trzy"
        }), e.foo + e.bar + e.trzy === "razdwatrzy");
      };
    }, function (e, t, n) {
      "use strict";

      var r = n(21),
          o = n(24),
          i = Math.max;

      e.exports = function (e, t) {
        var n,
            a,
            s,
            u = i(arguments.length, 2);

        for (e = Object(o(e)), s = function s(r) {
          try {
            e[r] = t[r];
          } catch (e) {
            n || (n = e);
          }
        }, a = 1; a < u; ++a) {
          t = arguments[a], r(t).forEach(s);
        }

        if (void 0 !== n) throw n;
        return e;
      };
    }, function (e, t, n) {
      "use strict";

      e.exports = n(22)() ? Object.keys : n(23);
    }, function (e, t, n) {
      "use strict";

      e.exports = function () {
        try {
          return Object.keys("primitive"), !0;
        } catch (e) {
          return !1;
        }
      };
    }, function (e, t, n) {
      "use strict";

      var r = Object.keys;

      e.exports = function (e) {
        return r(null == e ? e : Object(e));
      };
    }, function (e, t, n) {
      "use strict";

      e.exports = function (e) {
        if (null == e) throw new TypeError("Cannot use null or undefined");
        return e;
      };
    }, function (e, t, n) {
      "use strict";

      var r = Array.prototype.forEach,
          o = Object.create;

      e.exports = function (e) {
        var t = o(null);
        return r.call(arguments, function (e) {
          null != e && function (e, t) {
            var n;

            for (n in e) {
              t[n] = e[n];
            }
          }(Object(e), t);
        }), t;
      };
    }, function (e, t, n) {
      "use strict";

      e.exports = function (e) {
        return "function" == typeof e;
      };
    }, function (e, t, n) {
      "use strict";

      e.exports = n(28)() ? String.prototype.contains : n(29);
    }, function (e, t, n) {
      "use strict";

      var r = "razdwatrzy";

      e.exports = function () {
        return "function" == typeof r.contains && !0 === r.contains("dwa") && !1 === r.contains("foo");
      };
    }, function (e, t, n) {
      "use strict";

      var r = String.prototype.indexOf;

      e.exports = function (e) {
        return r.call(this, e, arguments[1]) > -1;
      };
    }, function (e, t, n) {
      "use strict";

      var r = n(31);

      e.exports = function (e) {
        if (!r(e)) throw new TypeError(e + " is not a symbol");
        return e;
      };
    }, function (e, t, n) {
      "use strict";

      function r(e) {
        return (r = "function" == typeof Symbol && "symbol" == typeof (typeof Symbol === "function" ? Symbol.iterator : "@@iterator") ? function (e) {
          return typeof e;
        } : function (e) {
          return e && "function" == typeof Symbol && e.constructor === Symbol && e !== (typeof Symbol === "function" ? Symbol.prototype : "@@prototype") ? "symbol" : typeof e;
        })(e);
      }

      e.exports = function (e) {
        return e && ("symbol" === r(e) || "Symbol" === e["@@toStringTag"]) || !1;
      };
    }, function (e, t, n) {
      "use strict";

      var r = n(4);

      e.exports = function (e, t) {
        t.forEach(function (t) {
          var n = t.pop(),
              o = t.reduce(function (e, t) {
            return e ? e[t] : null;
          }, e);

          if (o && o[n]) {
            var i = {};
            i[r.name] = o[n].name, i[r.type] = o[n].type, i[r.meta] = o[n].meta, i[r.inspected] = !1, o[n] = i;
          }
        });
      };
    }, function (e, t, n) {
      "use strict";

      function r(e) {
        return (r = "function" == typeof Symbol && "symbol" == typeof (typeof Symbol === "function" ? Symbol.iterator : "@@iterator") ? function (e) {
          return typeof e;
        } : function (e) {
          return e && "function" == typeof Symbol && e.constructor === Symbol && e !== (typeof Symbol === "function" ? Symbol.prototype : "@@prototype") ? "symbol" : typeof e;
        })(e);
      }

      var o = 2;

      function i(e, t, n, r) {
        var o = {};
        return "array" !== e && "typed_array" !== e || (o.length = t.length), "iterator" !== e && "typed_array" !== e || (o.readOnly = !0), n.push(r), {
          type: e,
          meta: o,
          name: t.constructor && "Object" !== t.constructor.name ? t.constructor.name : ""
        };
      }

      e.exports = function e(t, n) {
        var a = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : [],
            s = arguments.length > 3 && void 0 !== arguments[3] ? arguments[3] : 0,
            u = function (e) {
          if (!e) return null;
          var t = r(e);

          if ("object" === t) {
            if (e._reactFragment) return "react_fragment";
            if (Array.isArray(e)) return "array";
            if (ArrayBuffer.isView(e)) return e instanceof DataView ? "data_view" : "typed_array";
            if (e instanceof ArrayBuffer) return "array_buffer";
            if ("function" == typeof e[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"]) return "iterator";
            if ("[object Date]" === Object.prototype.toString.call(e)) return "date";
          }

          return t;
        }(t);

        switch (u) {
          case "function":
            return n.push(a), {
              name: t.name,
              type: "function"
            };

          case "string":
            return t.length <= 500 ? t : t.slice(0, 500) + "...";

          case "symbol":
            return n.push(a), {
              type: "symbol",
              name: t.toString()
            };

          case "react_fragment":
            return "A React Fragment";

          case "array_buffer":
          case "data_view":
            return n.push(a), {
              type: u,
              name: "data_view" === u ? "DataView" : "ArrayBuffer",
              meta: {
                length: t.byteLength,
                uninspectable: !0
              }
            };

          case "array":
            return s > o ? i(u, t, n, a) : t.map(function (t, r) {
              return e(t, n, a.concat([r]), s + 1);
            });

          case "typed_array":
          case "iterator":
            return i(u, t, n, a);

          case "date":
            return n.push(a), {
              name: t.toString(),
              type: "date",
              meta: {
                uninspectable: !0
              }
            };

          case "object":
            if (s > o || t.constructor && "function" == typeof t.constructor && "Object" !== t.constructor.name) return i(u, t, n, a);
            var c = {};

            for (var l in t) {
              c[l] = e(t[l], n, a.concat([l]), s + 1);
            }

            return c;

          default:
            return t;
        }
      };
    }, function (e, t, n) {
      "use strict";

      var r,
          o = n(35);
      r = o.now ? function () {
        return o.now();
      } : function () {
        return Date.now();
      }, e.exports = r;
    }, function (e, t, n) {
      "use strict";

      var r;
      n(36).canUseDOM && (r = window.performance || window.msPerformance || window.webkitPerformance), e.exports = r || {};
    }, function (e, t, n) {
      "use strict";

      var r = !("undefined" == typeof window || !window.document || !window.document.createElement),
          o = {
        canUseDOM: r,
        canUseWorkers: "undefined" != typeof Worker,
        canUseEventListeners: r && !(!window.addEventListener && !window.attachEvent),
        canUseViewport: r && !!window.screen,
        isInWorker: !r
      };
      e.exports = o;
    }, function (e, t, n) {
      "use strict";

      function r(e, t) {
        for (var n = 0; n < t.length; n++) {
          var r = t[n];
          r.enumerable = r.enumerable || !1, r.configurable = !0, "value" in r && (r.writable = !0), Object.defineProperty(e, r.key, r);
        }
      }

      function o(e, t, n) {
        return t in e ? Object.defineProperty(e, t, {
          value: n,
          enumerable: !0,
          configurable: !0,
          writable: !0
        }) : e[t] = n, e;
      }

      function i(e) {
        return (i = "function" == typeof Symbol && "symbol" == typeof (typeof Symbol === "function" ? Symbol.iterator : "@@iterator") ? function (e) {
          return typeof e;
        } : function (e) {
          return e && "function" == typeof Symbol && e.constructor === Symbol && e !== (typeof Symbol === "function" ? Symbol.prototype : "@@prototype") ? "symbol" : typeof e;
        })(e);
      }

      var a = "object" === ("undefined" == typeof performance ? "undefined" : i(performance)) && "function" == typeof performance.now ? function () {
        return performance.now();
      } : function () {
        return Date.now();
      },
          s = function () {
        function e(t) {
          var n = this;
          !function (e, t) {
            if (!(e instanceof t)) throw new TypeError("Cannot call a class as a function");
          }(this, e), o(this, "_committedNodes", new Set()), o(this, "_isRecording", !1), o(this, "_maxActualDuration", 0), o(this, "_recordingStartTime", 0), o(this, "_onIsRecording", function (e) {
            n._committedNodes = new Set(), n._isRecording = e, n._recordingStartTime = e ? a() : 0, e && n._agent.emit("clearSnapshots");
          }), o(this, "_onMountOrUpdate", function (e) {
            n._isRecording && void 0 !== e.actualDuration && (n._committedNodes.add(e.id), n._maxActualDuration = Math.max(n._maxActualDuration, e.actualDuration));
          }), o(this, "_onRootCommitted", function (e, t, r) {
            n._isRecording && (n._takeCommitSnapshotForRoot(e, r), n._committedNodes = new Set(), n._maxActualDuration = 0);
          }), o(this, "_onUnmount", function (e) {
            n._committedNodes.delete(e);
          }), this._agent = t, t.on("isRecording", this._onIsRecording), t.on("mount", this._onMountOrUpdate), t.on("rootCommitted", this._onRootCommitted), t.on("unmount", this._onUnmount), t.on("update", this._onMountOrUpdate);
        }

        var t, n, i;
        return t = e, (n = [{
          key: "_takeCommitSnapshotForRoot",
          value: function value(e, t) {
            var n = this,
                r = {
              memoizedInteractions: (null != t.memoizedInteractions ? Array.from(t.memoizedInteractions) : []).map(function (e) {
                return {
                  name: e.name,
                  timestamp: e.timestamp - n._recordingStartTime
                };
              }),
              committedNodes: Array.from(this._committedNodes),
              commitTime: a() - this._recordingStartTime,
              duration: this._maxActualDuration,
              root: e
            };

            this._agent.emit("storeSnapshot", r);
          }
        }]) && r(t.prototype, n), i && r(t, i), e;
      }();

      e.exports = {
        init: function init(e) {
          return new s(e);
        }
      };
    }, function (e, t, n) {
      "use strict";

      e.exports = function (e) {
        if (!e.__REACT_DEVTOOLS_GLOBAL_HOOK__) {
          var t = !1,
              n = {
            _renderers: {},
            helpers: {},
            checkDCE: function checkDCE(e) {
              try {
                Function.prototype.toString.call(e).indexOf("^_^") > -1 && (t = !0, setTimeout(function () {
                  throw new Error("React is running in production mode, but dead code elimination has not been applied. Read how to correctly configure React for production: https://fb.me/react-perf-use-the-production-build");
                }));
              } catch (e) {}
            },
            inject: function inject(e) {
              var r = Math.random().toString(16).slice(2);
              n._renderers[r] = e;
              var o = t ? "deadcode" : function (e) {
                try {
                  if ("string" == typeof e.version) return e.bundleType > 0 ? "development" : "production";
                  var t = Function.prototype.toString;

                  if (e.Mount && e.Mount._renderNewRootComponent) {
                    var n = t.call(e.Mount._renderNewRootComponent);
                    return 0 !== n.indexOf("function") ? "production" : -1 !== n.indexOf("storedMeasure") ? "development" : -1 !== n.indexOf("should be a pure function") ? -1 !== n.indexOf("NODE_ENV") ? "development" : -1 !== n.indexOf("development") ? "development" : -1 !== n.indexOf("true") ? "development" : -1 !== n.indexOf("nextElement") || -1 !== n.indexOf("nextComponent") ? "unminified" : "development" : -1 !== n.indexOf("nextElement") || -1 !== n.indexOf("nextComponent") ? "unminified" : "outdated";
                  }
                } catch (e) {}

                return "production";
              }(e);
              return n.emit("renderer", {
                id: r,
                renderer: e,
                reactBuildType: o
              }), r;
            },
            _listeners: {},
            sub: function sub(e, t) {
              return n.on(e, t), function () {
                return n.off(e, t);
              };
            },
            on: function on(e, t) {
              n._listeners[e] || (n._listeners[e] = []), n._listeners[e].push(t);
            },
            off: function off(e, t) {
              if (n._listeners[e]) {
                var r = n._listeners[e].indexOf(t);

                -1 !== r && n._listeners[e].splice(r, 1), n._listeners[e].length || (n._listeners[e] = null);
              }
            },
            emit: function emit(e, t) {
              n._listeners[e] && n._listeners[e].map(function (e) {
                return e(t);
              });
            },
            supportsFiber: !0,
            _fiberRoots: {},
            getFiberRoots: function getFiberRoots(e) {
              var t = n._fiberRoots;
              return t[e] || (t[e] = new Set()), t[e];
            },
            onCommitFiberUnmount: function onCommitFiberUnmount(e, t) {
              n.helpers[e] && n.helpers[e].handleCommitFiberUnmount(t);
            },
            onCommitFiberRoot: function onCommitFiberRoot(e, t) {
              var r = n.getFiberRoots(e),
                  o = t.current,
                  i = r.has(t),
                  a = null == o.memoizedState || null == o.memoizedState.element;
              i || a ? i && a && r.delete(t) : r.add(t), n.helpers[e] && n.helpers[e].handleCommitFiberRoot(t);
            }
          };
          Object.defineProperty(e, "__REACT_DEVTOOLS_GLOBAL_HOOK__", {
            value: n
          });
        }
      };
    }, function (e, t, n) {
      "use strict";

      var r = n(40);

      e.exports = function (e, t) {
        var n = [e.sub("renderer-attached", function (e) {
          var n = e.id,
              r = (e.renderer, e.helpers);
          t.setReactInternals(n, r), r.walkTree(t.onMounted.bind(t, n), t.addRoot.bind(t, n));
        }), e.sub("mount", function (e) {
          var n = e.renderer,
              r = e.internalInstance,
              o = e.data;
          return t.onMounted(n, r, o);
        }), e.sub("unmount", function (e) {
          e.renderer;
          var n = e.internalInstance;
          return t.onUnmounted(n);
        }), e.sub("update", function (e) {
          e.renderer;
          var n = e.internalInstance,
              r = e.data;
          return t.onUpdated(n, r);
        }), e.sub("root", function (e) {
          var n = e.renderer,
              r = e.internalInstance;
          return t.addRoot(n, r);
        }), e.sub("rootCommitted", function (e) {
          var n = e.renderer,
              r = e.internalInstance,
              o = e.data;
          return t.rootCommitted(n, r, o);
        }), e.sub("updateProfileTimes", function (e) {
          e.renderer;
          var n = e.internalInstance,
              r = e.data;
          return t.onUpdatedProfileTimes(n, r);
        })];
        r(e) && (e.emit("react-devtools", t), e.reactDevtoolsAgent = t, t.on("shutdown", function () {
          n.forEach(function (e) {
            return e();
          }), e.reactDevtoolsAgent = null;
        }));
      };
    }, function (e, t, n) {
      "use strict";

      var r = n(41);

      e.exports = function (e) {
        var t = window.React && window.React.__internals;

        for (var n in t && 0 === Object.keys(e._renderers).length && e.inject(t), e._renderers) {
          e.helpers[n] = r(e, n, e._renderers[n]), e.emit("renderer-attached", {
            id: n,
            renderer: e._renderers[n],
            helpers: e.helpers[n]
          });
        }

        e.on("renderer", function (t) {
          var n = t.id,
              o = t.renderer;
          e.helpers[n] = r(e, n, o), e.emit("renderer-attached", {
            id: n,
            renderer: o,
            helpers: e.helpers[n]
          });
        });
        return e.on("shutdown", function t() {
          for (var n in e.helpers) {
            e.helpers[n].cleanup();
          }

          e.off("shutdown", t);
        }), !0;
      };
    }, function (e, t, n) {
      "use strict";

      var r = n(42),
          o = n(45),
          i = n(46);

      function a(e, t, n) {
        var i = n ? o(e) : r(e);
        i.children && Array.isArray(i.children) && i.children.forEach(function (e) {
          return a(e, t, n);
        }), t(e, i);
      }

      function s(e, t, n) {
        var r = e[t];
        return e[t] = function (e) {
          var t = r.apply(this, arguments);
          return n(t), t;
        }, r;
      }

      function u(e, t, n) {
        var r = e[t];
        return e[t] = function (e) {
          var t = r.apply(this, arguments);
          return n.apply(this, arguments), t;
        }, r;
      }

      function c(e, t) {
        var n = {};

        for (var r in t) {
          n[r] = u(e, r, t[r]);
        }

        return n;
      }

      function l(e, t) {
        for (var n in t) {
          e[n] = t[n];
        }
      }

      e.exports = function (e, t, n) {
        var u,
            f,
            p,
            d = new Map(),
            h = {},
            m = !n.Reconciler;
        return "function" == typeof n.findFiberByHostInstance ? i(e, t, n) : (n.Mount.findNodeHandle && n.Mount.nativeTagToRootNodeID ? (h.getNativeFromReactElement = function (e) {
          return n.Mount.findNodeHandle(e);
        }, h.getReactElementFromNative = function (e) {
          var t = n.Mount.nativeTagToRootNodeID(e);
          return d.get(t);
        }) : n.ComponentTree ? (h.getNativeFromReactElement = function (e) {
          return n.ComponentTree.getNodeFromInstance(e);
        }, h.getReactElementFromNative = function (e) {
          return n.ComponentTree.getClosestInstanceFromNode(e);
        }) : n.Mount.getID && n.Mount.getNode ? (h.getNativeFromReactElement = function (e) {
          try {
            return n.Mount.getNode(e._rootNodeID);
          } catch (e) {
            return;
          }
        }, h.getReactElementFromNative = function (e) {
          for (var t = n.Mount.getID(e); e && e.parentNode && !t;) {
            e = e.parentNode, t = n.Mount.getID(e);
          }

          return d.get(t);
        }) : console.warn("Unknown react version (does not have getID), probably an unshimmed React Native"), n.Mount._renderNewRootComponent ? p = s(n.Mount, "_renderNewRootComponent", function (n) {
          e.emit("root", {
            renderer: t,
            internalInstance: n
          });
        }) : n.Mount.renderComponent && (f = s(n.Mount, "renderComponent", function (n) {
          e.emit("root", {
            renderer: t,
            internalInstance: n._reactInternalInstance
          });
        })), n.Component ? (console.error("You are using a version of React with limited support in this version of the devtools.\nPlease upgrade to use at least 0.13, or you can downgrade to use the old version of the devtools:\ninstructions here https://github.com/facebook/react-devtools/tree/devtools-next#how-do-i-use-this-for-react--013"), u = c(n.Component.Mixin, {
          mountComponent: function mountComponent() {
            var n = this;
            d.set(this._rootNodeID, this), setTimeout(function () {
              e.emit("mount", {
                internalInstance: n,
                data: o(n),
                renderer: t
              });
            }, 0);
          },
          updateComponent: function updateComponent() {
            var n = this;
            setTimeout(function () {
              e.emit("update", {
                internalInstance: n,
                data: o(n),
                renderer: t
              });
            }, 0);
          },
          unmountComponent: function unmountComponent() {
            e.emit("unmount", {
              internalInstance: this,
              renderer: t
            }), d.delete(this._rootNodeID);
          }
        })) : n.Reconciler && (u = c(n.Reconciler, {
          mountComponent: function mountComponent(n, o, i, a) {
            var s = r(n);
            d.set(n._rootNodeID, n), e.emit("mount", {
              internalInstance: n,
              data: s,
              renderer: t
            });
          },
          performUpdateIfNecessary: function performUpdateIfNecessary(n, o, i, a) {
            e.emit("update", {
              internalInstance: n,
              data: r(n),
              renderer: t
            });
          },
          receiveComponent: function receiveComponent(n, o, i, a) {
            e.emit("update", {
              internalInstance: n,
              data: r(n),
              renderer: t
            });
          },
          unmountComponent: function unmountComponent(n) {
            e.emit("unmount", {
              internalInstance: n,
              renderer: t
            }), d.delete(n._rootNodeID);
          }
        })), h.walkTree = function (e, t) {
          !function (e, t, n, r) {
            for (var o in e) {
              a(e[o], t, r), n(e[o]);
            }
          }(n.Mount._instancesByReactRootID || n.Mount._instancesByContainerID, function (t, n) {
            d.set(t._rootNodeID, t), e(t, n);
          }, t, m);
        }, h.cleanup = function () {
          u && (n.Component ? l(n.Component.Mixin, u) : l(n.Reconciler, u)), p && (n.Mount._renderNewRootComponent = p), f && (n.Mount.renderComponent = f), u = null, p = null, f = null;
        }, h.renderer = null, h);
      };
    }, function (e, t, n) {
      "use strict";

      function r(e, t, n) {
        return t in e ? Object.defineProperty(e, t, {
          value: n,
          enumerable: !0,
          configurable: !0,
          writable: !0
        }) : e[t] = n, e;
      }

      function o(e) {
        return (o = "function" == typeof Symbol && "symbol" == typeof (typeof Symbol === "function" ? Symbol.iterator : "@@iterator") ? function (e) {
          return typeof e;
        } : function (e) {
          return e && "function" == typeof Symbol && e.constructor === Symbol && e !== (typeof Symbol === "function" ? Symbol.prototype : "@@prototype") ? "symbol" : typeof e;
        })(e);
      }

      var i = n(2),
          a = n(5),
          s = n(43);

      function u(e, t, n) {
        var r = t.pop(),
            o = t.reduce(function (e, t) {
          return e ? e[t] : null;
        }, e);
        o && (o[r] = n);
      }

      function c(e) {
        var t = [];

        for (var n in e) {
          t.push(e[n]);
        }

        return t;
      }

      e.exports = function (e) {
        var t = null,
            n = null,
            l = null,
            f = null,
            p = null,
            d = null,
            h = null,
            m = null,
            y = null,
            v = null,
            g = null,
            b = null,
            _ = "Native";
        if ("object" !== o(e)) _ = "Text", g = e + "";else if (null === e._currentElement || !1 === e._currentElement) _ = "Empty";else if (e._renderedComponent) _ = "NativeWrapper", t = [e._renderedComponent], n = e._instance.props, l = e._instance.state, (f = e._instance.context) && 0 === Object.keys(f).length && (f = null);else if (e._renderedChildren) t = c(e._renderedChildren);else if (e._currentElement && e._currentElement.props) {
          var w = e._currentElement.props.children,
              S = [];
          s(w, "", function (e, t) {
            var n = o(t);
            "string" !== n && "number" !== n || S.push(t);
          }), t = S.length <= 1 ? S.length ? String(S[0]) : void 0 : S;
        }

        if (!n && e._currentElement && e._currentElement.props && (n = e._currentElement.props), null != e._currentElement && (h = e._currentElement.type, e._currentElement.key && (m = String(e._currentElement.key)), v = e._currentElement._source, y = e._currentElement.ref, "string" == typeof h ? (d = h, null != e._nativeNode && (b = e._nativeNode), null != e._hostNode && (b = e._hostNode)) : "function" == typeof h ? (_ = "Composite", d = a(h), e._renderedComponent && (e._currentElement.props === e._renderedComponent._currentElement || e._currentElement.type.isReactTopLevelWrapper) && (_ = "Wrapper"), null === d && (d = "No display name")) : "string" == typeof e._stringText ? (_ = "Text", g = e._stringText) : d = a(h)), e._instance) {
          var E = e._instance,
              O = E.forceUpdate || E.updater && E.updater.enqueueForceUpdate && function (e) {
            E.updater.enqueueForceUpdate(this, e, "forceUpdate");
          };

          p = {
            canUpdate: !0,
            setState: E.setState && E.setState.bind(E),
            setInProps: O && function (e, t, n, o) {
              var a = e._currentElement;
              e._currentElement = function (e) {
                for (var t = 1; t < arguments.length; t++) {
                  var n = null != arguments[t] ? arguments[t] : {},
                      o = Object.keys(n);
                  "function" == typeof Object.getOwnPropertySymbols && (o = o.concat(Object.getOwnPropertySymbols(n).filter(function (e) {
                    return Object.getOwnPropertyDescriptor(n, e).enumerable;
                  }))), o.forEach(function (t) {
                    r(e, t, n[t]);
                  });
                }

                return e;
              }({}, a, {
                props: i(a.props, n, o)
              }), t.call(e._instance);
            }.bind(null, e, O),
            setInState: E.forceUpdate && function (e, t, n) {
              u(e.state, t, n), e.forceUpdate();
            }.bind(null, E),
            setInContext: O && function (e, t, n, r) {
              u(e.context, n, r), t.call(e);
            }.bind(null, E, O)
          }, "function" == typeof h && (b = E), E._renderedChildren && (t = c(E._renderedChildren));
        }

        return "function" == typeof e.setNativeProps && (p = {
          setNativeProps: function setNativeProps(t) {
            e.setNativeProps(t);
          }
        }), {
          nodeType: _,
          type: h,
          key: m,
          ref: y,
          source: v,
          name: d,
          props: n,
          state: l,
          context: f,
          children: t,
          text: g,
          updater: p,
          publicInstance: b
        };
      };
    }, function (e, t, n) {
      "use strict";

      function r(e) {
        return (r = "function" == typeof Symbol && "symbol" == typeof (typeof Symbol === "function" ? Symbol.iterator : "@@iterator") ? function (e) {
          return typeof e;
        } : function (e) {
          return e && "function" == typeof Symbol && e.constructor === Symbol && e !== (typeof Symbol === "function" ? Symbol.prototype : "@@prototype") ? "symbol" : typeof e;
        })(e);
      }

      var o = n(44),
          i = ".",
          a = ":",
          s = "@@iterator",
          u = "function" == typeof Symbol && (typeof Symbol === "function" ? Symbol.iterator : "@@iterator"),
          c = "function" == typeof Symbol && (typeof Symbol === "function" ? Symbol.for : "@@for") && (typeof Symbol === "function" ? Symbol.for : "@@for")("react.element") || 60103;

      function l(e, t) {
        return "object" === r(e) && null !== e && null != e.key ? (n = e.key, o = {
          "=": "=0",
          ":": "=2"
        }, "$" + ("" + n).replace(/[=:]/g, function (e) {
          return o[e];
        })) : t.toString(36);
        var n, o;
      }

      e.exports = function e(t, n, f, p) {
        var d,
            h = r(t);
        if ("undefined" !== h && "boolean" !== h || (t = null), null === t || "string" === h || "number" === h || "object" === h && t.$$typeof === c) return f(p, t, "" === n ? i + l(t, 0) : n), 1;
        var m = 0,
            y = "" === n ? i : n + a;
        if (Array.isArray(t)) for (var v = 0; v < t.length; v++) {
          m += e(d = t[v], y + l(d, v), f, p);
        } else {
          var g = u && t[u] || t[s];
          if ("function" == typeof g) for (var b, _ = g.call(t), w = 0; !(b = _.next()).done;) {
            m += e(d = b.value, y + l(d, w++), f, p);
          } else if ("object" === h) {
            var S = "" + t;
            o(!1, "The React Devtools cannot render an object as a child. (found: %s).%s", "[object Object]" === S ? "object with keys {" + Object.keys(t).join(", ") + "}" : S, " If you meant to render a collection of children, use an array instead.");
          }
        }
        return m;
      };
    }, function (e, t, n) {
      "use strict";

      e.exports = function (e, t, n, r, o, i, a, s) {
        if (!e) {
          var u;
          if (void 0 === t) u = new Error("Minified exception occurred; use the non-minified dev environment for the full error message and additional helpful warnings.");else {
            var c = [n, r, o, i, a, s],
                l = 0;
            (u = new Error(t.replace(/%s/g, function () {
              return c[l++];
            }))).name = "Invariant Violation";
          }
          throw u.framesToPop = 1, u;
        }
      };
    }, function (e, t, n) {
      "use strict";

      var r = n(2);

      function o(e, t, n) {
        var r = t.pop(),
            o = t.reduce(function (e, t) {
          return e ? e[t] : null;
        }, e);
        o && (o[r] = n);
      }

      e.exports = function (e) {
        var t = null,
            n = e.props,
            i = e.state,
            a = e.context,
            s = null,
            u = null,
            c = null,
            l = null,
            f = null,
            p = null,
            d = null,
            h = "Native";
        return e._renderedComponent ? (h = "Wrapper", t = [e._renderedComponent], a && 0 === Object.keys(a).length && (a = null)) : e._renderedChildren ? (u = e.constructor.displayName, t = function (e) {
          var t = [];

          for (var n in e) {
            t.push(e[n]);
          }

          return t;
        }(e._renderedChildren)) : "string" == typeof n.children && (u = e.constructor.displayName, t = n.children, h = "Native"), !n && e._currentElement && e._currentElement.props && (n = e._currentElement.props), e._currentElement && (c = e._currentElement.type, e._currentElement.key && (l = String(e._currentElement.key)), f = e._currentElement.ref, "string" == typeof c ? u = c : (h = "Composite", (u = c.displayName) || (u = "No display name"))), u || (u = e.constructor.displayName || "No display name", h = "Composite"), "string" == typeof n && (h = "Text", p = n, n = null, u = null), e.forceUpdate && (s = {
          canUpdate: !0,
          setState: e.setState.bind(e),
          setInProps: e.forceUpdate && function (e, t, n) {
            e.props = r(e.props, t, n), e.forceUpdate();
          }.bind(null, e),
          setInState: e.forceUpdate && function (e, t, n) {
            o(e.state, t, n), e.forceUpdate();
          }.bind(null, e),
          setInContext: e.forceUpdate && function (e, t, n) {
            o(e.context, t, n), e.forceUpdate();
          }.bind(null, e)
        }, d = e), {
          nodeType: h,
          type: c,
          key: l,
          ref: f,
          source: null,
          name: u,
          props: n,
          state: i,
          context: a,
          children: t,
          text: p,
          updater: s,
          publicInstance: d
        };
      };
    }, function (e, t, n) {
      "use strict";

      function r(e) {
        return (r = "function" == typeof Symbol && "symbol" == typeof (typeof Symbol === "function" ? Symbol.iterator : "@@iterator") ? function (e) {
          return typeof e;
        } : function (e) {
          return e && "function" == typeof Symbol && e.constructor === Symbol && e !== (typeof Symbol === "function" ? Symbol.prototype : "@@prototype") ? "symbol" : typeof e;
        })(e);
      }

      var o = n(47),
          i = n(2),
          a = n(5);

      e.exports = function (e, t, n) {
        var s,
            u = n.overrideProps,
            c = (s = n.version, {
          ReactTypeOfWork: o.gte(s, "16.6.0-beta.0") ? {
            ClassComponent: 1,
            ContextConsumer: 9,
            ContextProvider: 10,
            CoroutineComponent: -1,
            CoroutineHandlerPhase: -1,
            ForwardRef: 11,
            Fragment: 7,
            FunctionComponent: 0,
            HostComponent: 5,
            HostPortal: 4,
            HostRoot: 3,
            HostText: 6,
            IncompleteClassComponent: 17,
            IndeterminateComponent: 2,
            LazyComponent: 16,
            MemoComponent: 14,
            Mode: 8,
            Profiler: 12,
            SimpleMemoComponent: 15,
            SuspenseComponent: 13,
            YieldComponent: -1
          } : o.gte(s, "16.4.3-alpha") ? {
            ClassComponent: 2,
            ContextConsumer: 11,
            ContextProvider: 12,
            CoroutineComponent: -1,
            CoroutineHandlerPhase: -1,
            ForwardRef: 13,
            Fragment: 9,
            FunctionComponent: 0,
            HostComponent: 7,
            HostPortal: 6,
            HostRoot: 5,
            HostText: 8,
            IncompleteClassComponent: -1,
            IndeterminateComponent: 4,
            LazyComponent: -1,
            MemoComponent: -1,
            Mode: 10,
            Profiler: 15,
            SimpleMemoComponent: -1,
            SuspenseComponent: 16,
            YieldComponent: -1
          } : {
            ClassComponent: 2,
            ContextConsumer: 12,
            ContextProvider: 13,
            CoroutineComponent: 7,
            CoroutineHandlerPhase: 8,
            ForwardRef: 14,
            Fragment: 10,
            FunctionComponent: 1,
            HostComponent: 5,
            HostPortal: 4,
            HostRoot: 3,
            HostText: 6,
            IncompleteClassComponent: -1,
            IndeterminateComponent: 0,
            LazyComponent: -1,
            MemoComponent: -1,
            Mode: 11,
            Profiler: 15,
            SimpleMemoComponent: -1,
            SuspenseComponent: 16,
            YieldComponent: 9
          },
          ReactSymbols: {
            CONCURRENT_MODE_NUMBER: 60111,
            CONCURRENT_MODE_SYMBOL_STRING: "Symbol(react.concurrent_mode)",
            DEPRECATED_ASYNC_MODE_SYMBOL_STRING: "Symbol(react.async_mode)",
            CONTEXT_CONSUMER_NUMBER: 60110,
            CONTEXT_CONSUMER_SYMBOL_STRING: "Symbol(react.context)",
            CONTEXT_PROVIDER_NUMBER: 60109,
            CONTEXT_PROVIDER_SYMBOL_STRING: "Symbol(react.provider)",
            FORWARD_REF_NUMBER: 60112,
            FORWARD_REF_SYMBOL_STRING: "Symbol(react.forward_ref)",
            MEMO_NUMBER: 60115,
            MEMO_SYMBOL_STRING: "Symbol(react.memo)",
            PROFILER_NUMBER: 60114,
            PROFILER_SYMBOL_STRING: "Symbol(react.profiler)",
            STRICT_MODE_NUMBER: 60108,
            STRICT_MODE_SYMBOL_STRING: "Symbol(react.strict_mode)",
            SUSPENSE_NUMBER: 60113,
            SUSPENSE_SYMBOL_STRING: "Symbol(react.suspense)",
            DEPRECATED_PLACEHOLDER_SYMBOL_STRING: "Symbol(react.placeholder)"
          },
          ReactTypeOfSideEffect: {
            PerformedWork: 1
          }
        }),
            l = c.ReactTypeOfWork,
            f = c.ReactSymbols,
            p = c.ReactTypeOfSideEffect.PerformedWork,
            d = l.FunctionComponent,
            h = l.ClassComponent,
            m = l.ContextConsumer,
            y = l.Fragment,
            v = l.ForwardRef,
            g = l.HostRoot,
            b = l.HostPortal,
            _ = l.HostComponent,
            w = l.HostText,
            S = l.IncompleteClassComponent,
            E = l.IndeterminateComponent,
            O = l.MemoComponent,
            x = l.SimpleMemoComponent,
            C = f.CONCURRENT_MODE_NUMBER,
            I = f.CONCURRENT_MODE_SYMBOL_STRING,
            N = f.DEPRECATED_ASYNC_MODE_SYMBOL_STRING,
            T = f.CONTEXT_CONSUMER_NUMBER,
            k = f.CONTEXT_CONSUMER_SYMBOL_STRING,
            R = f.CONTEXT_PROVIDER_NUMBER,
            j = f.CONTEXT_PROVIDER_SYMBOL_STRING,
            M = f.PROFILER_NUMBER,
            D = f.PROFILER_SYMBOL_STRING,
            P = f.STRICT_MODE_NUMBER,
            L = f.STRICT_MODE_SYMBOL_STRING,
            A = f.SUSPENSE_NUMBER,
            B = f.SUSPENSE_SYMBOL_STRING,
            F = f.DEPRECATED_PLACEHOLDER_SYMBOL_STRING;

        function U(e) {
          var t = e.elementType,
              n = e.type,
              o = e.key,
              s = e.ref,
              c = e.tag,
              l = e._debugSource,
              f = null,
              p = null,
              m = null,
              U = null,
              H = null,
              $ = null,
              G = null,
              W = null,
              q = null,
              Y = null,
              K = null,
              X = null,
              J = null,
              Z = null,
              Q = !1,
              ee = (c === d || c === x || c === v) && !!e.memoizedState,
              te = n;

          switch ("object" === r(n) && null !== n && "function" == typeof n.then && (te = n._reactResult), "function" == typeof u && ($ = {
            canUpdate: !0,
            setState: null,
            setInProps: u.bind(null, e),
            setInState: null,
            setInContext: null
          }), c) {
            case h:
            case d:
            case S:
            case E:
              G = "Composite", W = a(te), f = e.stateNode, p = e.memoizedProps, m = e.memoizedState, null != f && (H = f.context) && 0 === Object.keys(H).length && (H = null);
              var ne = f;
              ne && ($ = {
                canUpdate: !0,
                setState: ne.setState && ne.setState.bind(ne),
                setInProps: ne.forceUpdate && function (e, t, n) {
                  var r = e.stateNode;
                  e.pendingProps = i(r.props, t, n), e.alternate && (e.alternate.pendingProps = e.pendingProps), e.stateNode.forceUpdate();
                }.bind(null, e),
                setInState: ne.forceUpdate && function (e, t, n) {
                  z(e.state, t, n), e.forceUpdate();
                }.bind(null, ne),
                setInContext: ne.forceUpdate && function (e, t, n) {
                  z(e.context, t, n), e.forceUpdate();
                }.bind(null, ne)
              }), U = [];
              break;

            case v:
              var re = a(te.render, "");
              G = "Special", W = te.displayName || ("" !== re ? "ForwardRef(".concat(re, ")") : "ForwardRef"), p = e.memoizedProps, m = e.memoizedState, U = [];
              break;

            case g:
              G = "Wrapper", U = [], K = e.stateNode.memoizedInteractions;
              break;

            case b:
              G = "Portal", W = "ReactPortal", p = {
                target: e.stateNode.containerInfo
              }, U = [];
              break;

            case _:
              G = "Native", W = (W = e.type).replace("topsecret-", ""), f = e.stateNode, U = "string" == typeof (p = e.memoizedProps).children || "number" == typeof p.children ? p.children.toString() : [], "function" == typeof e.stateNode.setNativeProps && ($ = {
                setNativeProps: function setNativeProps(t) {
                  e.stateNode.setNativeProps(t);
                }
              });
              break;

            case w:
              G = "Text", f = e.stateNode, q = e.memoizedProps;
              break;

            case y:
              G = "Wrapper", U = [];
              break;

            case O:
            case x:
              if (G = "Composite", t.displayName) W = t.displayName;else {
                var oe = n.displayName || n.name;
                W = oe ? "Memo(".concat(oe, ")") : "Memo";
              }
              p = e.memoizedProps, m = e.memoizedState, U = [];
              break;

            default:
              var ie = "object" === r(n) && null !== n ? n.$$typeof : n;

              switch ("symbol" === r(ie) ? ie.toString() : ie) {
                case C:
                case I:
                case N:
                  G = "Special", W = "ConcurrentMode", U = [];
                  break;

                case R:
                case j:
                  G = "Special", p = e.memoizedProps, Y = e.type._context || e.type.context, W = "".concat(Y.displayName || "Context", ".Provider"), U = [];
                  break;

                case T:
                case k:
                  G = "Special", p = e.memoizedProps, Y = e.type._context || e.type, W = "".concat(Y.displayName || "Context", ".Consumer"), U = [];
                  break;

                case P:
                case L:
                  G = "Special", W = "StrictMode", U = [];
                  break;

                case A:
                case B:
                case F:
                  G = "Special", W = "Suspense", p = e.memoizedProps, U = [], Q = null !== e.memoizedState;
                  break;

                case M:
                case D:
                  G = "Special", p = e.memoizedProps, W = "Profiler(".concat(e.memoizedProps.id, ")"), U = [];
                  break;

                default:
                  G = "Native", p = e.memoizedProps, W = "TODO_NOT_IMPLEMENTED_YET", U = [];
              }

          }

          if (null !== p && void 0 !== r(e.elementType) && e.type !== e.elementType && (p = function (e, t) {
            if (e && e.defaultProps) {
              var n = _extends({}, t),
                  r = e.defaultProps;

              for (var o in r) {
                void 0 === n[o] && (n[o] = r[o]);
              }

              return n;
            }

            return t;
          }(e.type, p)), Array.isArray(U)) if (Q) {
            var ae = e.child,
                se = ae.child,
                ue = ae.sibling.child;
            U.push(se), U.push(ue);
          } else for (var ce = e.child; ce;) {
            U.push(V(ce)), ce = ce.sibling;
          }
          return void 0 !== e.actualDuration && (X = e.actualDuration, J = e.actualStartTime, Z = e.treeBaseDuration), null === f && (f = {
            props: p,
            state: m,
            type: n
          }), {
            nodeType: G,
            type: n,
            key: o,
            ref: s,
            source: l,
            name: W,
            props: p,
            state: m,
            context: H,
            children: U,
            text: q,
            updater: $,
            publicInstance: f,
            memoizedInteractions: K,
            actualDuration: X,
            actualStartTime: J,
            treeBaseDuration: Z,
            containsHooks: ee
          };
        }

        function z(e, t, n) {
          var r = t.pop(),
              o = t.reduce(function (e, t) {
            return e ? e[t] : null;
          }, e);
          o && (o[r] = n);
        }

        var H = new Set();

        function V(e) {
          if (H.has(e)) return e;
          var t = e.alternate;
          return null != t && H.has(t) ? t : (H.add(e), e);
        }

        var $ = [];

        function G() {
          var t = $;
          $ = [];

          for (var n = 0; n < t.length; n++) {
            var r = t[n];
            e.emit(r.type, r);
          }
        }

        function W(e) {
          $.push({
            internalInstance: V(e),
            data: U(e),
            renderer: t,
            type: "mount"
          }), e.tag === g && $.push({
            internalInstance: V(e),
            renderer: t,
            type: "root"
          });
        }

        function q(e, n) {
          var r,
              o,
              i = U(e);
          if (!n && !function (e, t) {
            switch (t.tag) {
              case h:
              case d:
              case m:
              case O:
              case x:
                return (t.effectTag & p) === p;

              default:
                return e.memoizedProps !== t.memoizedProps || e.memoizedState !== t.memoizedState || e.ref !== t.ref;
            }
          }(e.alternate, e)) return r = e.alternate, o = e, void (void 0 === r.actualDuration || r.actualDuration === o.actualDuration && r.actualStartTime === o.actualStartTime && r.treeBaseDuration === o.treeBaseDuration || $.push({
            internalInstance: V(e),
            data: i,
            renderer: t,
            type: "updateProfileTimes"
          }));
          $.push({
            internalInstance: V(e),
            data: i,
            renderer: t,
            type: "update"
          });
        }

        function Y(e) {
          var n = e.tag === g,
              r = V(e),
              o = {
            internalInstance: r,
            renderer: t,
            type: "unmount"
          };
          n ? $.push(o) : $.unshift(o), H.delete(r);
        }

        function K(e) {
          $.push({
            internalInstance: V(e),
            data: U(e),
            renderer: t,
            type: "rootCommitted"
          });
        }

        function X(e) {
          var t = e;

          e: for (;;) {
            if (t.child) t.child.return = t, t = t.child;else {
              if (W(t), t == e) return;

              if (!t.sibling) {
                for (; t.return;) {
                  if (W(t = t.return), t == e) return;

                  if (t.sibling) {
                    t.sibling.return = t.return, t = t.sibling;
                    continue e;
                  }
                }

                return;
              }

              t.sibling.return = t.return, t = t.sibling;
            }
          }
        }

        return {
          getNativeFromReactElement: function getNativeFromReactElement(e) {
            try {
              var t = e;
              return n.findHostInstanceByFiber(t);
            } catch (e) {
              return null;
            }
          },
          getReactElementFromNative: function getReactElementFromNative(e) {
            var t = n.findFiberByHostInstance(e);
            return null != t ? V(t) : null;
          },
          handleCommitFiberRoot: function handleCommitFiberRoot(e) {
            var t = e.current,
                n = t.alternate;

            if (n) {
              var r = null != n.memoizedState && null != n.memoizedState.element,
                  o = null != t.memoizedState && null != t.memoizedState.element;
              !r && o ? X(t) : r && o ? function e(t, n) {
                if (t.tag === l.SuspenseComponent && null !== t.memoizedState) {
                  var r = t.child.sibling.child;
                  r.alternate ? e(r, r.alternate) : X(r), q(t, !1);
                } else {
                  var o = !1;

                  if (t.child !== n.child) {
                    for (var i = t.child, a = n.child; i;) {
                      if (i.alternate) {
                        var s = i.alternate;
                        e(i, s), o || s === a || (o = !0);
                      } else X(i), o || (o = !0);

                      i = i.sibling, o || null == a || (a = a.sibling);
                    }

                    o || null == a || (o = !0);
                  }

                  q(t, o);
                }
              }(t, n) : r && !o && Y(t);
            } else X(t);

            K(t), G();
          },
          handleCommitFiberUnmount: function handleCommitFiberUnmount(e) {
            Y(e);
          },
          cleanup: function cleanup() {},
          walkTree: function walkTree() {
            e.getFiberRoots(t).forEach(function (e) {
              X(e.current), K(e.current);
            }), G();
          },
          renderer: n
        };
      };
    }, function (e, t, n) {
      (function (n) {
        function r(e) {
          return (r = "function" == typeof Symbol && "symbol" == typeof (typeof Symbol === "function" ? Symbol.iterator : "@@iterator") ? function (e) {
            return typeof e;
          } : function (e) {
            return e && "function" == typeof Symbol && e.constructor === Symbol && e !== (typeof Symbol === "function" ? Symbol.prototype : "@@prototype") ? "symbol" : typeof e;
          })(e);
        }

        var o;
        t = e.exports = K, o = "object" === (void 0 === n ? "undefined" : r(n)) && n.env && n.env.NODE_DEBUG && /\bsemver\b/i.test(n.env.NODE_DEBUG) ? function () {
          var e = Array.prototype.slice.call(arguments, 0);
          e.unshift("SEMVER"), console.log.apply(console, e);
        } : function () {}, t.SEMVER_SPEC_VERSION = "2.0.0";
        var i = 256,
            a = Number.MAX_SAFE_INTEGER || 9007199254740991,
            s = t.re = [],
            u = t.src = [],
            c = 0,
            l = c++;
        u[l] = "0|[1-9]\\d*";
        var f = c++;
        u[f] = "[0-9]+";
        var p = c++;
        u[p] = "\\d*[a-zA-Z-][a-zA-Z0-9-]*";
        var d = c++;
        u[d] = "(" + u[l] + ")\\.(" + u[l] + ")\\.(" + u[l] + ")";
        var h = c++;
        u[h] = "(" + u[f] + ")\\.(" + u[f] + ")\\.(" + u[f] + ")";
        var m = c++;
        u[m] = "(?:" + u[l] + "|" + u[p] + ")";
        var y = c++;
        u[y] = "(?:" + u[f] + "|" + u[p] + ")";
        var v = c++;
        u[v] = "(?:-(" + u[m] + "(?:\\." + u[m] + ")*))";
        var g = c++;
        u[g] = "(?:-?(" + u[y] + "(?:\\." + u[y] + ")*))";
        var b = c++;
        u[b] = "[0-9A-Za-z-]+";

        var _ = c++;

        u[_] = "(?:\\+(" + u[b] + "(?:\\." + u[b] + ")*))";
        var w = c++,
            S = "v?" + u[d] + u[v] + "?" + u[_] + "?";
        u[w] = "^" + S + "$";
        var E = "[v=\\s]*" + u[h] + u[g] + "?" + u[_] + "?",
            O = c++;
        u[O] = "^" + E + "$";
        var x = c++;
        u[x] = "((?:<|>)?=?)";
        var C = c++;
        u[C] = u[f] + "|x|X|\\*";
        var I = c++;
        u[I] = u[l] + "|x|X|\\*";
        var N = c++;
        u[N] = "[v=\\s]*(" + u[I] + ")(?:\\.(" + u[I] + ")(?:\\.(" + u[I] + ")(?:" + u[v] + ")?" + u[_] + "?)?)?";
        var T = c++;
        u[T] = "[v=\\s]*(" + u[C] + ")(?:\\.(" + u[C] + ")(?:\\.(" + u[C] + ")(?:" + u[g] + ")?" + u[_] + "?)?)?";
        var k = c++;
        u[k] = "^" + u[x] + "\\s*" + u[N] + "$";
        var R = c++;
        u[R] = "^" + u[x] + "\\s*" + u[T] + "$";
        var j = c++;
        u[j] = "(?:^|[^\\d])(\\d{1,16})(?:\\.(\\d{1,16}))?(?:\\.(\\d{1,16}))?(?:$|[^\\d])";
        var M = c++;
        u[M] = "(?:~>?)";
        var D = c++;
        u[D] = "(\\s*)" + u[M] + "\\s+", s[D] = new RegExp(u[D], "g");
        var P = c++;
        u[P] = "^" + u[M] + u[N] + "$";
        var L = c++;
        u[L] = "^" + u[M] + u[T] + "$";
        var A = c++;
        u[A] = "(?:\\^)";
        var B = c++;
        u[B] = "(\\s*)" + u[A] + "\\s+", s[B] = new RegExp(u[B], "g");
        var F = c++;
        u[F] = "^" + u[A] + u[N] + "$";
        var U = c++;
        u[U] = "^" + u[A] + u[T] + "$";
        var z = c++;
        u[z] = "^" + u[x] + "\\s*(" + E + ")$|^$";
        var H = c++;
        u[H] = "^" + u[x] + "\\s*(" + S + ")$|^$";
        var V = c++;
        u[V] = "(\\s*)" + u[x] + "\\s*(" + E + "|" + u[N] + ")", s[V] = new RegExp(u[V], "g");
        var $ = c++;
        u[$] = "^\\s*(" + u[N] + ")\\s+-\\s+(" + u[N] + ")\\s*$";
        var G = c++;
        u[G] = "^\\s*(" + u[T] + ")\\s+-\\s+(" + u[T] + ")\\s*$";
        var W = c++;
        u[W] = "(<|>)?=?\\s*\\*";

        for (var q = 0; q < 35; q++) {
          o(q, u[q]), s[q] || (s[q] = new RegExp(u[q]));
        }

        function Y(e, t) {
          if (e instanceof K) return e;
          if ("string" != typeof e) return null;
          if (e.length > i) return null;
          if (!(t ? s[O] : s[w]).test(e)) return null;

          try {
            return new K(e, t);
          } catch (e) {
            return null;
          }
        }

        function K(e, t) {
          if (e instanceof K) {
            if (e.loose === t) return e;
            e = e.version;
          } else if ("string" != typeof e) throw new TypeError("Invalid Version: " + e);

          if (e.length > i) throw new TypeError("version is longer than " + i + " characters");
          if (!(this instanceof K)) return new K(e, t);
          o("SemVer", e, t), this.loose = t;
          var n = e.trim().match(t ? s[O] : s[w]);
          if (!n) throw new TypeError("Invalid Version: " + e);
          if (this.raw = e, this.major = +n[1], this.minor = +n[2], this.patch = +n[3], this.major > a || this.major < 0) throw new TypeError("Invalid major version");
          if (this.minor > a || this.minor < 0) throw new TypeError("Invalid minor version");
          if (this.patch > a || this.patch < 0) throw new TypeError("Invalid patch version");
          n[4] ? this.prerelease = n[4].split(".").map(function (e) {
            if (/^[0-9]+$/.test(e)) {
              var t = +e;
              if (t >= 0 && t < a) return t;
            }

            return e;
          }) : this.prerelease = [], this.build = n[5] ? n[5].split(".") : [], this.format();
        }

        t.parse = Y, t.valid = function (e, t) {
          var n = Y(e, t);
          return n ? n.version : null;
        }, t.clean = function (e, t) {
          var n = Y(e.trim().replace(/^[=v]+/, ""), t);
          return n ? n.version : null;
        }, t.SemVer = K, K.prototype.format = function () {
          return this.version = this.major + "." + this.minor + "." + this.patch, this.prerelease.length && (this.version += "-" + this.prerelease.join(".")), this.version;
        }, K.prototype.toString = function () {
          return this.version;
        }, K.prototype.compare = function (e) {
          return o("SemVer.compare", this.version, this.loose, e), e instanceof K || (e = new K(e, this.loose)), this.compareMain(e) || this.comparePre(e);
        }, K.prototype.compareMain = function (e) {
          return e instanceof K || (e = new K(e, this.loose)), J(this.major, e.major) || J(this.minor, e.minor) || J(this.patch, e.patch);
        }, K.prototype.comparePre = function (e) {
          if (e instanceof K || (e = new K(e, this.loose)), this.prerelease.length && !e.prerelease.length) return -1;
          if (!this.prerelease.length && e.prerelease.length) return 1;
          if (!this.prerelease.length && !e.prerelease.length) return 0;
          var t = 0;

          do {
            var n = this.prerelease[t],
                r = e.prerelease[t];
            if (o("prerelease compare", t, n, r), void 0 === n && void 0 === r) return 0;
            if (void 0 === r) return 1;
            if (void 0 === n) return -1;
            if (n !== r) return J(n, r);
          } while (++t);
        }, K.prototype.inc = function (e, t) {
          switch (e) {
            case "premajor":
              this.prerelease.length = 0, this.patch = 0, this.minor = 0, this.major++, this.inc("pre", t);
              break;

            case "preminor":
              this.prerelease.length = 0, this.patch = 0, this.minor++, this.inc("pre", t);
              break;

            case "prepatch":
              this.prerelease.length = 0, this.inc("patch", t), this.inc("pre", t);
              break;

            case "prerelease":
              0 === this.prerelease.length && this.inc("patch", t), this.inc("pre", t);
              break;

            case "major":
              0 === this.minor && 0 === this.patch && 0 !== this.prerelease.length || this.major++, this.minor = 0, this.patch = 0, this.prerelease = [];
              break;

            case "minor":
              0 === this.patch && 0 !== this.prerelease.length || this.minor++, this.patch = 0, this.prerelease = [];
              break;

            case "patch":
              0 === this.prerelease.length && this.patch++, this.prerelease = [];
              break;

            case "pre":
              if (0 === this.prerelease.length) this.prerelease = [0];else {
                for (var n = this.prerelease.length; --n >= 0;) {
                  "number" == typeof this.prerelease[n] && (this.prerelease[n]++, n = -2);
                }

                -1 === n && this.prerelease.push(0);
              }
              t && (this.prerelease[0] === t ? isNaN(this.prerelease[1]) && (this.prerelease = [t, 0]) : this.prerelease = [t, 0]);
              break;

            default:
              throw new Error("invalid increment argument: " + e);
          }

          return this.format(), this.raw = this.version, this;
        }, t.inc = function (e, t, n, r) {
          "string" == typeof n && (r = n, n = void 0);

          try {
            return new K(e, n).inc(t, r).version;
          } catch (e) {
            return null;
          }
        }, t.diff = function (e, t) {
          if (te(e, t)) return null;
          var n = Y(e),
              r = Y(t);

          if (n.prerelease.length || r.prerelease.length) {
            for (var o in n) {
              if (("major" === o || "minor" === o || "patch" === o) && n[o] !== r[o]) return "pre" + o;
            }

            return "prerelease";
          }

          for (var o in n) {
            if (("major" === o || "minor" === o || "patch" === o) && n[o] !== r[o]) return o;
          }
        }, t.compareIdentifiers = J;
        var X = /^[0-9]+$/;

        function J(e, t) {
          var n = X.test(e),
              r = X.test(t);
          return n && r && (e = +e, t = +t), n && !r ? -1 : r && !n ? 1 : e < t ? -1 : e > t ? 1 : 0;
        }

        function Z(e, t, n) {
          return new K(e, n).compare(new K(t, n));
        }

        function Q(e, t, n) {
          return Z(e, t, n) > 0;
        }

        function ee(e, t, n) {
          return Z(e, t, n) < 0;
        }

        function te(e, t, n) {
          return 0 === Z(e, t, n);
        }

        function ne(e, t, n) {
          return 0 !== Z(e, t, n);
        }

        function re(e, t, n) {
          return Z(e, t, n) >= 0;
        }

        function oe(e, t, n) {
          return Z(e, t, n) <= 0;
        }

        function ie(e, t, n, o) {
          var i;

          switch (t) {
            case "===":
              "object" === r(e) && (e = e.version), "object" === r(n) && (n = n.version), i = e === n;
              break;

            case "!==":
              "object" === r(e) && (e = e.version), "object" === r(n) && (n = n.version), i = e !== n;
              break;

            case "":
            case "=":
            case "==":
              i = te(e, n, o);
              break;

            case "!=":
              i = ne(e, n, o);
              break;

            case ">":
              i = Q(e, n, o);
              break;

            case ">=":
              i = re(e, n, o);
              break;

            case "<":
              i = ee(e, n, o);
              break;

            case "<=":
              i = oe(e, n, o);
              break;

            default:
              throw new TypeError("Invalid operator: " + t);
          }

          return i;
        }

        function ae(e, t) {
          if (e instanceof ae) {
            if (e.loose === t) return e;
            e = e.value;
          }

          if (!(this instanceof ae)) return new ae(e, t);
          o("comparator", e, t), this.loose = t, this.parse(e), this.semver === se ? this.value = "" : this.value = this.operator + this.semver.version, o("comp", this);
        }

        t.rcompareIdentifiers = function (e, t) {
          return J(t, e);
        }, t.major = function (e, t) {
          return new K(e, t).major;
        }, t.minor = function (e, t) {
          return new K(e, t).minor;
        }, t.patch = function (e, t) {
          return new K(e, t).patch;
        }, t.compare = Z, t.compareLoose = function (e, t) {
          return Z(e, t, !0);
        }, t.rcompare = function (e, t, n) {
          return Z(t, e, n);
        }, t.sort = function (e, n) {
          return e.sort(function (e, r) {
            return t.compare(e, r, n);
          });
        }, t.rsort = function (e, n) {
          return e.sort(function (e, r) {
            return t.rcompare(e, r, n);
          });
        }, t.gt = Q, t.lt = ee, t.eq = te, t.neq = ne, t.gte = re, t.lte = oe, t.cmp = ie, t.Comparator = ae;
        var se = {};

        function ue(e, t) {
          if (e instanceof ue) return e.loose === t ? e : new ue(e.raw, t);
          if (e instanceof ae) return new ue(e.value, t);
          if (!(this instanceof ue)) return new ue(e, t);
          if (this.loose = t, this.raw = e, this.set = e.split(/\s*\|\|\s*/).map(function (e) {
            return this.parseRange(e.trim());
          }, this).filter(function (e) {
            return e.length;
          }), !this.set.length) throw new TypeError("Invalid SemVer Range: " + e);
          this.format();
        }

        function ce(e) {
          return !e || "x" === e.toLowerCase() || "*" === e;
        }

        function le(e, t, n, r, o, i, a, s, u, c, l, f, p) {
          return ((t = ce(n) ? "" : ce(r) ? ">=" + n + ".0.0" : ce(o) ? ">=" + n + "." + r + ".0" : ">=" + t) + " " + (s = ce(u) ? "" : ce(c) ? "<" + (+u + 1) + ".0.0" : ce(l) ? "<" + u + "." + (+c + 1) + ".0" : f ? "<=" + u + "." + c + "." + l + "-" + f : "<=" + s)).trim();
        }

        function fe(e, t) {
          for (var n = 0; n < e.length; n++) {
            if (!e[n].test(t)) return !1;
          }

          if (t.prerelease.length) {
            for (n = 0; n < e.length; n++) {
              if (o(e[n].semver), e[n].semver !== se && e[n].semver.prerelease.length > 0) {
                var r = e[n].semver;
                if (r.major === t.major && r.minor === t.minor && r.patch === t.patch) return !0;
              }
            }

            return !1;
          }

          return !0;
        }

        function pe(e, t, n) {
          try {
            t = new ue(t, n);
          } catch (e) {
            return !1;
          }

          return t.test(e);
        }

        function de(e, t, n, r) {
          var o, i, a, s, u;

          switch (e = new K(e, r), t = new ue(t, r), n) {
            case ">":
              o = Q, i = oe, a = ee, s = ">", u = ">=";
              break;

            case "<":
              o = ee, i = re, a = Q, s = "<", u = "<=";
              break;

            default:
              throw new TypeError('Must provide a hilo val of "<" or ">"');
          }

          if (pe(e, t, r)) return !1;

          for (var c = 0; c < t.set.length; ++c) {
            var l = t.set[c],
                f = null,
                p = null;
            if (l.forEach(function (e) {
              e.semver === se && (e = new ae(">=0.0.0")), f = f || e, p = p || e, o(e.semver, f.semver, r) ? f = e : a(e.semver, p.semver, r) && (p = e);
            }), f.operator === s || f.operator === u) return !1;
            if ((!p.operator || p.operator === s) && i(e, p.semver)) return !1;
            if (p.operator === u && a(e, p.semver)) return !1;
          }

          return !0;
        }

        ae.prototype.parse = function (e) {
          var t = this.loose ? s[z] : s[H],
              n = e.match(t);
          if (!n) throw new TypeError("Invalid comparator: " + e);
          this.operator = n[1], "=" === this.operator && (this.operator = ""), n[2] ? this.semver = new K(n[2], this.loose) : this.semver = se;
        }, ae.prototype.toString = function () {
          return this.value;
        }, ae.prototype.test = function (e) {
          return o("Comparator.test", e, this.loose), this.semver === se || ("string" == typeof e && (e = new K(e, this.loose)), ie(e, this.operator, this.semver, this.loose));
        }, ae.prototype.intersects = function (e, t) {
          if (!(e instanceof ae)) throw new TypeError("a Comparator is required");
          var n;
          if ("" === this.operator) return n = new ue(e.value, t), pe(this.value, n, t);
          if ("" === e.operator) return n = new ue(this.value, t), pe(e.semver, n, t);
          var r = !(">=" !== this.operator && ">" !== this.operator || ">=" !== e.operator && ">" !== e.operator),
              o = !("<=" !== this.operator && "<" !== this.operator || "<=" !== e.operator && "<" !== e.operator),
              i = this.semver.version === e.semver.version,
              a = !(">=" !== this.operator && "<=" !== this.operator || ">=" !== e.operator && "<=" !== e.operator),
              s = ie(this.semver, "<", e.semver, t) && (">=" === this.operator || ">" === this.operator) && ("<=" === e.operator || "<" === e.operator),
              u = ie(this.semver, ">", e.semver, t) && ("<=" === this.operator || "<" === this.operator) && (">=" === e.operator || ">" === e.operator);
          return r || o || i && a || s || u;
        }, t.Range = ue, ue.prototype.format = function () {
          return this.range = this.set.map(function (e) {
            return e.join(" ").trim();
          }).join("||").trim(), this.range;
        }, ue.prototype.toString = function () {
          return this.range;
        }, ue.prototype.parseRange = function (e) {
          var t = this.loose;
          e = e.trim(), o("range", e, t);
          var n = t ? s[G] : s[$];
          e = e.replace(n, le), o("hyphen replace", e), e = e.replace(s[V], "$1$2$3"), o("comparator trim", e, s[V]), e = (e = (e = e.replace(s[D], "$1~")).replace(s[B], "$1^")).split(/\s+/).join(" ");
          var r = t ? s[z] : s[H],
              i = e.split(" ").map(function (e) {
            return function (e, t) {
              return o("comp", e), e = function (e, t) {
                return e.trim().split(/\s+/).map(function (e) {
                  return function (e, t) {
                    o("caret", e, t);
                    var n = t ? s[U] : s[F];
                    return e.replace(n, function (t, n, r, i, a) {
                      var s;
                      return o("caret", e, t, n, r, i, a), ce(n) ? s = "" : ce(r) ? s = ">=" + n + ".0.0 <" + (+n + 1) + ".0.0" : ce(i) ? s = "0" === n ? ">=" + n + "." + r + ".0 <" + n + "." + (+r + 1) + ".0" : ">=" + n + "." + r + ".0 <" + (+n + 1) + ".0.0" : a ? (o("replaceCaret pr", a), "-" !== a.charAt(0) && (a = "-" + a), s = "0" === n ? "0" === r ? ">=" + n + "." + r + "." + i + a + " <" + n + "." + r + "." + (+i + 1) : ">=" + n + "." + r + "." + i + a + " <" + n + "." + (+r + 1) + ".0" : ">=" + n + "." + r + "." + i + a + " <" + (+n + 1) + ".0.0") : (o("no pr"), s = "0" === n ? "0" === r ? ">=" + n + "." + r + "." + i + " <" + n + "." + r + "." + (+i + 1) : ">=" + n + "." + r + "." + i + " <" + n + "." + (+r + 1) + ".0" : ">=" + n + "." + r + "." + i + " <" + (+n + 1) + ".0.0"), o("caret return", s), s;
                    });
                  }(e, t);
                }).join(" ");
              }(e, t), o("caret", e), e = function (e, t) {
                return e.trim().split(/\s+/).map(function (e) {
                  return function (e, t) {
                    var n = t ? s[L] : s[P];
                    return e.replace(n, function (t, n, r, i, a) {
                      var s;
                      return o("tilde", e, t, n, r, i, a), ce(n) ? s = "" : ce(r) ? s = ">=" + n + ".0.0 <" + (+n + 1) + ".0.0" : ce(i) ? s = ">=" + n + "." + r + ".0 <" + n + "." + (+r + 1) + ".0" : a ? (o("replaceTilde pr", a), "-" !== a.charAt(0) && (a = "-" + a), s = ">=" + n + "." + r + "." + i + a + " <" + n + "." + (+r + 1) + ".0") : s = ">=" + n + "." + r + "." + i + " <" + n + "." + (+r + 1) + ".0", o("tilde return", s), s;
                    });
                  }(e, t);
                }).join(" ");
              }(e, t), o("tildes", e), e = function (e, t) {
                return o("replaceXRanges", e, t), e.split(/\s+/).map(function (e) {
                  return function (e, t) {
                    e = e.trim();
                    var n = t ? s[R] : s[k];
                    return e.replace(n, function (t, n, r, i, a, s) {
                      o("xRange", e, t, n, r, i, a, s);
                      var u = ce(r),
                          c = u || ce(i),
                          l = c || ce(a),
                          f = l;
                      return "=" === n && f && (n = ""), u ? t = ">" === n || "<" === n ? "<0.0.0" : "*" : n && f ? (c && (i = 0), l && (a = 0), ">" === n ? (n = ">=", c ? (r = +r + 1, i = 0, a = 0) : l && (i = +i + 1, a = 0)) : "<=" === n && (n = "<", c ? r = +r + 1 : i = +i + 1), t = n + r + "." + i + "." + a) : c ? t = ">=" + r + ".0.0 <" + (+r + 1) + ".0.0" : l && (t = ">=" + r + "." + i + ".0 <" + r + "." + (+i + 1) + ".0"), o("xRange return", t), t;
                    });
                  }(e, t);
                }).join(" ");
              }(e, t), o("xrange", e), e = function (e, t) {
                return o("replaceStars", e, t), e.trim().replace(s[W], "");
              }(e, t), o("stars", e), e;
            }(e, t);
          }).join(" ").split(/\s+/);
          return this.loose && (i = i.filter(function (e) {
            return !!e.match(r);
          })), i = i.map(function (e) {
            return new ae(e, t);
          });
        }, ue.prototype.intersects = function (e, t) {
          if (!(e instanceof ue)) throw new TypeError("a Range is required");
          return this.set.some(function (n) {
            return n.every(function (n) {
              return e.set.some(function (e) {
                return e.every(function (e) {
                  return n.intersects(e, t);
                });
              });
            });
          });
        }, t.toComparators = function (e, t) {
          return new ue(e, t).set.map(function (e) {
            return e.map(function (e) {
              return e.value;
            }).join(" ").trim().split(" ");
          });
        }, ue.prototype.test = function (e) {
          if (!e) return !1;
          "string" == typeof e && (e = new K(e, this.loose));

          for (var t = 0; t < this.set.length; t++) {
            if (fe(this.set[t], e)) return !0;
          }

          return !1;
        }, t.satisfies = pe, t.maxSatisfying = function (e, t, n) {
          var r = null,
              o = null;

          try {
            var i = new ue(t, n);
          } catch (e) {
            return null;
          }

          return e.forEach(function (e) {
            i.test(e) && (r && -1 !== o.compare(e) || (o = new K(r = e, n)));
          }), r;
        }, t.minSatisfying = function (e, t, n) {
          var r = null,
              o = null;

          try {
            var i = new ue(t, n);
          } catch (e) {
            return null;
          }

          return e.forEach(function (e) {
            i.test(e) && (r && 1 !== o.compare(e) || (o = new K(r = e, n)));
          }), r;
        }, t.validRange = function (e, t) {
          try {
            return new ue(e, t).range || "*";
          } catch (e) {
            return null;
          }
        }, t.ltr = function (e, t, n) {
          return de(e, t, "<", n);
        }, t.gtr = function (e, t, n) {
          return de(e, t, ">", n);
        }, t.outside = de, t.prerelease = function (e, t) {
          var n = Y(e, t);
          return n && n.prerelease.length ? n.prerelease : null;
        }, t.intersects = function (e, t, n) {
          return e = new ue(e, n), t = new ue(t, n), e.intersects(t);
        }, t.coerce = function (e) {
          if (e instanceof K) return e;
          if ("string" != typeof e) return null;
          var t = e.match(s[j]);
          return null == t ? null : Y((t[1] || "0") + "." + (t[2] || "0") + "." + (t[3] || "0"));
        };
      }).call(this, n(6));
    }, function (e, t, n) {
      "use strict";

      (function (t) {
        /*!
         * The buffer module from node.js, for the browser.
         *
         * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
         * @license  MIT
         */
        function r(e) {
          return (r = "function" == typeof Symbol && "symbol" == typeof (typeof Symbol === "function" ? Symbol.iterator : "@@iterator") ? function (e) {
            return typeof e;
          } : function (e) {
            return e && "function" == typeof Symbol && e.constructor === Symbol && e !== (typeof Symbol === "function" ? Symbol.prototype : "@@prototype") ? "symbol" : typeof e;
          })(e);
        }

        function o(e, t) {
          if (e === t) return 0;

          for (var n = e.length, r = t.length, o = 0, i = Math.min(n, r); o < i; ++o) {
            if (e[o] !== t[o]) {
              n = e[o], r = t[o];
              break;
            }
          }

          return n < r ? -1 : r < n ? 1 : 0;
        }

        function i(e) {
          return t.Buffer && "function" == typeof t.Buffer.isBuffer ? t.Buffer.isBuffer(e) : !(null == e || !e._isBuffer);
        }

        var a = n(49),
            s = Object.prototype.hasOwnProperty,
            u = Array.prototype.slice,
            c = "foo" === function () {}.name;

        function l(e) {
          return Object.prototype.toString.call(e);
        }

        function f(e) {
          return !i(e) && "function" == typeof t.ArrayBuffer && ("function" == typeof ArrayBuffer.isView ? ArrayBuffer.isView(e) : !!e && (e instanceof DataView || !!(e.buffer && e.buffer instanceof ArrayBuffer)));
        }

        var p = e.exports = g,
            d = /\s*function\s+([^\(\s]*)\s*/;

        function h(e) {
          if (a.isFunction(e)) {
            if (c) return e.name;
            var t = e.toString().match(d);
            return t && t[1];
          }
        }

        function m(e, t) {
          return "string" == typeof e ? e.length < t ? e : e.slice(0, t) : e;
        }

        function y(e) {
          if (c || !a.isFunction(e)) return a.inspect(e);
          var t = h(e);
          return "[Function" + (t ? ": " + t : "") + "]";
        }

        function v(e, t, n, r, o) {
          throw new p.AssertionError({
            message: n,
            actual: e,
            expected: t,
            operator: r,
            stackStartFunction: o
          });
        }

        function g(e, t) {
          e || v(e, !0, t, "==", p.ok);
        }

        function b(e, t, n, s) {
          if (e === t) return !0;
          if (i(e) && i(t)) return 0 === o(e, t);
          if (a.isDate(e) && a.isDate(t)) return e.getTime() === t.getTime();
          if (a.isRegExp(e) && a.isRegExp(t)) return e.source === t.source && e.global === t.global && e.multiline === t.multiline && e.lastIndex === t.lastIndex && e.ignoreCase === t.ignoreCase;

          if (null !== e && "object" === r(e) || null !== t && "object" === r(t)) {
            if (f(e) && f(t) && l(e) === l(t) && !(e instanceof Float32Array || e instanceof Float64Array)) return 0 === o(new Uint8Array(e.buffer), new Uint8Array(t.buffer));
            if (i(e) !== i(t)) return !1;
            var c = (s = s || {
              actual: [],
              expected: []
            }).actual.indexOf(e);
            return -1 !== c && c === s.expected.indexOf(t) || (s.actual.push(e), s.expected.push(t), function (e, t, n, r) {
              if (null == e || null == t) return !1;
              if (a.isPrimitive(e) || a.isPrimitive(t)) return e === t;
              if (n && Object.getPrototypeOf(e) !== Object.getPrototypeOf(t)) return !1;

              var o = _(e),
                  i = _(t);

              if (o && !i || !o && i) return !1;
              if (o) return e = u.call(e), t = u.call(t), b(e, t, n);
              var s,
                  c,
                  l = E(e),
                  f = E(t);
              if (l.length !== f.length) return !1;

              for (l.sort(), f.sort(), c = l.length - 1; c >= 0; c--) {
                if (l[c] !== f[c]) return !1;
              }

              for (c = l.length - 1; c >= 0; c--) {
                if (s = l[c], !b(e[s], t[s], n, r)) return !1;
              }

              return !0;
            }(e, t, n, s));
          }

          return n ? e === t : e == t;
        }

        function _(e) {
          return "[object Arguments]" == Object.prototype.toString.call(e);
        }

        function w(e, t) {
          if (!e || !t) return !1;
          if ("[object RegExp]" == Object.prototype.toString.call(t)) return t.test(e);

          try {
            if (e instanceof t) return !0;
          } catch (e) {}

          return !Error.isPrototypeOf(t) && !0 === t.call({}, e);
        }

        function S(e, t, n, r) {
          var o;
          if ("function" != typeof t) throw new TypeError('"block" argument must be a function');
          "string" == typeof n && (r = n, n = null), o = function (e) {
            var t;

            try {
              e();
            } catch (e) {
              t = e;
            }

            return t;
          }(t), r = (n && n.name ? " (" + n.name + ")." : ".") + (r ? " " + r : "."), e && !o && v(o, n, "Missing expected exception" + r);
          var i = "string" == typeof r,
              s = !e && o && !n;
          if ((!e && a.isError(o) && i && w(o, n) || s) && v(o, n, "Got unwanted exception" + r), e && o && n && !w(o, n) || !e && o) throw o;
        }

        p.AssertionError = function (e) {
          var t;
          this.name = "AssertionError", this.actual = e.actual, this.expected = e.expected, this.operator = e.operator, e.message ? (this.message = e.message, this.generatedMessage = !1) : (this.message = m(y((t = this).actual), 128) + " " + t.operator + " " + m(y(t.expected), 128), this.generatedMessage = !0);
          var n = e.stackStartFunction || v;
          if (Error.captureStackTrace) Error.captureStackTrace(this, n);else {
            var r = new Error();

            if (r.stack) {
              var o = r.stack,
                  i = h(n),
                  a = o.indexOf("\n" + i);

              if (a >= 0) {
                var s = o.indexOf("\n", a + 1);
                o = o.substring(s + 1);
              }

              this.stack = o;
            }
          }
        }, a.inherits(p.AssertionError, Error), p.fail = v, p.ok = g, p.equal = function (e, t, n) {
          e != t && v(e, t, n, "==", p.equal);
        }, p.notEqual = function (e, t, n) {
          e == t && v(e, t, n, "!=", p.notEqual);
        }, p.deepEqual = function (e, t, n) {
          b(e, t, !1) || v(e, t, n, "deepEqual", p.deepEqual);
        }, p.deepStrictEqual = function (e, t, n) {
          b(e, t, !0) || v(e, t, n, "deepStrictEqual", p.deepStrictEqual);
        }, p.notDeepEqual = function (e, t, n) {
          b(e, t, !1) && v(e, t, n, "notDeepEqual", p.notDeepEqual);
        }, p.notDeepStrictEqual = function e(t, n, r) {
          b(t, n, !0) && v(t, n, r, "notDeepStrictEqual", e);
        }, p.strictEqual = function (e, t, n) {
          e !== t && v(e, t, n, "===", p.strictEqual);
        }, p.notStrictEqual = function (e, t, n) {
          e === t && v(e, t, n, "!==", p.notStrictEqual);
        }, p.throws = function (e, t, n) {
          S(!0, e, t, n);
        }, p.doesNotThrow = function (e, t, n) {
          S(!1, e, t, n);
        }, p.ifError = function (e) {
          if (e) throw e;
        };

        var E = Object.keys || function (e) {
          var t = [];

          for (var n in e) {
            s.call(e, n) && t.push(n);
          }

          return t;
        };
      }).call(this, n(7));
    }, function (e, t, n) {
      (function (e, r) {
        function o(e) {
          return (o = "function" == typeof Symbol && "symbol" == typeof (typeof Symbol === "function" ? Symbol.iterator : "@@iterator") ? function (e) {
            return typeof e;
          } : function (e) {
            return e && "function" == typeof Symbol && e.constructor === Symbol && e !== (typeof Symbol === "function" ? Symbol.prototype : "@@prototype") ? "symbol" : typeof e;
          })(e);
        }

        var i = /%[sdj%]/g;
        t.format = function (e) {
          if (!g(e)) {
            for (var t = [], n = 0; n < arguments.length; n++) {
              t.push(u(arguments[n]));
            }

            return t.join(" ");
          }

          n = 1;

          for (var r = arguments, o = r.length, a = String(e).replace(i, function (e) {
            if ("%%" === e) return "%";
            if (n >= o) return e;

            switch (e) {
              case "%s":
                return String(r[n++]);

              case "%d":
                return Number(r[n++]);

              case "%j":
                try {
                  return JSON.stringify(r[n++]);
                } catch (e) {
                  return "[Circular]";
                }

              default:
                return e;
            }
          }), s = r[n]; n < o; s = r[++n]) {
            y(s) || !w(s) ? a += " " + s : a += " " + u(s);
          }

          return a;
        }, t.deprecate = function (n, o) {
          if (b(e.process)) return function () {
            return t.deprecate(n, o).apply(this, arguments);
          };
          if (!0 === r.noDeprecation) return n;
          var i = !1;
          return function () {
            if (!i) {
              if (r.throwDeprecation) throw new Error(o);
              r.traceDeprecation ? console.trace(o) : console.error(o), i = !0;
            }

            return n.apply(this, arguments);
          };
        };
        var a,
            s = {};

        function u(e, n) {
          var r = {
            seen: [],
            stylize: l
          };
          return arguments.length >= 3 && (r.depth = arguments[2]), arguments.length >= 4 && (r.colors = arguments[3]), m(n) ? r.showHidden = n : n && t._extend(r, n), b(r.showHidden) && (r.showHidden = !1), b(r.depth) && (r.depth = 2), b(r.colors) && (r.colors = !1), b(r.customInspect) && (r.customInspect = !0), r.colors && (r.stylize = c), f(r, e, r.depth);
        }

        function c(e, t) {
          var n = u.styles[t];
          return n ? "[" + u.colors[n][0] + "m" + e + "[" + u.colors[n][1] + "m" : e;
        }

        function l(e, t) {
          return e;
        }

        function f(e, n, r) {
          if (e.customInspect && n && O(n.inspect) && n.inspect !== t.inspect && (!n.constructor || n.constructor.prototype !== n)) {
            var o = n.inspect(r, e);
            return g(o) || (o = f(e, o, r)), o;
          }

          var i = function (e, t) {
            if (b(t)) return e.stylize("undefined", "undefined");

            if (g(t)) {
              var n = "'" + JSON.stringify(t).replace(/^"|"$/g, "").replace(/'/g, "\\'").replace(/\\"/g, '"') + "'";
              return e.stylize(n, "string");
            }

            if (v(t)) return e.stylize("" + t, "number");
            if (m(t)) return e.stylize("" + t, "boolean");
            if (y(t)) return e.stylize("null", "null");
          }(e, n);

          if (i) return i;

          var a = Object.keys(n),
              s = function (e) {
            var t = {};
            return e.forEach(function (e, n) {
              t[e] = !0;
            }), t;
          }(a);

          if (e.showHidden && (a = Object.getOwnPropertyNames(n)), E(n) && (a.indexOf("message") >= 0 || a.indexOf("description") >= 0)) return p(n);

          if (0 === a.length) {
            if (O(n)) {
              var u = n.name ? ": " + n.name : "";
              return e.stylize("[Function" + u + "]", "special");
            }

            if (_(n)) return e.stylize(RegExp.prototype.toString.call(n), "regexp");
            if (S(n)) return e.stylize(Date.prototype.toString.call(n), "date");
            if (E(n)) return p(n);
          }

          var c,
              l = "",
              w = !1,
              x = ["{", "}"];
          (h(n) && (w = !0, x = ["[", "]"]), O(n)) && (l = " [Function" + (n.name ? ": " + n.name : "") + "]");
          return _(n) && (l = " " + RegExp.prototype.toString.call(n)), S(n) && (l = " " + Date.prototype.toUTCString.call(n)), E(n) && (l = " " + p(n)), 0 !== a.length || w && 0 != n.length ? r < 0 ? _(n) ? e.stylize(RegExp.prototype.toString.call(n), "regexp") : e.stylize("[Object]", "special") : (e.seen.push(n), c = w ? function (e, t, n, r, o) {
            for (var i = [], a = 0, s = t.length; a < s; ++a) {
              N(t, String(a)) ? i.push(d(e, t, n, r, String(a), !0)) : i.push("");
            }

            return o.forEach(function (o) {
              o.match(/^\d+$/) || i.push(d(e, t, n, r, o, !0));
            }), i;
          }(e, n, r, s, a) : a.map(function (t) {
            return d(e, n, r, s, t, w);
          }), e.seen.pop(), function (e, t, n) {
            if (e.reduce(function (e, t) {
              return 0, t.indexOf("\n") >= 0 && 0, e + t.replace(/\u001b\[\d\d?m/g, "").length + 1;
            }, 0) > 60) return n[0] + ("" === t ? "" : t + "\n ") + " " + e.join(",\n  ") + " " + n[1];
            return n[0] + t + " " + e.join(", ") + " " + n[1];
          }(c, l, x)) : x[0] + l + x[1];
        }

        function p(e) {
          return "[" + Error.prototype.toString.call(e) + "]";
        }

        function d(e, t, n, r, o, i) {
          var a, s, u;

          if ((u = Object.getOwnPropertyDescriptor(t, o) || {
            value: t[o]
          }).get ? s = u.set ? e.stylize("[Getter/Setter]", "special") : e.stylize("[Getter]", "special") : u.set && (s = e.stylize("[Setter]", "special")), N(r, o) || (a = "[" + o + "]"), s || (e.seen.indexOf(u.value) < 0 ? (s = y(n) ? f(e, u.value, null) : f(e, u.value, n - 1)).indexOf("\n") > -1 && (s = i ? s.split("\n").map(function (e) {
            return "  " + e;
          }).join("\n").substr(2) : "\n" + s.split("\n").map(function (e) {
            return "   " + e;
          }).join("\n")) : s = e.stylize("[Circular]", "special")), b(a)) {
            if (i && o.match(/^\d+$/)) return s;
            (a = JSON.stringify("" + o)).match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/) ? (a = a.substr(1, a.length - 2), a = e.stylize(a, "name")) : (a = a.replace(/'/g, "\\'").replace(/\\"/g, '"').replace(/(^"|"$)/g, "'"), a = e.stylize(a, "string"));
          }

          return a + ": " + s;
        }

        function h(e) {
          return Array.isArray(e);
        }

        function m(e) {
          return "boolean" == typeof e;
        }

        function y(e) {
          return null === e;
        }

        function v(e) {
          return "number" == typeof e;
        }

        function g(e) {
          return "string" == typeof e;
        }

        function b(e) {
          return void 0 === e;
        }

        function _(e) {
          return w(e) && "[object RegExp]" === x(e);
        }

        function w(e) {
          return "object" === o(e) && null !== e;
        }

        function S(e) {
          return w(e) && "[object Date]" === x(e);
        }

        function E(e) {
          return w(e) && ("[object Error]" === x(e) || e instanceof Error);
        }

        function O(e) {
          return "function" == typeof e;
        }

        function x(e) {
          return Object.prototype.toString.call(e);
        }

        function C(e) {
          return e < 10 ? "0" + e.toString(10) : e.toString(10);
        }

        t.debuglog = function (e) {
          if (b(a) && (a = r.env.NODE_DEBUG || ""), e = e.toUpperCase(), !s[e]) if (new RegExp("\\b" + e + "\\b", "i").test(a)) {
            var n = r.pid;

            s[e] = function () {
              var r = t.format.apply(t, arguments);
              console.error("%s %d: %s", e, n, r);
            };
          } else s[e] = function () {};
          return s[e];
        }, t.inspect = u, u.colors = {
          bold: [1, 22],
          italic: [3, 23],
          underline: [4, 24],
          inverse: [7, 27],
          white: [37, 39],
          grey: [90, 39],
          black: [30, 39],
          blue: [34, 39],
          cyan: [36, 39],
          green: [32, 39],
          magenta: [35, 39],
          red: [31, 39],
          yellow: [33, 39]
        }, u.styles = {
          special: "cyan",
          number: "yellow",
          boolean: "yellow",
          undefined: "grey",
          null: "bold",
          string: "green",
          date: "magenta",
          regexp: "red"
        }, t.isArray = h, t.isBoolean = m, t.isNull = y, t.isNullOrUndefined = function (e) {
          return null == e;
        }, t.isNumber = v, t.isString = g, t.isSymbol = function (e) {
          return "symbol" === o(e);
        }, t.isUndefined = b, t.isRegExp = _, t.isObject = w, t.isDate = S, t.isError = E, t.isFunction = O, t.isPrimitive = function (e) {
          return null === e || "boolean" == typeof e || "number" == typeof e || "string" == typeof e || "symbol" === o(e) || void 0 === e;
        }, t.isBuffer = n(50);
        var I = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];

        function N(e, t) {
          return Object.prototype.hasOwnProperty.call(e, t);
        }

        t.log = function () {
          var e, n;
          console.log("%s - %s", (e = new Date(), n = [C(e.getHours()), C(e.getMinutes()), C(e.getSeconds())].join(":"), [e.getDate(), I[e.getMonth()], n].join(" ")), t.format.apply(t, arguments));
        }, t.inherits = n(51), t._extend = function (e, t) {
          if (!t || !w(t)) return e;

          for (var n = Object.keys(t), r = n.length; r--;) {
            e[n[r]] = t[n[r]];
          }

          return e;
        };
      }).call(this, n(7), n(6));
    }, function (e, t) {
      function n(e) {
        return (n = "function" == typeof Symbol && "symbol" == typeof (typeof Symbol === "function" ? Symbol.iterator : "@@iterator") ? function (e) {
          return typeof e;
        } : function (e) {
          return e && "function" == typeof Symbol && e.constructor === Symbol && e !== (typeof Symbol === "function" ? Symbol.prototype : "@@prototype") ? "symbol" : typeof e;
        })(e);
      }

      e.exports = function (e) {
        return e && "object" === n(e) && "function" == typeof e.copy && "function" == typeof e.fill && "function" == typeof e.readUInt8;
      };
    }, function (e, t) {
      "function" == typeof Object.create ? e.exports = function (e, t) {
        e.super_ = t, e.prototype = Object.create(t.prototype, {
          constructor: {
            value: e,
            enumerable: !1,
            writable: !0,
            configurable: !0
          }
        });
      } : e.exports = function (e, t) {
        e.super_ = t;

        var n = function n() {};

        n.prototype = t.prototype, e.prototype = new n(), e.prototype.constructor = e;
      };
    }, function (e, t, n) {
      "use strict";

      function r(e) {
        return (r = "function" == typeof Symbol && "symbol" == typeof (typeof Symbol === "function" ? Symbol.iterator : "@@iterator") ? function (e) {
          return typeof e;
        } : function (e) {
          return e && "function" == typeof Symbol && e.constructor === Symbol && e !== (typeof Symbol === "function" ? Symbol.prototype : "@@prototype") ? "symbol" : typeof e;
        })(e);
      }

      function o(e, t, n) {
        return t in e ? Object.defineProperty(e, t, {
          value: n,
          enumerable: !0,
          configurable: !0,
          writable: !0
        }) : e[t] = n, e;
      }

      var i = n(53),
          a = {};

      e.exports = function (e, t, n) {
        e.onCall("rn-style:get", function (e) {
          var r = t.elementData.get(e);
          return r && r.props ? n(r.props.style) : null;
        }), e.on("rn-style:measure", function (r) {
          u(t, e, n, r);
        }), e.on("rn-style:rename", function (i) {
          var s = i.id,
              l = i.oldName,
              f = i.newName,
              p = i.val;
          !function (e, t, n, i, s) {
            var u,
                l = e.elementData.get(t),
                f = i ? (o(u = {}, n, void 0), o(u, i, s), u) : o({}, n, void 0);

            if (l && l.updater && "function" == typeof l.updater.setInProps) {
              var p,
                  d = l && l.props && l.props.style;

              if (Array.isArray(d)) {
                var h = d.length - 1;
                "object" !== r(d[h]) || Array.isArray(d[h]) ? (d = d.concat([f]), l.updater.setInProps(["style"], d)) : (delete (p = c(d[h]))[n], i ? p[i] = s : p[n] = void 0, l.updater.setInProps(["style", h], p));
              } else "object" === r(d) ? (delete (p = c(d))[n], i ? p[i] = s : p[n] = void 0, l.updater.setInProps(["style"], p)) : (d = [d, f], l.updater.setInProps(["style"], d));
            } else {
              if (!l || !l.updater || "function" != typeof l.updater.setNativeProps) return;
              a[t] ? _extends(a[t], f) : a[t] = f, l.updater.setNativeProps({
                style: f
              });
            }

            e.emit("hideHighlight");
          }(t, s, l, f, p), setTimeout(function () {
            return u(t, e, n, s);
          });
        }), e.on("rn-style:set", function (i) {
          var s = i.id,
              c = i.attr,
              l = i.val;
          !function (e, t, n, i) {
            var s = e.elementData.get(t),
                u = o({}, n, i);

            if (s && s.updater && "function" == typeof s.updater.setInProps) {
              var c = s.props && s.props.style;

              if (Array.isArray(c)) {
                var l = c.length - 1;
                "object" !== r(c[l]) || Array.isArray(c[l]) ? (c = c.concat([u]), s.updater.setInProps(["style"], c)) : s.updater.setInProps(["style", l, n], i);
              } else c = [c, u], s.updater.setInProps(["style"], c);
            } else {
              if (!s || !s.updater || "function" != typeof s.updater.setNativeProps) return;
              a[t] ? _extends(a[t], u) : a[t] = u, s.updater.setNativeProps({
                style: u
              });
            }

            e.emit("hideHighlight");
          }(t, s, c, l), setTimeout(function () {
            return u(t, e, n, s);
          });
        });
      };

      var s = {
        top: 0,
        left: 0,
        right: 0,
        bottom: 0
      };

      function u(e, t, n, r) {
        var o = e.elementData.get(r);

        if (o && o.props) {
          var u = n(o.props.style);
          a[r] && (u = _extends({}, u, a[r]));
          var c = o.publicInstance;
          c && c.measure ? c.measure(function (e, n, r, o, a, c) {
            if ("number" == typeof e) {
              var l = u && i("margin", u) || s,
                  f = u && i("padding", u) || s;
              t.send("rn-style:measure", {
                style: u,
                measuredLayout: {
                  x: e,
                  y: n,
                  width: r,
                  height: o,
                  left: a,
                  top: c,
                  margin: l,
                  padding: f
                }
              });
            } else t.send("rn-style:measure", {
              style: u
            });
          }) : t.send("rn-style:measure", {
            style: u
          });
        } else t.send("rn-style:measure", {});
      }

      function c(e) {
        var t = {};

        for (var n in e) {
          t[n] = e[n];
        }

        return t;
      }
    }, function (e, t) {
      e.exports = function (e, t) {
        var n = {},
            r = ["top", "left", "bottom", "right"],
            o = !1;
        return r.forEach(function (r) {
          n[r] = t[e] || 0;
        }), t[e] && (o = !0), t[e + "Vertical"] && (n.top = n.bottom = t[e + "Vertical"], o = !0), t[e + "Horizontal"] && (n.left = n.right = t[e + "Horizontal"], o = !0), r.forEach(function (r) {
          var i,
              a = t[e + (i = r, i[0].toUpperCase() + i.slice(1))];
          a && (n[r] = a, o = !0);
        }), o ? n : null;
      };
    }, function (e, t, n) {
      var r, o, i;
      !function (n, a) {
        "use strict";

        o = [], void 0 === (i = "function" == typeof (r = function r() {
          function e(e) {
            return !isNaN(parseFloat(e)) && isFinite(e);
          }

          function t(e) {
            return e.charAt(0).toUpperCase() + e.substring(1);
          }

          function n(e) {
            return function () {
              return this[e];
            };
          }

          var r = ["isConstructor", "isEval", "isNative", "isToplevel"],
              o = ["columnNumber", "lineNumber"],
              i = ["fileName", "functionName", "source"],
              a = r.concat(o, i, ["args"]);

          function s(e) {
            if (e instanceof Object) for (var n = 0; n < a.length; n++) {
              e.hasOwnProperty(a[n]) && void 0 !== e[a[n]] && this["set" + t(a[n])](e[a[n]]);
            }
          }

          s.prototype = {
            getArgs: function getArgs() {
              return this.args;
            },
            setArgs: function setArgs(e) {
              if ("[object Array]" !== Object.prototype.toString.call(e)) throw new TypeError("Args must be an Array");
              this.args = e;
            },
            getEvalOrigin: function getEvalOrigin() {
              return this.evalOrigin;
            },
            setEvalOrigin: function setEvalOrigin(e) {
              if (e instanceof s) this.evalOrigin = e;else {
                if (!(e instanceof Object)) throw new TypeError("Eval Origin must be an Object or StackFrame");
                this.evalOrigin = new s(e);
              }
            },
            toString: function toString() {
              var t = this.getFunctionName() || "{anonymous}",
                  n = "(" + (this.getArgs() || []).join(",") + ")",
                  r = this.getFileName() ? "@" + this.getFileName() : "",
                  o = e(this.getLineNumber()) ? ":" + this.getLineNumber() : "",
                  i = e(this.getColumnNumber()) ? ":" + this.getColumnNumber() : "";
              return t + n + r + o + i;
            }
          };

          for (var u = 0; u < r.length; u++) {
            s.prototype["get" + t(r[u])] = n(r[u]), s.prototype["set" + t(r[u])] = function (e) {
              return function (t) {
                this[e] = Boolean(t);
              };
            }(r[u]);
          }

          for (var c = 0; c < o.length; c++) {
            s.prototype["get" + t(o[c])] = n(o[c]), s.prototype["set" + t(o[c])] = function (t) {
              return function (n) {
                if (!e(n)) throw new TypeError(t + " must be a Number");
                this[t] = Number(n);
              };
            }(o[c]);
          }

          for (var l = 0; l < i.length; l++) {
            s.prototype["get" + t(i[l])] = n(i[l]), s.prototype["set" + t(i[l])] = function (e) {
              return function (t) {
                this[e] = String(t);
              };
            }(i[l]);
          }

          return s;
        }) ? r.apply(t, o) : r) || (e.exports = i);
      }();
    }, function (e, t, n) {
      "use strict";

      var r = function r() {};

      e.exports = function (e, t, n) {
        var o = function o() {
          var n = !1;
          t.roots.forEach(function (e) {
            t.internalInstancesById.get(e).hasOwnProperty("treeBaseDuration") && (n = !0);
          }), e.call("profiler:update", [n], r);
        };

        t.on("root", o), t.on("rootUnmounted", o), o();
      };
    }, function (e, t, n) {
      "use strict";

      var r = n(57);

      e.exports = function (e) {
        var t = new r(window, function (t) {
          e.selectFromDOMNode(t);
        });
        e.on("highlight", function (e) {
          return t.highlight(e.node, e.name);
        }), e.on("highlightMany", function (e) {
          return t.highlightMany(e);
        }), e.on("hideHighlight", function () {
          return t.hideHighlight();
        }), e.on("refreshMultiOverlay", function () {
          return t.refreshMultiOverlay();
        }), e.on("startInspecting", function () {
          return t.startInspecting();
        }), e.on("stopInspecting", function () {
          return t.stopInspecting();
        }), e.on("shutdown", function () {
          t.remove();
        });
      };
    }, function (e, t, n) {
      "use strict";

      function r(e, t) {
        for (var n = 0; n < t.length; n++) {
          var r = t[n];
          r.enumerable = r.enumerable || !1, r.configurable = !0, "value" in r && (r.writable = !0), Object.defineProperty(e, r.key, r);
        }
      }

      var o = n(58),
          i = n(60),
          a = function () {
        function e(t, n) {
          !function (e, t) {
            if (!(e instanceof t)) throw new TypeError("Cannot call a class as a function");
          }(this, e), this._win = t, this._onSelect = n, this._overlay = null, this._multiOverlay = null, this._subs = [];
        }

        var t, n, a;
        return t = e, (n = [{
          key: "startInspecting",
          value: function value() {
            this._inspecting = !0, this._subs = [s(this._win, "mouseover", this.onHover.bind(this)), s(this._win, "mousedown", this.onMouseDown.bind(this)), s(this._win, "click", this.onClick.bind(this))];
          }
        }, {
          key: "stopInspecting",
          value: function value() {
            this._subs.forEach(function (e) {
              return e();
            }), this.hideHighlight();
          }
        }, {
          key: "remove",
          value: function value() {
            this.stopInspecting(), this._button && this._button.parentNode && this._button.parentNode.removeChild(this._button);
          }
        }, {
          key: "highlight",
          value: function value(e, t) {
            this.removeMultiOverlay(), e.nodeType !== Node.COMMENT_NODE && (this._overlay || (this._overlay = new o(this._win)), this._overlay.inspect(e, t));
          }
        }, {
          key: "highlightMany",
          value: function value(e) {
            this.removeOverlay(), this._multiOverlay || (this._multiOverlay = new i(this._win)), this._multiOverlay.highlightMany(e);
          }
        }, {
          key: "hideHighlight",
          value: function value() {
            this._inspecting = !1, this.removeOverlay(), this.removeMultiOverlay();
          }
        }, {
          key: "refreshMultiOverlay",
          value: function value() {
            this._multiOverlay && this._multiOverlay.refresh();
          }
        }, {
          key: "removeOverlay",
          value: function value() {
            this._overlay && (this._overlay.remove(), this._overlay = null);
          }
        }, {
          key: "removeMultiOverlay",
          value: function value() {
            this._multiOverlay && (this._multiOverlay.remove(), this._multiOverlay = null);
          }
        }, {
          key: "onMouseDown",
          value: function value(e) {
            this._inspecting && (e.preventDefault(), e.stopPropagation(), e.cancelBubble = !0, this._onSelect(e.target));
          }
        }, {
          key: "onClick",
          value: function value(e) {
            this._inspecting && (this._subs.forEach(function (e) {
              return e();
            }), e.preventDefault(), e.stopPropagation(), e.cancelBubble = !0, this.hideHighlight());
          }
        }, {
          key: "onHover",
          value: function value(e) {
            this._inspecting && (e.preventDefault(), e.stopPropagation(), e.cancelBubble = !0, this.highlight(e.target));
          }
        }, {
          key: "injectButton",
          value: function value() {
            var e;
            this._button = ((e = window.document.createElement("button")).innerHTML = "&#128269;", e.style.backgroundColor = "transparent", e.style.border = "none", e.style.outline = "none", e.style.cursor = "pointer", e.style.position = "fixed", e.style.bottom = "10px", e.style.right = "10px", e.style.fontSize = "30px", e.style.zIndex = 1e7, e), this._button.onclick = this.startInspecting.bind(this), this._win.document.body.appendChild(this._button);
          }
        }]) && r(t.prototype, n), a && r(t, a), e;
      }();

      function s(e, t, n) {
        return e.addEventListener(t, n, !0), function () {
          return e.removeEventListener(t, n, !0);
        };
      }

      e.exports = a;
    }, function (e, t, n) {
      "use strict";

      function r(e, t) {
        for (var n = 0; n < t.length; n++) {
          var r = t[n];
          r.enumerable = r.enumerable || !1, r.configurable = !0, "value" in r && (r.writable = !0), Object.defineProperty(e, r.key, r);
        }
      }

      var o = n(1),
          i = n(59).monospace,
          a = function () {
        function e(t) {
          !function (e, t) {
            if (!(e instanceof t)) throw new TypeError("Cannot call a class as a function");
          }(this, e);
          var n = t.document;
          this.win = t, this.container = n.createElement("div"), this.node = n.createElement("div"), this.border = n.createElement("div"), this.padding = n.createElement("div"), this.content = n.createElement("div"), this.border.style.borderColor = d.border, this.padding.style.borderColor = d.padding, this.content.style.backgroundColor = d.background, o(this.node.style, {
            borderColor: d.margin,
            pointerEvents: "none",
            position: "fixed"
          }), this.tip = n.createElement("div"), o(this.tip.style, {
            backgroundColor: "#333740",
            borderRadius: "2px",
            fontFamily: i.family,
            fontWeight: "bold",
            padding: "3px 5px",
            position: "fixed",
            fontSize: i.sizes.normal + "px"
          }), this.nameSpan = n.createElement("span"), this.tip.appendChild(this.nameSpan), o(this.nameSpan.style, {
            color: "#ee78e6",
            borderRight: "1px solid #aaaaaa",
            paddingRight: "0.5rem",
            marginRight: "0.5rem"
          }), this.dimSpan = n.createElement("span"), this.tip.appendChild(this.dimSpan), o(this.dimSpan.style, {
            color: "#d7d7d7"
          }), this.container.style.zIndex = 1e7, this.node.style.zIndex = 1e7, this.tip.style.zIndex = 1e7, this.container.appendChild(this.node), this.container.appendChild(this.tip), this.node.appendChild(this.border), this.border.appendChild(this.padding), this.padding.appendChild(this.content), n.body.appendChild(this.container);
        }

        var t, n, a;
        return t = e, (n = [{
          key: "remove",
          value: function value() {
            this.container.parentNode && this.container.parentNode.removeChild(this.container);
          }
        }, {
          key: "inspect",
          value: function value(e, t) {
            if (e.nodeType === Node.ELEMENT_NODE) {
              var n = function (e, t) {
                var n = c(e);

                if (n && n !== t) {
                  for (var r = [e.getBoundingClientRect()], o = n, i = !1; o;) {
                    var a = l(o);
                    if (r.push(a), o = c(o), i) break;
                    o && u(o) === t && (i = !0);
                  }

                  return f(r);
                }

                return e.getBoundingClientRect();
              }(e, this.win),
                  r = s(e);

              p(r, "margin", this.node), p(r, "border", this.border), p(r, "padding", this.padding), o(this.content.style, {
                height: n.height - r.borderTop - r.borderBottom - r.paddingTop - r.paddingBottom + "px",
                width: n.width - r.borderLeft - r.borderRight - r.paddingLeft - r.paddingRight + "px"
              }), o(this.node.style, {
                top: n.top - r.marginTop + "px",
                left: n.left - r.marginLeft + "px"
              }), this.nameSpan.textContent = t || e.nodeName.toLowerCase(), this.dimSpan.textContent = n.width + "px × " + n.height + "px";

              var i = function (e, t) {
                var n;
                n = e.top + e.height + 20 <= t.innerHeight ? e.top + e.height < 0 ? 5 : e.top + e.height + 5 : e.top - 20 <= t.innerHeight ? e.top - 20 - 5 < 5 ? 5 : e.top - 20 - 5 : t.innerHeight - 20 - 5;
                if (n += "px", e.left < 0) return {
                  top: n,
                  left: 5
                };
                if (e.left + 200 > t.innerWidth) return {
                  top: n,
                  right: 5
                };
                return {
                  top: n,
                  left: e.left + 5 + "px"
                };
              }({
                top: n.top - r.marginTop,
                left: n.left - r.marginLeft,
                height: n.height + r.marginTop + r.marginBottom,
                width: n.width + r.marginLeft + r.marginRight
              }, this.win);

              o(this.tip.style, i);
            }
          }
        }]) && r(t.prototype, n), a && r(t, a), e;
      }();

      function s(e) {
        var t = window.getComputedStyle(e);
        return {
          borderLeft: +t.borderLeftWidth.match(/[0-9]*/)[0],
          borderRight: +t.borderRightWidth.match(/[0-9]*/)[0],
          borderTop: +t.borderTopWidth.match(/[0-9]*/)[0],
          borderBottom: +t.borderBottomWidth.match(/[0-9]*/)[0],
          marginLeft: +t.marginLeft.match(/[0-9]*/)[0],
          marginRight: +t.marginRight.match(/[0-9]*/)[0],
          marginTop: +t.marginTop.match(/[0-9]*/)[0],
          marginBottom: +t.marginBottom.match(/[0-9]*/)[0],
          paddingLeft: +t.paddingLeft.match(/[0-9]*/)[0],
          paddingRight: +t.paddingRight.match(/[0-9]*/)[0],
          paddingTop: +t.paddingTop.match(/[0-9]*/)[0],
          paddingBottom: +t.paddingBottom.match(/[0-9]*/)[0]
        };
      }

      function u(e) {
        return e.ownerDocument ? e.ownerDocument.defaultView : null;
      }

      function c(e) {
        var t = u(e);
        return t ? t.frameElement : null;
      }

      function l(e) {
        var t = s(e);
        return f([e.getBoundingClientRect(), {
          top: t.borderTop,
          left: t.borderLeft,
          bottom: t.borderBottom,
          right: t.borderRight,
          width: 0,
          height: 0
        }]);
      }

      function f(e) {
        return e.reduce(function (e, t) {
          return null == e ? t : {
            top: e.top + t.top,
            left: e.left + t.left,
            width: e.width,
            height: e.height,
            bottom: e.bottom + t.bottom,
            right: e.right + t.right
          };
        });
      }

      function p(e, t, n) {
        o(n.style, {
          borderTopWidth: e[t + "Top"] + "px",
          borderLeftWidth: e[t + "Left"] + "px",
          borderRightWidth: e[t + "Right"] + "px",
          borderBottomWidth: e[t + "Bottom"] + "px",
          borderStyle: "solid"
        });
      }

      var d = {
        background: "rgba(120, 170, 210, 0.7)",
        padding: "rgba(77, 200, 0, 0.3)",
        margin: "rgba(255, 155, 0, 0.3)",
        border: "rgba(255, 200, 50, 0.3)"
      };
      e.exports = a;
    }, function (e, t, n) {
      "use strict";

      e.exports = {
        monospace: {
          family: "Menlo, Consolas, monospace",
          sizes: {
            normal: 11,
            large: 14
          }
        },
        sansSerif: {
          family: '"Helvetica Neue", "Lucida Grande", -apple-system, BlinkMacSystemFont, "Segoe UI", Ubuntu, sans-serif',
          sizes: {
            small: 10,
            normal: 12,
            large: 14
          }
        }
      };
    }, function (e, t, n) {
      "use strict";

      function r(e, t) {
        for (var n = 0; n < t.length; n++) {
          var r = t[n];
          r.enumerable = r.enumerable || !1, r.configurable = !0, "value" in r && (r.writable = !0), Object.defineProperty(e, r.key, r);
        }
      }

      var o = n(1),
          i = function () {
        function e(t) {
          !function (e, t) {
            if (!(e instanceof t)) throw new TypeError("Cannot call a class as a function");
          }(this, e), this.win = t;
          var n = t.document;
          this.container = n.createElement("div"), n.body.appendChild(this.container), this._currentNodes = null;
        }

        var t, n, i;
        return t = e, (n = [{
          key: "highlightMany",
          value: function value(e) {
            var t = this;
            this._currentNodes = e, this.container.innerHTML = "", e.forEach(function (e) {
              var n = t.win.document.createElement("div");

              if ("function" == typeof e.getBoundingClientRect) {
                var r = e.getBoundingClientRect();
                r.bottom < 0 || r.top > window.innerHeight || (o(n.style, {
                  top: r.top + "px",
                  left: r.left + "px",
                  width: r.width + "px",
                  height: r.height + "px",
                  border: "2px dotted rgba(200, 100, 100, .8)",
                  boxSizing: "border-box",
                  backgroundColor: "rgba(200, 100, 100, .2)",
                  position: "fixed",
                  zIndex: 1e7,
                  pointerEvents: "none"
                }), t.container.appendChild(n));
              }
            });
          }
        }, {
          key: "refresh",
          value: function value() {
            this._currentNodes && this.highlightMany(this._currentNodes);
          }
        }, {
          key: "remove",
          value: function value() {
            this.container.parentNode && (this.container.parentNode.removeChild(this.container), this._currentNodes = null);
          }
        }]) && r(t.prototype, n), i && r(t, i), e;
      }();

      e.exports = i;
    }, function (e, t, n) {
      "use strict";

      n.r(t);
      var r = n(0),
          o = n.n(r);

      function i(e) {
        return (i = "function" == typeof Symbol && "symbol" == typeof (typeof Symbol === "function" ? Symbol.iterator : "@@iterator") ? function (e) {
          return typeof e;
        } : function (e) {
          return e && "function" == typeof Symbol && e.constructor === Symbol && e !== (typeof Symbol === "function" ? Symbol.prototype : "@@prototype") ? "symbol" : typeof e;
        })(e);
      }

      var a = 10,
          s = 11,
          u = 0,
          c = 15,
          l = [],
          f = null;

      function p() {
        if (null === f) {
          var e,
              t = new Map();

          try {
            m.useContext({
              _currentValue: null
            }), m.useState(null), m.useReducer(function (e, t) {
              return e;
            }, null), m.useRef(null), m.useLayoutEffect(function () {}), m.useEffect(function () {}), m.useImperativeHandle(void 0, function () {
              return null;
            }), m.useCallback(function () {}), m.useMemo(function () {
              return null;
            }), m.useDebugValue(null);
          } finally {
            e = l, l = [];
          }

          for (var n = 0; n < e.length; n++) {
            var r = e[n];
            t.set(r.primitive, o.a.parse(r.stackError));
          }

          f = t;
        }

        return f;
      }

      var d = null;

      function h() {
        var e = d;
        return null !== e && (d = e.next), e;
      }

      var m = {
        readContext: function readContext(e, t) {
          return e._currentValue;
        },
        useCallback: function useCallback(e, t) {
          var n = h();
          return l.push({
            primitive: "Callback",
            stackError: new Error(),
            value: null !== n ? n.memoizedState[0] : e
          }), e;
        },
        useContext: function useContext(e, t) {
          return l.push({
            primitive: "Context",
            stackError: new Error(),
            value: e._currentValue
          }), e._currentValue;
        },
        useEffect: function useEffect(e, t) {
          h(), l.push({
            primitive: "Effect",
            stackError: new Error(),
            value: e
          });
        },
        useImperativeHandle: function useImperativeHandle(e, t, n) {
          h();
          var r = void 0;
          null !== e && "object" === i(e) && (r = e.current), l.push({
            primitive: "ImperativeHandle",
            stackError: new Error(),
            value: r
          });
        },
        useDebugValue: function useDebugValue(e, t) {
          l.push({
            primitive: "DebugValue",
            stackError: new Error(),
            value: "function" == typeof t ? t(e) : e
          });
        },
        useLayoutEffect: function useLayoutEffect(e, t) {
          h(), l.push({
            primitive: "LayoutEffect",
            stackError: new Error(),
            value: e
          });
        },
        useMemo: function useMemo(e, t) {
          var n = h(),
              r = null !== n ? n.memoizedState[0] : e();
          return l.push({
            primitive: "Memo",
            stackError: new Error(),
            value: r
          }), r;
        },
        useReducer: function useReducer(e, t, n) {
          var r = h(),
              o = null !== r ? r.memoizedState : t;
          return l.push({
            primitive: "Reducer",
            stackError: new Error(),
            value: o
          }), [o, function (e) {}];
        },
        useRef: function useRef(e) {
          var t = h(),
              n = null !== t ? t.memoizedState : {
            current: e
          };
          return l.push({
            primitive: "Ref",
            stackError: new Error(),
            value: n.current
          }), n;
        },
        useState: function useState(e) {
          var t = h(),
              n = null !== t ? t.memoizedState : "function" == typeof e ? e() : e;
          return l.push({
            primitive: "State",
            stackError: new Error(),
            value: n
          }), [n, function (e) {}];
        }
      },
          y = 0;

      function v(e, t, n) {
        var r = t[n].source;

        e: for (var o = 0; o < e.length; o++) {
          if (e[o].source === r) {
            for (var i = n + 1, a = o + 1; i < t.length && a < e.length; i++, a++) {
              if (e[a].source !== t[i].source) continue e;
            }

            return o;
          }
        }

        return -1;
      }

      function g(e, t) {
        if (!e) return !1;
        var n = "use" + t;
        return !(e.length < n.length) && e.lastIndexOf(n) === e.length - n.length;
      }

      function b(e, t) {
        var n = o.a.parse(t.stackError),
            r = function (e, t) {
          var n = v(t, e, y);
          if (-1 !== n) return n;

          for (var r = 0; r < e.length && r < 5; r++) {
            if (-1 !== (n = v(t, e, r))) return y = r, n;
          }

          return -1;
        }(e, n),
            i = function (e, t) {
          var n = p().get(t.primitive);
          if (void 0 === n) return -1;

          for (var r = 0; r < n.length && r < e.length; r++) {
            if (n[r].source !== e[r].source) return r < e.length - 1 && g(e[r].functionName, t.primitive) && r++, r < e.length - 1 && g(e[r].functionName, t.primitive) && r++, r;
          }

          return -1;
        }(n, t);

        return -1 === r || -1 === i || r - i < 2 ? null : n.slice(i, r - 1);
      }

      function _(e) {
        if (!e) return "";
        var t = e.lastIndexOf(".");
        return -1 === t && (t = 0), "use" === e.substr(t, 3) && (t += 3), e.substr(t);
      }

      function w(e, t) {
        for (var n = [], r = null, o = n, i = [], a = 0; a < t.length; a++) {
          var s = t[a],
              u = b(e, s);

          if (null !== u) {
            var c = 0;

            if (null !== r) {
              for (; c < u.length && c < r.length;) {
                if (u[u.length - c - 1].source !== r[r.length - c - 1].source) break;
                c++;
              }

              for (var l = r.length - 1; l > c; l--) {
                o = i.pop();
              }
            }

            for (var f = u.length - c - 1; f >= 1; f--) {
              var p = [];
              o.push({
                name: _(u[f - 1].functionName),
                value: void 0,
                subHooks: p
              }), i.push(o), o = p;
            }

            r = u;
          }

          o.push({
            name: s.primitive,
            value: s.value,
            subHooks: []
          });
        }

        return function e(t, n) {
          var r = [];

          for (var o = 0; o < t.length; o++) {
            var i = t[o];
            "DebugValue" === i.name && 0 === i.subHooks.length ? (t.splice(o, 1), o--, r.push(i)) : e(i.subHooks, i);
          }

          null !== n && (1 === r.length ? n.value = r[0].value : r.length > 1 && (n.value = r.map(function (e) {
            var t = e.value;
            return t;
          })));
        }(n, null), n;
      }

      function S(e, t) {
        if (e.tag !== u && e.tag !== c && e.tag !== s) throw new Error("Unknown Fiber. Needs to be a function component to inspect hooks.");
        p();
        var n = e.type,
            r = e.memoizedProps;
        n !== e.elementType && (r = function (e, t) {
          if (e && e.defaultProps) {
            var n = _extends({}, t),
                r = e.defaultProps;

            for (var o in r) {
              void 0 === n[o] && (n[o] = r[o]);
            }

            return n;
          }

          return t;
        }(n, r)), d = e.memoizedState;
        var i = new Map();

        try {
          return function (e, t) {
            for (var n = t; n;) {
              if (n.tag === a) {
                var r = n.type._context;
                e.has(r) || (e.set(r, r._currentValue), r._currentValue = n.memoizedProps.value);
              }

              n = n.return;
            }
          }(i, e), e.tag === s ? function (e, t, n, r) {
            var i,
                a,
                s = r.current;
            r.current = m;

            try {
              a = new Error(), e(t, n);
            } finally {
              i = l, l = [], r.current = s;
            }

            return w(o.a.parse(a), i);
          }(n.render, r, e.ref, t) : function (e, t, n) {
            var r,
                i,
                a = n.current;
            n.current = m;

            try {
              i = new Error(), e(t);
            } finally {
              r = l, l = [], n.current = a;
            }

            return w(o.a.parse(i), r);
          }(n, r, t);
        } finally {
          d = null, function (e) {
            e.forEach(function (e, t) {
              return t._currentValue = e;
            });
          }(i);
        }
      }

      function E(e, t) {
        var n = null,
            r = null;

        function o(e) {
          var n = t.elementData.get(e),
              r = t.internalInstancesById.get(e);

          if (r) {
            var o = t.renderers.get(e);

            if (o) {
              var i = t.reactInternals[o].renderer;
              if (i && i.currentDispatcherRef) return {
                elementID: e,
                id: "hooksTree",
                hooksTree: S(n.state === r.memoizedState ? r : r.alternate, i.currentDispatcherRef)
              };
            }
          }

          return null;
        }

        t.on("selected", function (i) {
          r = i;
          var a = t.elementData.get(i),
              s = null;
          a && a.containsHooks && (s = o(i)), n !== s && (n = s, e.send("inspectedHooks", s));
        }), t.on("update", function (t) {
          if (null !== r && null !== n && n.elementID === t.id) {
            var i = o(t.id);
            n !== i && (n = i, e.send("inspectedHooks", i));
          }
        });
      }

      n.d(t, "default", function () {
        return E;
      });
    }]);
  });
},183,[13],"node_modules/react-devtools-core/build/backend.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var JSInspector = {
    registerAgent: function registerAgent(type) {
      if (global.__registerInspectorAgent) {
        global.__registerInspectorAgent(type);
      }
    },
    getTimestamp: function getTimestamp() {
      return global.__inspectorTimestamp();
    }
  };
  module.exports = JSInspector;
},184,[],"node_modules/react-native/Libraries/JSInspector/JSInspector.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/possibleConstructorReturn");

  var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/getPrototypeOf");

  var _inherits = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/inherits");

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/createClass");

  var InspectorAgent = _$$_REQUIRE(_dependencyMap[5], "./InspectorAgent");

  var JSInspector = _$$_REQUIRE(_dependencyMap[6], "./JSInspector");

  var XMLHttpRequest = _$$_REQUIRE(_dependencyMap[7], "../Network/XMLHttpRequest");

  var Interceptor = function () {
    function Interceptor(agent) {
      _classCallCheck(this, Interceptor);

      this._agent = agent;
      this._requests = new Map();
    }

    _createClass(Interceptor, [{
      key: "getData",
      value: function getData(requestId) {
        return this._requests.get(requestId);
      }
    }, {
      key: "requestSent",
      value: function requestSent(id, url, method, headers) {
        var requestId = String(id);

        this._requests.set(requestId, '');

        var request = {
          url: url,
          method: method,
          headers: headers,
          initialPriority: 'Medium'
        };
        var event = {
          requestId: requestId,
          documentURL: '',
          frameId: '1',
          loaderId: '1',
          request: request,
          timestamp: JSInspector.getTimestamp(),
          initiator: {
            type: 'other'
          },
          type: 'Other'
        };

        this._agent.sendEvent('requestWillBeSent', event);
      }
    }, {
      key: "responseReceived",
      value: function responseReceived(id, url, status, headers) {
        var requestId = String(id);
        var response = {
          url: url,
          status: status,
          statusText: String(status),
          headers: headers,
          requestHeaders: {},
          mimeType: this._getMimeType(headers),
          connectionReused: false,
          connectionId: -1,
          encodedDataLength: 0,
          securityState: 'unknown'
        };
        var event = {
          requestId: requestId,
          frameId: '1',
          loaderId: '1',
          timestamp: JSInspector.getTimestamp(),
          type: 'Other',
          response: response
        };

        this._agent.sendEvent('responseReceived', event);
      }
    }, {
      key: "dataReceived",
      value: function dataReceived(id, data) {
        var requestId = String(id);
        var existingData = this._requests.get(requestId) || '';

        this._requests.set(requestId, existingData.concat(data));

        var event = {
          requestId: requestId,
          timestamp: JSInspector.getTimestamp(),
          dataLength: data.length,
          encodedDataLength: data.length
        };

        this._agent.sendEvent('dataReceived', event);
      }
    }, {
      key: "loadingFinished",
      value: function loadingFinished(id, encodedDataLength) {
        var event = {
          requestId: String(id),
          timestamp: JSInspector.getTimestamp(),
          encodedDataLength: encodedDataLength
        };

        this._agent.sendEvent('loadingFinished', event);
      }
    }, {
      key: "loadingFailed",
      value: function loadingFailed(id, error) {
        var event = {
          requestId: String(id),
          timestamp: JSInspector.getTimestamp(),
          type: 'Other',
          errorText: error
        };

        this._agent.sendEvent('loadingFailed', event);
      }
    }, {
      key: "_getMimeType",
      value: function _getMimeType(headers) {
        var contentType = headers['Content-Type'] || '';
        return contentType.split(';')[0];
      }
    }]);

    return Interceptor;
  }();

  var NetworkAgent = function (_InspectorAgent) {
    _inherits(NetworkAgent, _InspectorAgent);

    function NetworkAgent() {
      _classCallCheck(this, NetworkAgent);

      return _possibleConstructorReturn(this, _getPrototypeOf(NetworkAgent).apply(this, arguments));
    }

    _createClass(NetworkAgent, [{
      key: "enable",
      value: function enable(_ref) {
        var maxResourceBufferSize = _ref.maxResourceBufferSize,
            maxTotalBufferSize = _ref.maxTotalBufferSize;
        this._interceptor = new Interceptor(this);
        XMLHttpRequest.setInterceptor(this._interceptor);
      }
    }, {
      key: "disable",
      value: function disable() {
        XMLHttpRequest.setInterceptor(null);
        this._interceptor = null;
      }
    }, {
      key: "getResponseBody",
      value: function getResponseBody(_ref2) {
        var requestId = _ref2.requestId;
        return {
          body: this.interceptor().getData(requestId),
          base64Encoded: false
        };
      }
    }, {
      key: "interceptor",
      value: function interceptor() {
        if (this._interceptor) {
          return this._interceptor;
        } else {
          throw Error('_interceptor can not be null');
        }
      }
    }]);

    return NetworkAgent;
  }(InspectorAgent);

  NetworkAgent.DOMAIN = 'Network';
  module.exports = NetworkAgent;
},185,[32,34,37,24,25,186,184,126],"node_modules/react-native/Libraries/JSInspector/NetworkAgent.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");

  var InspectorAgent = function () {
    function InspectorAgent(eventSender) {
      _classCallCheck(this, InspectorAgent);

      this._eventSender = eventSender;
    }

    _createClass(InspectorAgent, [{
      key: "sendEvent",
      value: function sendEvent(name, params) {
        this._eventSender(name, params);
      }
    }]);

    return InspectorAgent;
  }();

  module.exports = InspectorAgent;
},186,[24,25],"node_modules/react-native/Libraries/JSInspector/InspectorAgent.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  if (__DEV__) {
    var NativeDevSettings = _$$_REQUIRE(_dependencyMap[0], "../NativeModules/specs/NativeDevSettings").default;

    if (typeof NativeDevSettings.reload !== 'function') {
      throw new Error('Could not find the reload() implementation.');
    }

    var ReactRefreshRuntime = _$$_REQUIRE(_dependencyMap[1], "react-refresh/runtime");

    ReactRefreshRuntime.injectIntoGlobalHook(global);
    var Refresh = {
      performFullRefresh: function performFullRefresh() {
        NativeDevSettings.reload();
      },
      createSignatureFunctionForTransform: ReactRefreshRuntime.createSignatureFunctionForTransform,
      isLikelyComponentType: ReactRefreshRuntime.isLikelyComponentType,
      getFamilyByType: ReactRefreshRuntime.getFamilyByType,
      register: ReactRefreshRuntime.register,
      performReactRefresh: function performReactRefresh() {
        if (ReactRefreshRuntime.hasUnrecoverableErrors()) {
          NativeDevSettings.reload();
          return;
        }

        ReactRefreshRuntime.performReactRefresh();
      }
    };
    _$$_REQUIRE.Refresh = Refresh;
  }
},187,[188,189],"node_modules/react-native/Libraries/Core/setUpReactRefresh.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireWildcard");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[1], "../../TurboModule/TurboModuleRegistry"));

  var _default = TurboModuleRegistry.getEnforcing('DevSettings');

  exports.default = _default;
},188,[9,11],"node_modules/react-native/Libraries/NativeModules/specs/NativeDevSettings.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  if (process.env.NODE_ENV === 'production') {
    module.exports = _$$_REQUIRE(_dependencyMap[0], "./cjs/react-refresh-runtime.production.min.js");
  } else {
    module.exports = _$$_REQUIRE(_dependencyMap[1], "./cjs/react-refresh-runtime.development.js");
  }
},189,[190,191],"node_modules/react-refresh/runtime.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  /** @license React vundefined
   * react-refresh-runtime.production.min.js
   *
   * 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.
   */
  'use strict';

  throw Error("React Refresh runtime should not be included in the production bundle.");
},190,[],"node_modules/react-refresh/cjs/react-refresh-runtime.production.min.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  /** @license React vundefined
   * react-refresh-runtime.development.js
   *
   * 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.
   */
  'use strict';

  if (process.env.NODE_ENV !== "production") {
    (function () {
      'use strict';

      var hasSymbol = typeof Symbol === 'function' && (typeof Symbol === "function" ? Symbol.for : "@@for");
      var REACT_FORWARD_REF_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.forward_ref') : 0xead0;
      var REACT_MEMO_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.memo') : 0xead3;
      var PossiblyWeakMap = typeof WeakMap === 'function' ? WeakMap : Map;
      var allFamiliesByID = new Map();
      var allFamiliesByType = new PossiblyWeakMap();
      var allSignaturesByType = new PossiblyWeakMap();
      var updatedFamiliesByType = new PossiblyWeakMap();
      var pendingUpdates = [];
      var helpersByRendererID = new Map();
      var helpersByRoot = new Map();
      var mountedRoots = new Set();
      var failedRoots = new Map();
      var didSomeRootFailOnMount = false;

      function computeFullKey(signature) {
        if (signature.fullKey !== null) {
          return signature.fullKey;
        }

        var fullKey = signature.ownKey;
        var hooks;

        try {
          hooks = signature.getCustomHooks();
        } catch (err) {
          signature.forceReset = true;
          signature.fullKey = fullKey;
          return fullKey;
        }

        for (var i = 0; i < hooks.length; i++) {
          var hook = hooks[i];

          if (typeof hook !== 'function') {
            signature.forceReset = true;
            signature.fullKey = fullKey;
            return fullKey;
          }

          var nestedHookSignature = allSignaturesByType.get(hook);

          if (nestedHookSignature === undefined) {
            continue;
          }

          var nestedHookKey = computeFullKey(nestedHookSignature);

          if (nestedHookSignature.forceReset) {
            signature.forceReset = true;
          }

          fullKey += '\n---\n' + nestedHookKey;
        }

        signature.fullKey = fullKey;
        return fullKey;
      }

      function haveEqualSignatures(prevType, nextType) {
        var prevSignature = allSignaturesByType.get(prevType);
        var nextSignature = allSignaturesByType.get(nextType);

        if (prevSignature === undefined && nextSignature === undefined) {
          return true;
        }

        if (prevSignature === undefined || nextSignature === undefined) {
          return false;
        }

        if (computeFullKey(prevSignature) !== computeFullKey(nextSignature)) {
          return false;
        }

        if (nextSignature.forceReset) {
          return false;
        }

        return true;
      }

      function isReactClass(type) {
        return type.prototype && type.prototype.isReactComponent;
      }

      function canPreserveStateBetween(prevType, nextType) {
        if (isReactClass(prevType) || isReactClass(nextType)) {
          return false;
        }

        if (haveEqualSignatures(prevType, nextType)) {
          return true;
        }

        return false;
      }

      function resolveFamily(type) {
        return updatedFamiliesByType.get(type);
      }

      function performReactRefresh() {
        {
          if (pendingUpdates.length === 0) {
            return null;
          }

          var staleFamilies = new Set();
          var updatedFamilies = new Set();
          var updates = pendingUpdates;
          pendingUpdates = [];
          updates.forEach(function (_ref) {
            var family = _ref[0],
                nextType = _ref[1];
            var prevType = family.current;
            updatedFamiliesByType.set(prevType, family);
            updatedFamiliesByType.set(nextType, family);
            family.current = nextType;

            if (canPreserveStateBetween(prevType, nextType)) {
              updatedFamilies.add(family);
            } else {
              staleFamilies.add(family);
            }
          });
          var update = {
            updatedFamilies: updatedFamilies,
            staleFamilies: staleFamilies
          };
          helpersByRendererID.forEach(function (helpers) {
            helpers.setRefreshHandler(resolveFamily);
          });
          var didError = false;
          var firstError = null;
          failedRoots.forEach(function (element, root) {
            var helpers = helpersByRoot.get(root);

            if (helpers === undefined) {
              throw new Error('Could not find helpers for a root. This is a bug in React Refresh.');
            }

            try {
              helpers.scheduleRoot(root, element);
            } catch (err) {
              if (!didError) {
                didError = true;
                firstError = err;
              }
            }
          });
          mountedRoots.forEach(function (root) {
            var helpers = helpersByRoot.get(root);

            if (helpers === undefined) {
              throw new Error('Could not find helpers for a root. This is a bug in React Refresh.');
            }

            try {
              helpers.scheduleRefresh(root, update);
            } catch (err) {
              if (!didError) {
                didError = true;
                firstError = err;
              }
            }
          });

          if (didError) {
            throw firstError;
          }

          return update;
        }
      }

      function register(type, id) {
        {
          if (type === null) {
            return;
          }

          if (typeof type !== 'function' && typeof type !== 'object') {
            return;
          }

          if (allFamiliesByType.has(type)) {
            return;
          }

          var family = allFamiliesByID.get(id);

          if (family === undefined) {
            family = {
              current: type
            };
            allFamiliesByID.set(id, family);
          } else {
            pendingUpdates.push([family, type]);
          }

          allFamiliesByType.set(type, family);

          if (typeof type === 'object' && type !== null) {
            switch (type.$$typeof) {
              case REACT_FORWARD_REF_TYPE:
                register(type.render, id + '$render');
                break;

              case REACT_MEMO_TYPE:
                register(type.type, id + '$type');
                break;
            }
          }
        }
      }

      function setSignature(type, key) {
        var forceReset = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
        var getCustomHooks = arguments.length > 3 ? arguments[3] : undefined;
        {
          allSignaturesByType.set(type, {
            forceReset: forceReset,
            ownKey: key,
            fullKey: null,
            getCustomHooks: getCustomHooks || function () {
              return [];
            }
          });
        }
      }

      function collectCustomHooksForSignature(type) {
        {
          var signature = allSignaturesByType.get(type);

          if (signature !== undefined) {
            computeFullKey(signature);
          }
        }
      }

      function getFamilyByID(id) {
        {
          return allFamiliesByID.get(id);
        }
      }

      function getFamilyByType(type) {
        {
          return allFamiliesByType.get(type);
        }
      }

      function findAffectedHostInstances(families) {
        {
          var affectedInstances = new Set();
          mountedRoots.forEach(function (root) {
            var helpers = helpersByRoot.get(root);

            if (helpers === undefined) {
              throw new Error('Could not find helpers for a root. This is a bug in React Refresh.');
            }

            var instancesForRoot = helpers.findHostInstancesForRefresh(root, families);
            instancesForRoot.forEach(function (inst) {
              affectedInstances.add(inst);
            });
          });
          return affectedInstances;
        }
      }

      function injectIntoGlobalHook(globalObject) {
        {
          var hook = globalObject.__REACT_DEVTOOLS_GLOBAL_HOOK__;

          if (hook === undefined) {
            var nextID = 0;
            globalObject.__REACT_DEVTOOLS_GLOBAL_HOOK__ = hook = {
              supportsFiber: true,
              inject: function inject(injected) {
                return nextID++;
              },
              onCommitFiberRoot: function onCommitFiberRoot(id, root, maybePriorityLevel, didError) {},
              onCommitFiberUnmount: function onCommitFiberUnmount() {}
            };
          }

          var oldInject = hook.inject;

          hook.inject = function (injected) {
            var id = oldInject.apply(this, arguments);

            if (typeof injected.scheduleRefresh === 'function' && typeof injected.setRefreshHandler === 'function') {
              helpersByRendererID.set(id, injected);
            }

            return id;
          };

          var oldOnCommitFiberRoot = hook.onCommitFiberRoot;

          hook.onCommitFiberRoot = function (id, root, maybePriorityLevel, didError) {
            var helpers = helpersByRendererID.get(id);

            if (helpers === undefined) {
              return;
            }

            helpersByRoot.set(root, helpers);
            var current = root.current;
            var alternate = current.alternate;

            if (alternate !== null) {
              var wasMounted = alternate.memoizedState != null && alternate.memoizedState.element != null;
              var isMounted = current.memoizedState != null && current.memoizedState.element != null;

              if (!wasMounted && isMounted) {
                mountedRoots.add(root);
                failedRoots.delete(root);
              } else if (wasMounted && isMounted) {} else if (wasMounted && !isMounted) {
                mountedRoots.delete(root);

                if (didError) {
                  failedRoots.set(root, alternate.memoizedState.element);
                } else {
                  helpersByRoot.delete(root);
                }
              } else if (!wasMounted && !isMounted) {
                if (didError && !failedRoots.has(root)) {
                  didSomeRootFailOnMount = true;
                }
              }
            } else {
              mountedRoots.add(root);
            }

            return oldOnCommitFiberRoot.apply(this, arguments);
          };
        }
      }

      function hasUnrecoverableErrors() {
        return didSomeRootFailOnMount;
      }

      function _getMountedRootCount() {
        {
          return mountedRoots.size;
        }
      }

      function createSignatureFunctionForTransform() {
        {
          var call = 0;
          var savedType;
          var hasCustomHooks;
          return function (type, key, forceReset, getCustomHooks) {
            switch (call++) {
              case 0:
                savedType = type;
                hasCustomHooks = typeof getCustomHooks === 'function';
                setSignature(type, key, forceReset, getCustomHooks);
                break;

              case 1:
                if (hasCustomHooks) {
                  collectCustomHooksForSignature(savedType);
                }

                break;
            }

            return type;
          };
        }
      }

      function isLikelyComponentType(type) {
        {
          switch (typeof type) {
            case 'function':
              {
                if (type.prototype != null) {
                  if (type.prototype.isReactComponent) {
                    return true;
                  }

                  var ownNames = Object.getOwnPropertyNames(type.prototype);

                  if (ownNames.length > 1 || ownNames[0] !== 'constructor') {
                    return false;
                  }

                  if (type.prototype.__proto__ !== Object.prototype) {
                    return false;
                  }
                }

                var name = type.name || type.displayName;
                return typeof name === 'string' && /^[A-Z]/.test(name);
              }

            case 'object':
              {
                if (type != null) {
                  switch (type.$$typeof) {
                    case REACT_FORWARD_REF_TYPE:
                    case REACT_MEMO_TYPE:
                      return true;

                    default:
                      return false;
                  }
                }

                return false;
              }

            default:
              {
                return false;
              }
          }
        }
      }

      var ReactFreshRuntime = Object.freeze({
        performReactRefresh: performReactRefresh,
        register: register,
        setSignature: setSignature,
        collectCustomHooksForSignature: collectCustomHooksForSignature,
        getFamilyByID: getFamilyByID,
        getFamilyByType: getFamilyByType,
        findAffectedHostInstances: findAffectedHostInstances,
        injectIntoGlobalHook: injectIntoGlobalHook,
        hasUnrecoverableErrors: hasUnrecoverableErrors,
        _getMountedRootCount: _getMountedRootCount,
        createSignatureFunctionForTransform: createSignatureFunctionForTransform,
        isLikelyComponentType: isLikelyComponentType
      });
      var runtime = ReactFreshRuntime.default || ReactFreshRuntime;
      module.exports = runtime;
    })();
  }
},191,[],"node_modules/react-refresh/cjs/react-refresh-runtime.development.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  module.exports = {
    get BatchedBridge() {
      return _$$_REQUIRE(_dependencyMap[0], "../BatchedBridge/BatchedBridge.js");
    },

    get ExceptionsManager() {
      return _$$_REQUIRE(_dependencyMap[1], "../Core/ExceptionsManager");
    },

    get Platform() {
      return _$$_REQUIRE(_dependencyMap[2], "../Utilities/Platform");
    },

    get RCTEventEmitter() {
      return _$$_REQUIRE(_dependencyMap[3], "../EventEmitter/RCTEventEmitter");
    },

    get ReactNativeViewConfigRegistry() {
      return _$$_REQUIRE(_dependencyMap[4], "../Renderer/shims/ReactNativeViewConfigRegistry");
    },

    get TextInputState() {
      return _$$_REQUIRE(_dependencyMap[5], "../Components/TextInput/TextInputState");
    },

    get UIManager() {
      return _$$_REQUIRE(_dependencyMap[6], "../ReactNative/UIManager");
    },

    get deepDiffer() {
      return _$$_REQUIRE(_dependencyMap[7], "../Utilities/differ/deepDiffer");
    },

    get deepFreezeAndThrowOnMutationInDev() {
      return _$$_REQUIRE(_dependencyMap[8], "../Utilities/deepFreezeAndThrowOnMutationInDev");
    },

    get flattenStyle() {
      return _$$_REQUIRE(_dependencyMap[9], "../StyleSheet/flattenStyle");
    },

    get ReactFiberErrorDialog() {
      return _$$_REQUIRE(_dependencyMap[10], "../Core/ReactFiberErrorDialog");
    }

  };
},192,[18,95,48,193,194,195,43,196,28,85,197],"node_modules/react-native/Libraries/ReactPrivate/ReactNativePrivateInterface.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var BatchedBridge = _$$_REQUIRE(_dependencyMap[0], "../BatchedBridge/BatchedBridge");

  var RCTEventEmitter = {
    register: function register(eventEmitter) {
      BatchedBridge.registerCallableModule('RCTEventEmitter', eventEmitter);
    }
  };
  module.exports = RCTEventEmitter;
},193,[18],"node_modules/react-native/Libraries/EventEmitter/RCTEventEmitter.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var invariant = _$$_REQUIRE(_dependencyMap[0], "invariant");

  var customBubblingEventTypes = {};
  var customDirectEventTypes = {};
  exports.customBubblingEventTypes = customBubblingEventTypes;
  exports.customDirectEventTypes = customDirectEventTypes;
  var viewConfigCallbacks = new Map();
  var viewConfigs = new Map();

  function processEventTypes(viewConfig) {
    var bubblingEventTypes = viewConfig.bubblingEventTypes,
        directEventTypes = viewConfig.directEventTypes;

    if (__DEV__) {
      if (bubblingEventTypes != null && directEventTypes != null) {
        for (var topLevelType in directEventTypes) {
          invariant(bubblingEventTypes[topLevelType] == null, 'Event cannot be both direct and bubbling: %s', topLevelType);
        }
      }
    }

    if (bubblingEventTypes != null) {
      for (var _topLevelType in bubblingEventTypes) {
        if (customBubblingEventTypes[_topLevelType] == null) {
          customBubblingEventTypes[_topLevelType] = bubblingEventTypes[_topLevelType];
        }
      }
    }

    if (directEventTypes != null) {
      for (var _topLevelType2 in directEventTypes) {
        if (customDirectEventTypes[_topLevelType2] == null) {
          customDirectEventTypes[_topLevelType2] = directEventTypes[_topLevelType2];
        }
      }
    }
  }

  exports.register = function (name, callback) {
    invariant(!viewConfigCallbacks.has(name), 'Tried to register two views with the same name %s', name);
    viewConfigCallbacks.set(name, callback);
    return name;
  };

  exports.get = function (name) {
    var viewConfig;

    if (!viewConfigs.has(name)) {
      var callback = viewConfigCallbacks.get(name);

      if (typeof callback !== 'function') {
        invariant(false, 'View config not found for name %s.%s', name, typeof name[0] === 'string' && /[a-z]/.test(name[0]) ? ' Make sure to start component names with a capital letter.' : '');
      }

      viewConfigCallbacks.set(name, null);
      viewConfig = callback();
      processEventTypes(viewConfig);
      viewConfigs.set(name, viewConfig);
    } else {
      viewConfig = viewConfigs.get(name);
    }

    invariant(viewConfig, 'View config not found for name %s', name);
    return viewConfig;
  };
},194,[3],"node_modules/react-native/Libraries/Renderer/shims/ReactNativeViewConfigRegistry.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var Platform = _$$_REQUIRE(_dependencyMap[0], "../../Utilities/Platform");

  var UIManager = _$$_REQUIRE(_dependencyMap[1], "../../ReactNative/UIManager");

  var currentlyFocusedID = null;
  var inputs = new Set();

  function currentlyFocusedField() {
    return currentlyFocusedID;
  }

  function focusTextInput(textFieldID) {
    if (currentlyFocusedID !== textFieldID && textFieldID !== null) {
      currentlyFocusedID = textFieldID;

      if ("android" === 'ios') {
        UIManager.focus(textFieldID);
      } else if ("android" === 'android') {
        UIManager.dispatchViewManagerCommand(textFieldID, UIManager.getViewManagerConfig('AndroidTextInput').Commands.focusTextInput, null);
      }
    }
  }

  function blurTextInput(textFieldID) {
    if (currentlyFocusedID === textFieldID && textFieldID !== null) {
      currentlyFocusedID = null;

      if ("android" === 'ios') {
        UIManager.blur(textFieldID);
      } else if ("android" === 'android') {
        UIManager.dispatchViewManagerCommand(textFieldID, UIManager.getViewManagerConfig('AndroidTextInput').Commands.blurTextInput, null);
      }
    }
  }

  function registerInput(textFieldID) {
    inputs.add(textFieldID);
  }

  function unregisterInput(textFieldID) {
    inputs.delete(textFieldID);
  }

  function isTextInput(textFieldID) {
    return inputs.has(textFieldID);
  }

  module.exports = {
    currentlyFocusedField: currentlyFocusedField,
    focusTextInput: focusTextInput,
    blurTextInput: blurTextInput,
    registerInput: registerInput,
    unregisterInput: unregisterInput,
    isTextInput: isTextInput
  };
},195,[48,43],"node_modules/react-native/Libraries/Components/TextInput/TextInputState.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var deepDiffer = function deepDiffer(one, two) {
    var maxDepth = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : -1;

    if (maxDepth === 0) {
      return true;
    }

    if (one === two) {
      return false;
    }

    if (typeof one === 'function' && typeof two === 'function') {
      return false;
    }

    if (typeof one !== 'object' || one === null) {
      return one !== two;
    }

    if (typeof two !== 'object' || two === null) {
      return true;
    }

    if (one.constructor !== two.constructor) {
      return true;
    }

    if (Array.isArray(one)) {
      var len = one.length;

      if (two.length !== len) {
        return true;
      }

      for (var ii = 0; ii < len; ii++) {
        if (deepDiffer(one[ii], two[ii], maxDepth - 1)) {
          return true;
        }
      }
    } else {
      for (var key in one) {
        if (deepDiffer(one[key], two[key], maxDepth - 1)) {
          return true;
        }
      }

      for (var twoKey in two) {
        if (one[twoKey] === undefined && two[twoKey] !== undefined) {
          return true;
        }
      }
    }

    return false;
  };

  module.exports = deepDiffer;
},196,[],"node_modules/react-native/Libraries/Utilities/differ/deepDiffer.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _ExceptionsManager = _$$_REQUIRE(_dependencyMap[0], "./ExceptionsManager");

  function showErrorDialog(capturedError) {
    var componentStack = capturedError.componentStack,
        error = capturedError.error;
    var errorToHandle;

    if (error instanceof Error) {
      errorToHandle = error;
    } else if (typeof error === 'string') {
      errorToHandle = new _ExceptionsManager.SyntheticError(error);
    } else {
      errorToHandle = new _ExceptionsManager.SyntheticError('Unspecified error');
    }

    try {
      errorToHandle.componentStack = componentStack;
    } catch (e) {}

    (0, _ExceptionsManager.handleException)(errorToHandle, false);
    return false;
  }

  module.exports = {
    showErrorDialog: showErrorDialog
  };
},197,[95],"node_modules/react-native/Libraries/Core/ReactFiberErrorDialog.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  if (process.env.NODE_ENV === 'production') {
    module.exports = _$$_REQUIRE(_dependencyMap[0], "./cjs/scheduler.production.min.js");
  } else {
    module.exports = _$$_REQUIRE(_dependencyMap[1], "./cjs/scheduler.development.js");
  }
},198,[199,200],"node_modules/scheduler/index.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  /** @license React v0.15.0
   * scheduler.production.min.js
   *
   * 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.
   */
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: !0
  });

  var _d = void 0,
      e = void 0,
      g = void 0,
      m = void 0,
      n = void 0;

  exports.unstable_now = void 0;
  exports.unstable_forceFrameRate = void 0;

  if ("undefined" === typeof window || "function" !== typeof MessageChannel) {
    var p = null,
        q = null,
        r = function r() {
      if (null !== p) try {
        var a = exports.unstable_now();
        p(!0, a);
        p = null;
      } catch (b) {
        throw setTimeout(r, 0), b;
      }
    };

    exports.unstable_now = function () {
      return Date.now();
    };

    _d = function d(a) {
      null !== p ? setTimeout(_d, 0, a) : (p = a, setTimeout(r, 0));
    };

    e = function e(a, b) {
      q = setTimeout(a, b);
    };

    g = function g() {
      clearTimeout(q);
    };

    m = function m() {
      return !1;
    };

    n = exports.unstable_forceFrameRate = function () {};
  } else {
    var t = window.performance,
        u = window.Date,
        v = window.setTimeout,
        w = window.clearTimeout,
        x = window.requestAnimationFrame,
        y = window.cancelAnimationFrame;
    "undefined" !== typeof console && ("function" !== typeof x && console.error("This browser doesn't support requestAnimationFrame. Make sure that you load a polyfill in older browsers. https://fb.me/react-polyfills"), "function" !== typeof y && console.error("This browser doesn't support cancelAnimationFrame. Make sure that you load a polyfill in older browsers. https://fb.me/react-polyfills"));
    exports.unstable_now = "object" === typeof t && "function" === typeof t.now ? function () {
      return t.now();
    } : function () {
      return u.now();
    };
    var z = !1,
        A = null,
        B = -1,
        C = -1,
        D = 33.33,
        E = -1,
        F = -1,
        G = 0,
        H = !1;

    m = function m() {
      return exports.unstable_now() >= G;
    };

    n = function n() {};

    exports.unstable_forceFrameRate = function (a) {
      0 > a || 125 < a ? console.error("forceFrameRate takes a positive int between 0 and 125, forcing framerates higher than 125 fps is not unsupported") : 0 < a ? (D = Math.floor(1E3 / a), H = !0) : (D = 33.33, H = !1);
    };

    var J = function J() {
      if (null !== A) {
        var a = exports.unstable_now(),
            b = 0 < G - a;

        try {
          A(b, a) || (A = null);
        } catch (c) {
          throw I.postMessage(null), c;
        }
      }
    },
        K = new MessageChannel(),
        I = K.port2;

    K.port1.onmessage = J;

    var L = function L(a) {
      if (null === A) F = E = -1, z = !1;else {
        z = !0;
        x(function (a) {
          w(B);
          L(a);
        });

        var b = function b() {
          G = exports.unstable_now() + D / 2;
          J();
          B = v(b, 3 * D);
        };

        B = v(b, 3 * D);

        if (-1 !== E && .1 < a - E) {
          var c = a - E;
          !H && -1 !== F && c < D && F < D && (D = c < F ? F : c, 8.33 > D && (D = 8.33));
          F = c;
        }

        E = a;
        G = a + D;
        I.postMessage(null);
      }
    };

    _d = function _d(a) {
      A = a;
      z || (z = !0, x(function (a) {
        L(a);
      }));
    };

    e = function e(a, b) {
      C = v(function () {
        a(exports.unstable_now());
      }, b);
    };

    g = function g() {
      w(C);
      C = -1;
    };
  }

  var M = null,
      N = null,
      O = null,
      P = 3,
      Q = !1,
      R = !1,
      S = !1;

  function T(a, b) {
    var c = a.next;
    if (c === a) M = null;else {
      a === M && (M = c);
      var f = a.previous;
      f.next = c;
      c.previous = f;
    }
    a.next = a.previous = null;
    c = a.callback;
    f = P;
    var l = O;
    P = a.priorityLevel;
    O = a;

    try {
      var h = a.expirationTime <= b;

      switch (P) {
        case 1:
          var k = c(h);
          break;

        case 2:
          k = c(h);
          break;

        case 3:
          k = c(h);
          break;

        case 4:
          k = c(h);
          break;

        case 5:
          k = c(h);
      }
    } catch (Z) {
      throw Z;
    } finally {
      P = f, O = l;
    }

    if ("function" === typeof k) if (b = a.expirationTime, a.callback = k, null === M) M = a.next = a.previous = a;else {
      k = null;
      h = M;

      do {
        if (b <= h.expirationTime) {
          k = h;
          break;
        }

        h = h.next;
      } while (h !== M);

      null === k ? k = M : k === M && (M = a);
      b = k.previous;
      b.next = k.previous = a;
      a.next = k;
      a.previous = b;
    }
  }

  function U(a) {
    if (null !== N && N.startTime <= a) {
      do {
        var b = N,
            c = b.next;
        if (b === c) N = null;else {
          N = c;
          var f = b.previous;
          f.next = c;
          c.previous = f;
        }
        b.next = b.previous = null;
        V(b, b.expirationTime);
      } while (null !== N && N.startTime <= a);
    }
  }

  function W(a) {
    S = !1;
    U(a);
    R || (null !== M ? (R = !0, _d(X)) : null !== N && e(W, N.startTime - a));
  }

  function X(a, b) {
    R = !1;
    S && (S = !1, g());
    U(b);
    Q = !0;

    try {
      if (!a) for (; null !== M && M.expirationTime <= b;) {
        T(M, b), b = exports.unstable_now(), U(b);
      } else if (null !== M) {
        do {
          T(M, b), b = exports.unstable_now(), U(b);
        } while (null !== M && !m());
      }
      if (null !== M) return !0;
      null !== N && e(W, N.startTime - b);
      return !1;
    } finally {
      Q = !1;
    }
  }

  function Y(a) {
    switch (a) {
      case 1:
        return -1;

      case 2:
        return 250;

      case 5:
        return 1073741823;

      case 4:
        return 1E4;

      default:
        return 5E3;
    }
  }

  function V(a, b) {
    if (null === M) M = a.next = a.previous = a;else {
      var c = null,
          f = M;

      do {
        if (b < f.expirationTime) {
          c = f;
          break;
        }

        f = f.next;
      } while (f !== M);

      null === c ? c = M : c === M && (M = a);
      b = c.previous;
      b.next = c.previous = a;
      a.next = c;
      a.previous = b;
    }
  }

  var aa = n;
  exports.unstable_ImmediatePriority = 1;
  exports.unstable_UserBlockingPriority = 2;
  exports.unstable_NormalPriority = 3;
  exports.unstable_IdlePriority = 5;
  exports.unstable_LowPriority = 4;

  exports.unstable_runWithPriority = function (a, b) {
    switch (a) {
      case 1:
      case 2:
      case 3:
      case 4:
      case 5:
        break;

      default:
        a = 3;
    }

    var c = P;
    P = a;

    try {
      return b();
    } finally {
      P = c;
    }
  };

  exports.unstable_next = function (a) {
    switch (P) {
      case 1:
      case 2:
      case 3:
        var b = 3;
        break;

      default:
        b = P;
    }

    var c = P;
    P = b;

    try {
      return a();
    } finally {
      P = c;
    }
  };

  exports.unstable_scheduleCallback = function (a, b, c) {
    var f = exports.unstable_now();

    if ("object" === typeof c && null !== c) {
      var l = c.delay;
      l = "number" === typeof l && 0 < l ? f + l : f;
      c = "number" === typeof c.timeout ? c.timeout : Y(a);
    } else c = Y(a), l = f;

    c = l + c;
    a = {
      callback: b,
      priorityLevel: a,
      startTime: l,
      expirationTime: c,
      next: null,
      previous: null
    };

    if (l > f) {
      c = l;
      if (null === N) N = a.next = a.previous = a;else {
        b = null;
        var h = N;

        do {
          if (c < h.startTime) {
            b = h;
            break;
          }

          h = h.next;
        } while (h !== N);

        null === b ? b = N : b === N && (N = a);
        c = b.previous;
        c.next = b.previous = a;
        a.next = b;
        a.previous = c;
      }
      null === M && N === a && (S ? g() : S = !0, e(W, l - f));
    } else V(a, c), R || Q || (R = !0, _d(X));

    return a;
  };

  exports.unstable_cancelCallback = function (a) {
    var b = a.next;

    if (null !== b) {
      if (a === b) a === M ? M = null : a === N && (N = null);else {
        a === M ? M = b : a === N && (N = b);
        var c = a.previous;
        c.next = b;
        b.previous = c;
      }
      a.next = a.previous = null;
    }
  };

  exports.unstable_wrapCallback = function (a) {
    var b = P;
    return function () {
      var c = P;
      P = b;

      try {
        return a.apply(this, arguments);
      } finally {
        P = c;
      }
    };
  };

  exports.unstable_getCurrentPriorityLevel = function () {
    return P;
  };

  exports.unstable_shouldYield = function () {
    var a = exports.unstable_now();
    U(a);
    return null !== O && null !== M && M.startTime <= a && M.expirationTime < O.expirationTime || m();
  };

  exports.unstable_requestPaint = aa;

  exports.unstable_continueExecution = function () {
    R || Q || (R = !0, _d(X));
  };

  exports.unstable_pauseExecution = function () {};

  exports.unstable_getFirstCallbackNode = function () {
    return M;
  };
},199,[],"node_modules/scheduler/cjs/scheduler.production.min.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  /** @license React v0.15.0
   * scheduler.development.js
   *
   * 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.
   */
  'use strict';

  if (process.env.NODE_ENV !== "production") {
    (function () {
      'use strict';

      Object.defineProperty(exports, '__esModule', {
        value: true
      });
      var enableSchedulerDebugging = false;
      var enableIsInputPending = false;
      var requestIdleCallbackBeforeFirstFrame = false;
      var requestTimerEventBeforeFirstFrame = false;
      var enableMessageLoopImplementation = false;

      var _requestHostCallback = void 0;

      var requestHostTimeout = void 0;
      var cancelHostTimeout = void 0;
      var shouldYieldToHost = void 0;
      var requestPaint = void 0;
      exports.unstable_now = void 0;
      exports.unstable_forceFrameRate = void 0;

      if (typeof window === 'undefined' || typeof MessageChannel !== 'function') {
        var _callback = null;
        var _timeoutID = null;

        var _flushCallback = function _flushCallback() {
          if (_callback !== null) {
            try {
              var currentTime = exports.unstable_now();
              var hasRemainingTime = true;

              _callback(hasRemainingTime, currentTime);

              _callback = null;
            } catch (e) {
              setTimeout(_flushCallback, 0);
              throw e;
            }
          }
        };

        exports.unstable_now = function () {
          return Date.now();
        };

        _requestHostCallback = function requestHostCallback(cb) {
          if (_callback !== null) {
            setTimeout(_requestHostCallback, 0, cb);
          } else {
            _callback = cb;
            setTimeout(_flushCallback, 0);
          }
        };

        requestHostTimeout = function requestHostTimeout(cb, ms) {
          _timeoutID = setTimeout(cb, ms);
        };

        cancelHostTimeout = function cancelHostTimeout() {
          clearTimeout(_timeoutID);
        };

        shouldYieldToHost = function shouldYieldToHost() {
          return false;
        };

        requestPaint = exports.unstable_forceFrameRate = function () {};
      } else {
        var performance = window.performance;
        var _Date = window.Date;
        var _setTimeout = window.setTimeout;
        var _clearTimeout = window.clearTimeout;
        var requestAnimationFrame = window.requestAnimationFrame;
        var cancelAnimationFrame = window.cancelAnimationFrame;
        var requestIdleCallback = window.requestIdleCallback;

        if (typeof console !== 'undefined') {
          if (typeof requestAnimationFrame !== 'function') {
            console.error("This browser doesn't support requestAnimationFrame. " + 'Make sure that you load a ' + 'polyfill in older browsers. https://fb.me/react-polyfills');
          }

          if (typeof cancelAnimationFrame !== 'function') {
            console.error("This browser doesn't support cancelAnimationFrame. " + 'Make sure that you load a ' + 'polyfill in older browsers. https://fb.me/react-polyfills');
          }
        }

        var requestIdleCallbackBeforeFirstFrame$1 = requestIdleCallbackBeforeFirstFrame && typeof requestIdleCallback === 'function' && typeof cancelIdleCallback === 'function';
        exports.unstable_now = typeof performance === 'object' && typeof performance.now === 'function' ? function () {
          return performance.now();
        } : function () {
          return _Date.now();
        };
        var isRAFLoopRunning = false;
        var isMessageLoopRunning = false;
        var scheduledHostCallback = null;
        var rAFTimeoutID = -1;
        var taskTimeoutID = -1;
        var frameLength = enableMessageLoopImplementation ? 5 : 33.33;
        var prevRAFTime = -1;
        var prevRAFInterval = -1;
        var frameDeadline = 0;
        var fpsLocked = false;
        var maxFrameLength = 300;
        var needsPaint = false;

        if (enableIsInputPending && navigator !== undefined && navigator.scheduling !== undefined && navigator.scheduling.isInputPending !== undefined) {
          var scheduling = navigator.scheduling;

          shouldYieldToHost = function shouldYieldToHost() {
            var currentTime = exports.unstable_now();

            if (currentTime >= frameDeadline) {
              if (needsPaint || scheduling.isInputPending()) {
                return true;
              }

              return currentTime >= frameDeadline + maxFrameLength;
            } else {
              return false;
            }
          };

          requestPaint = function requestPaint() {
            needsPaint = true;
          };
        } else {
          shouldYieldToHost = function shouldYieldToHost() {
            return exports.unstable_now() >= frameDeadline;
          };

          requestPaint = function requestPaint() {};
        }

        exports.unstable_forceFrameRate = function (fps) {
          if (fps < 0 || fps > 125) {
            console.error('forceFrameRate takes a positive int between 0 and 125, ' + 'forcing framerates higher than 125 fps is not unsupported');
            return;
          }

          if (fps > 0) {
            frameLength = Math.floor(1000 / fps);
            fpsLocked = true;
          } else {
            frameLength = 33.33;
            fpsLocked = false;
          }
        };

        var performWorkUntilDeadline = function performWorkUntilDeadline() {
          if (enableMessageLoopImplementation) {
            if (scheduledHostCallback !== null) {
              var currentTime = exports.unstable_now();
              frameDeadline = currentTime + frameLength;
              var hasTimeRemaining = true;

              try {
                var hasMoreWork = scheduledHostCallback(hasTimeRemaining, currentTime);

                if (!hasMoreWork) {
                  isMessageLoopRunning = false;
                  scheduledHostCallback = null;
                } else {
                  port.postMessage(null);
                }
              } catch (error) {
                port.postMessage(null);
                throw error;
              }
            }

            needsPaint = false;
          } else {
            if (scheduledHostCallback !== null) {
              var _currentTime = exports.unstable_now();

              var _hasTimeRemaining = frameDeadline - _currentTime > 0;

              try {
                var _hasMoreWork = scheduledHostCallback(_hasTimeRemaining, _currentTime);

                if (!_hasMoreWork) {
                  scheduledHostCallback = null;
                }
              } catch (error) {
                port.postMessage(null);
                throw error;
              }
            }

            needsPaint = false;
          }
        };

        var channel = new MessageChannel();
        var port = channel.port2;
        channel.port1.onmessage = performWorkUntilDeadline;

        var onAnimationFrame = function onAnimationFrame(rAFTime) {
          if (scheduledHostCallback === null) {
            prevRAFTime = -1;
            prevRAFInterval = -1;
            isRAFLoopRunning = false;
            return;
          }

          isRAFLoopRunning = true;
          requestAnimationFrame(function (nextRAFTime) {
            _clearTimeout(rAFTimeoutID);

            onAnimationFrame(nextRAFTime);
          });

          var onTimeout = function onTimeout() {
            frameDeadline = exports.unstable_now() + frameLength / 2;
            performWorkUntilDeadline();
            rAFTimeoutID = _setTimeout(onTimeout, frameLength * 3);
          };

          rAFTimeoutID = _setTimeout(onTimeout, frameLength * 3);

          if (prevRAFTime !== -1 && rAFTime - prevRAFTime > 0.1) {
            var rAFInterval = rAFTime - prevRAFTime;

            if (!fpsLocked && prevRAFInterval !== -1) {
              if (rAFInterval < frameLength && prevRAFInterval < frameLength) {
                frameLength = rAFInterval < prevRAFInterval ? prevRAFInterval : rAFInterval;

                if (frameLength < 8.33) {
                  frameLength = 8.33;
                }
              }
            }

            prevRAFInterval = rAFInterval;
          }

          prevRAFTime = rAFTime;
          frameDeadline = rAFTime + frameLength;
          port.postMessage(null);
        };

        _requestHostCallback = function _requestHostCallback(callback) {
          scheduledHostCallback = callback;

          if (enableMessageLoopImplementation) {
            if (!isMessageLoopRunning) {
              isMessageLoopRunning = true;
              port.postMessage(null);
            }
          } else {
            if (!isRAFLoopRunning) {
              isRAFLoopRunning = true;
              requestAnimationFrame(function (rAFTime) {
                if (requestIdleCallbackBeforeFirstFrame$1) {
                  cancelIdleCallback(idleCallbackID);
                }

                if (requestTimerEventBeforeFirstFrame) {
                  _clearTimeout(idleTimeoutID);
                }

                onAnimationFrame(rAFTime);
              });
              var idleCallbackID = void 0;

              if (requestIdleCallbackBeforeFirstFrame$1) {
                idleCallbackID = requestIdleCallback(function onIdleCallbackBeforeFirstFrame() {
                  if (requestTimerEventBeforeFirstFrame) {
                    _clearTimeout(idleTimeoutID);
                  }

                  frameDeadline = exports.unstable_now() + frameLength;
                  performWorkUntilDeadline();
                });
              }

              var idleTimeoutID = void 0;

              if (requestTimerEventBeforeFirstFrame) {
                idleTimeoutID = _setTimeout(function onTimerEventBeforeFirstFrame() {
                  if (requestIdleCallbackBeforeFirstFrame$1) {
                    cancelIdleCallback(idleCallbackID);
                  }

                  frameDeadline = exports.unstable_now() + frameLength;
                  performWorkUntilDeadline();
                }, 0);
              }
            }
          }
        };

        requestHostTimeout = function requestHostTimeout(callback, ms) {
          taskTimeoutID = _setTimeout(function () {
            callback(exports.unstable_now());
          }, ms);
        };

        cancelHostTimeout = function cancelHostTimeout() {
          _clearTimeout(taskTimeoutID);

          taskTimeoutID = -1;
        };
      }

      var ImmediatePriority = 1;
      var UserBlockingPriority = 2;
      var NormalPriority = 3;
      var LowPriority = 4;
      var IdlePriority = 5;
      var maxSigned31BitInt = 1073741823;
      var IMMEDIATE_PRIORITY_TIMEOUT = -1;
      var USER_BLOCKING_PRIORITY = 250;
      var NORMAL_PRIORITY_TIMEOUT = 5000;
      var LOW_PRIORITY_TIMEOUT = 10000;
      var IDLE_PRIORITY = maxSigned31BitInt;
      var firstTask = null;
      var firstDelayedTask = null;
      var isSchedulerPaused = false;
      var currentTask = null;
      var currentPriorityLevel = NormalPriority;
      var isPerformingWork = false;
      var isHostCallbackScheduled = false;
      var isHostTimeoutScheduled = false;

      function scheduler_flushTaskAtPriority_Immediate(callback, didTimeout) {
        return callback(didTimeout);
      }

      function scheduler_flushTaskAtPriority_UserBlocking(callback, didTimeout) {
        return callback(didTimeout);
      }

      function scheduler_flushTaskAtPriority_Normal(callback, didTimeout) {
        return callback(didTimeout);
      }

      function scheduler_flushTaskAtPriority_Low(callback, didTimeout) {
        return callback(didTimeout);
      }

      function scheduler_flushTaskAtPriority_Idle(callback, didTimeout) {
        return callback(didTimeout);
      }

      function flushTask(task, currentTime) {
        var next = task.next;

        if (next === task) {
          firstTask = null;
        } else {
          if (task === firstTask) {
            firstTask = next;
          }

          var previous = task.previous;
          previous.next = next;
          next.previous = previous;
        }

        task.next = task.previous = null;
        var callback = task.callback;
        var previousPriorityLevel = currentPriorityLevel;
        var previousTask = currentTask;
        currentPriorityLevel = task.priorityLevel;
        currentTask = task;
        var continuationCallback;

        try {
          var didUserCallbackTimeout = task.expirationTime <= currentTime;

          switch (currentPriorityLevel) {
            case ImmediatePriority:
              continuationCallback = scheduler_flushTaskAtPriority_Immediate(callback, didUserCallbackTimeout);
              break;

            case UserBlockingPriority:
              continuationCallback = scheduler_flushTaskAtPriority_UserBlocking(callback, didUserCallbackTimeout);
              break;

            case NormalPriority:
              continuationCallback = scheduler_flushTaskAtPriority_Normal(callback, didUserCallbackTimeout);
              break;

            case LowPriority:
              continuationCallback = scheduler_flushTaskAtPriority_Low(callback, didUserCallbackTimeout);
              break;

            case IdlePriority:
              continuationCallback = scheduler_flushTaskAtPriority_Idle(callback, didUserCallbackTimeout);
              break;
          }
        } catch (error) {
          throw error;
        } finally {
          currentPriorityLevel = previousPriorityLevel;
          currentTask = previousTask;
        }

        if (typeof continuationCallback === 'function') {
          var expirationTime = task.expirationTime;
          var continuationTask = task;
          continuationTask.callback = continuationCallback;

          if (firstTask === null) {
            firstTask = continuationTask.next = continuationTask.previous = continuationTask;
          } else {
            var nextAfterContinuation = null;
            var t = firstTask;

            do {
              if (expirationTime <= t.expirationTime) {
                nextAfterContinuation = t;
                break;
              }

              t = t.next;
            } while (t !== firstTask);

            if (nextAfterContinuation === null) {
              nextAfterContinuation = firstTask;
            } else if (nextAfterContinuation === firstTask) {
              firstTask = continuationTask;
            }

            var _previous = nextAfterContinuation.previous;
            _previous.next = nextAfterContinuation.previous = continuationTask;
            continuationTask.next = nextAfterContinuation;
            continuationTask.previous = _previous;
          }
        }
      }

      function advanceTimers(currentTime) {
        if (firstDelayedTask !== null && firstDelayedTask.startTime <= currentTime) {
          do {
            var task = firstDelayedTask;
            var next = task.next;

            if (task === next) {
              firstDelayedTask = null;
            } else {
              firstDelayedTask = next;
              var previous = task.previous;
              previous.next = next;
              next.previous = previous;
            }

            task.next = task.previous = null;
            insertScheduledTask(task, task.expirationTime);
          } while (firstDelayedTask !== null && firstDelayedTask.startTime <= currentTime);
        }
      }

      function handleTimeout(currentTime) {
        isHostTimeoutScheduled = false;
        advanceTimers(currentTime);

        if (!isHostCallbackScheduled) {
          if (firstTask !== null) {
            isHostCallbackScheduled = true;

            _requestHostCallback(flushWork);
          } else if (firstDelayedTask !== null) {
            requestHostTimeout(handleTimeout, firstDelayedTask.startTime - currentTime);
          }
        }
      }

      function flushWork(hasTimeRemaining, initialTime) {
        if (enableSchedulerDebugging && isSchedulerPaused) {
          return;
        }

        isHostCallbackScheduled = false;

        if (isHostTimeoutScheduled) {
          isHostTimeoutScheduled = false;
          cancelHostTimeout();
        }

        var currentTime = initialTime;
        advanceTimers(currentTime);
        isPerformingWork = true;

        try {
          if (!hasTimeRemaining) {
            while (firstTask !== null && firstTask.expirationTime <= currentTime && !(enableSchedulerDebugging && isSchedulerPaused)) {
              flushTask(firstTask, currentTime);
              currentTime = exports.unstable_now();
              advanceTimers(currentTime);
            }
          } else {
            if (firstTask !== null) {
              do {
                flushTask(firstTask, currentTime);
                currentTime = exports.unstable_now();
                advanceTimers(currentTime);
              } while (firstTask !== null && !shouldYieldToHost() && !(enableSchedulerDebugging && isSchedulerPaused));
            }
          }

          if (firstTask !== null) {
            return true;
          } else {
            if (firstDelayedTask !== null) {
              requestHostTimeout(handleTimeout, firstDelayedTask.startTime - currentTime);
            }

            return false;
          }
        } finally {
          isPerformingWork = false;
        }
      }

      function unstable_runWithPriority(priorityLevel, eventHandler) {
        switch (priorityLevel) {
          case ImmediatePriority:
          case UserBlockingPriority:
          case NormalPriority:
          case LowPriority:
          case IdlePriority:
            break;

          default:
            priorityLevel = NormalPriority;
        }

        var previousPriorityLevel = currentPriorityLevel;
        currentPriorityLevel = priorityLevel;

        try {
          return eventHandler();
        } finally {
          currentPriorityLevel = previousPriorityLevel;
        }
      }

      function unstable_next(eventHandler) {
        var priorityLevel;

        switch (currentPriorityLevel) {
          case ImmediatePriority:
          case UserBlockingPriority:
          case NormalPriority:
            priorityLevel = NormalPriority;
            break;

          default:
            priorityLevel = currentPriorityLevel;
            break;
        }

        var previousPriorityLevel = currentPriorityLevel;
        currentPriorityLevel = priorityLevel;

        try {
          return eventHandler();
        } finally {
          currentPriorityLevel = previousPriorityLevel;
        }
      }

      function unstable_wrapCallback(callback) {
        var parentPriorityLevel = currentPriorityLevel;
        return function () {
          var previousPriorityLevel = currentPriorityLevel;
          currentPriorityLevel = parentPriorityLevel;

          try {
            return callback.apply(this, arguments);
          } finally {
            currentPriorityLevel = previousPriorityLevel;
          }
        };
      }

      function timeoutForPriorityLevel(priorityLevel) {
        switch (priorityLevel) {
          case ImmediatePriority:
            return IMMEDIATE_PRIORITY_TIMEOUT;

          case UserBlockingPriority:
            return USER_BLOCKING_PRIORITY;

          case IdlePriority:
            return IDLE_PRIORITY;

          case LowPriority:
            return LOW_PRIORITY_TIMEOUT;

          case NormalPriority:
          default:
            return NORMAL_PRIORITY_TIMEOUT;
        }
      }

      function unstable_scheduleCallback(priorityLevel, callback, options) {
        var currentTime = exports.unstable_now();
        var startTime;
        var timeout;

        if (typeof options === 'object' && options !== null) {
          var delay = options.delay;

          if (typeof delay === 'number' && delay > 0) {
            startTime = currentTime + delay;
          } else {
            startTime = currentTime;
          }

          timeout = typeof options.timeout === 'number' ? options.timeout : timeoutForPriorityLevel(priorityLevel);
        } else {
          timeout = timeoutForPriorityLevel(priorityLevel);
          startTime = currentTime;
        }

        var expirationTime = startTime + timeout;
        var newTask = {
          callback: callback,
          priorityLevel: priorityLevel,
          startTime: startTime,
          expirationTime: expirationTime,
          next: null,
          previous: null
        };

        if (startTime > currentTime) {
          insertDelayedTask(newTask, startTime);

          if (firstTask === null && firstDelayedTask === newTask) {
            if (isHostTimeoutScheduled) {
              cancelHostTimeout();
            } else {
              isHostTimeoutScheduled = true;
            }

            requestHostTimeout(handleTimeout, startTime - currentTime);
          }
        } else {
          insertScheduledTask(newTask, expirationTime);

          if (!isHostCallbackScheduled && !isPerformingWork) {
            isHostCallbackScheduled = true;

            _requestHostCallback(flushWork);
          }
        }

        return newTask;
      }

      function insertScheduledTask(newTask, expirationTime) {
        if (firstTask === null) {
          firstTask = newTask.next = newTask.previous = newTask;
        } else {
          var next = null;
          var task = firstTask;

          do {
            if (expirationTime < task.expirationTime) {
              next = task;
              break;
            }

            task = task.next;
          } while (task !== firstTask);

          if (next === null) {
            next = firstTask;
          } else if (next === firstTask) {
            firstTask = newTask;
          }

          var previous = next.previous;
          previous.next = next.previous = newTask;
          newTask.next = next;
          newTask.previous = previous;
        }
      }

      function insertDelayedTask(newTask, startTime) {
        if (firstDelayedTask === null) {
          firstDelayedTask = newTask.next = newTask.previous = newTask;
        } else {
          var next = null;
          var task = firstDelayedTask;

          do {
            if (startTime < task.startTime) {
              next = task;
              break;
            }

            task = task.next;
          } while (task !== firstDelayedTask);

          if (next === null) {
            next = firstDelayedTask;
          } else if (next === firstDelayedTask) {
            firstDelayedTask = newTask;
          }

          var previous = next.previous;
          previous.next = next.previous = newTask;
          newTask.next = next;
          newTask.previous = previous;
        }
      }

      function unstable_pauseExecution() {
        isSchedulerPaused = true;
      }

      function unstable_continueExecution() {
        isSchedulerPaused = false;

        if (!isHostCallbackScheduled && !isPerformingWork) {
          isHostCallbackScheduled = true;

          _requestHostCallback(flushWork);
        }
      }

      function unstable_getFirstCallbackNode() {
        return firstTask;
      }

      function unstable_cancelCallback(task) {
        var next = task.next;

        if (next === null) {
          return;
        }

        if (task === next) {
          if (task === firstTask) {
            firstTask = null;
          } else if (task === firstDelayedTask) {
            firstDelayedTask = null;
          }
        } else {
          if (task === firstTask) {
            firstTask = next;
          } else if (task === firstDelayedTask) {
            firstDelayedTask = next;
          }

          var previous = task.previous;
          previous.next = next;
          next.previous = previous;
        }

        task.next = task.previous = null;
      }

      function unstable_getCurrentPriorityLevel() {
        return currentPriorityLevel;
      }

      function unstable_shouldYield() {
        var currentTime = exports.unstable_now();
        advanceTimers(currentTime);
        return currentTask !== null && firstTask !== null && firstTask.startTime <= currentTime && firstTask.expirationTime < currentTask.expirationTime || shouldYieldToHost();
      }

      var unstable_requestPaint = requestPaint;
      exports.unstable_ImmediatePriority = ImmediatePriority;
      exports.unstable_UserBlockingPriority = UserBlockingPriority;
      exports.unstable_NormalPriority = NormalPriority;
      exports.unstable_IdlePriority = IdlePriority;
      exports.unstable_LowPriority = LowPriority;
      exports.unstable_runWithPriority = unstable_runWithPriority;
      exports.unstable_next = unstable_next;
      exports.unstable_scheduleCallback = unstable_scheduleCallback;
      exports.unstable_cancelCallback = unstable_cancelCallback;
      exports.unstable_wrapCallback = unstable_wrapCallback;
      exports.unstable_getCurrentPriorityLevel = unstable_getCurrentPriorityLevel;
      exports.unstable_shouldYield = unstable_shouldYield;
      exports.unstable_requestPaint = unstable_requestPaint;
      exports.unstable_continueExecution = unstable_continueExecution;
      exports.unstable_pauseExecution = unstable_pauseExecution;
      exports.unstable_getFirstCallbackNode = unstable_getFirstCallbackNode;
    })();
  }
},200,[],"node_modules/scheduler/cjs/scheduler.development.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  if (process.env.NODE_ENV === 'production') {
    module.exports = _$$_REQUIRE(_dependencyMap[0], "./cjs/scheduler-tracing.production.min.js");
  } else {
    module.exports = _$$_REQUIRE(_dependencyMap[1], "./cjs/scheduler-tracing.development.js");
  }
},201,[202,203],"node_modules/scheduler/tracing.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  /** @license React v0.15.0
   * scheduler-tracing.production.min.js
   *
   * 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.
   */
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: !0
  });
  var b = 0;
  exports.__interactionsRef = null;
  exports.__subscriberRef = null;

  exports.unstable_clear = function (a) {
    return a();
  };

  exports.unstable_getCurrent = function () {
    return null;
  };

  exports.unstable_getThreadID = function () {
    return ++b;
  };

  exports.unstable_trace = function (a, d, c) {
    return c();
  };

  exports.unstable_wrap = function (a) {
    return a;
  };

  exports.unstable_subscribe = function () {};

  exports.unstable_unsubscribe = function () {};
},202,[],"node_modules/scheduler/cjs/scheduler-tracing.production.min.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  /** @license React v0.15.0
   * scheduler-tracing.development.js
   *
   * 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.
   */
  'use strict';

  if (process.env.NODE_ENV !== "production") {
    (function () {
      'use strict';

      Object.defineProperty(exports, '__esModule', {
        value: true
      });
      var enableSchedulerTracing = true;
      var DEFAULT_THREAD_ID = 0;
      var interactionIDCounter = 0;
      var threadIDCounter = 0;
      exports.__interactionsRef = null;
      exports.__subscriberRef = null;

      if (enableSchedulerTracing) {
        exports.__interactionsRef = {
          current: new Set()
        };
        exports.__subscriberRef = {
          current: null
        };
      }

      function unstable_clear(callback) {
        if (!enableSchedulerTracing) {
          return callback();
        }

        var prevInteractions = exports.__interactionsRef.current;
        exports.__interactionsRef.current = new Set();

        try {
          return callback();
        } finally {
          exports.__interactionsRef.current = prevInteractions;
        }
      }

      function unstable_getCurrent() {
        if (!enableSchedulerTracing) {
          return null;
        } else {
          return exports.__interactionsRef.current;
        }
      }

      function unstable_getThreadID() {
        return ++threadIDCounter;
      }

      function unstable_trace(name, timestamp, callback) {
        var threadID = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : DEFAULT_THREAD_ID;

        if (!enableSchedulerTracing) {
          return callback();
        }

        var interaction = {
          __count: 1,
          id: interactionIDCounter++,
          name: name,
          timestamp: timestamp
        };
        var prevInteractions = exports.__interactionsRef.current;
        var interactions = new Set(prevInteractions);
        interactions.add(interaction);
        exports.__interactionsRef.current = interactions;
        var subscriber = exports.__subscriberRef.current;
        var returnValue = void 0;

        try {
          if (subscriber !== null) {
            subscriber.onInteractionTraced(interaction);
          }
        } finally {
          try {
            if (subscriber !== null) {
              subscriber.onWorkStarted(interactions, threadID);
            }
          } finally {
            try {
              returnValue = callback();
            } finally {
              exports.__interactionsRef.current = prevInteractions;

              try {
                if (subscriber !== null) {
                  subscriber.onWorkStopped(interactions, threadID);
                }
              } finally {
                interaction.__count--;

                if (subscriber !== null && interaction.__count === 0) {
                  subscriber.onInteractionScheduledWorkCompleted(interaction);
                }
              }
            }
          }
        }

        return returnValue;
      }

      function unstable_wrap(callback) {
        var threadID = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : DEFAULT_THREAD_ID;

        if (!enableSchedulerTracing) {
          return callback;
        }

        var wrappedInteractions = exports.__interactionsRef.current;
        var subscriber = exports.__subscriberRef.current;

        if (subscriber !== null) {
          subscriber.onWorkScheduled(wrappedInteractions, threadID);
        }

        wrappedInteractions.forEach(function (interaction) {
          interaction.__count++;
        });
        var hasRun = false;

        function wrapped() {
          var prevInteractions = exports.__interactionsRef.current;
          exports.__interactionsRef.current = wrappedInteractions;
          subscriber = exports.__subscriberRef.current;

          try {
            var returnValue = void 0;

            try {
              if (subscriber !== null) {
                subscriber.onWorkStarted(wrappedInteractions, threadID);
              }
            } finally {
              try {
                returnValue = callback.apply(undefined, arguments);
              } finally {
                exports.__interactionsRef.current = prevInteractions;

                if (subscriber !== null) {
                  subscriber.onWorkStopped(wrappedInteractions, threadID);
                }
              }
            }

            return returnValue;
          } finally {
            if (!hasRun) {
              hasRun = true;
              wrappedInteractions.forEach(function (interaction) {
                interaction.__count--;

                if (subscriber !== null && interaction.__count === 0) {
                  subscriber.onInteractionScheduledWorkCompleted(interaction);
                }
              });
            }
          }
        }

        wrapped.cancel = function cancel() {
          subscriber = exports.__subscriberRef.current;

          try {
            if (subscriber !== null) {
              subscriber.onWorkCanceled(wrappedInteractions, threadID);
            }
          } finally {
            wrappedInteractions.forEach(function (interaction) {
              interaction.__count--;

              if (subscriber && interaction.__count === 0) {
                subscriber.onInteractionScheduledWorkCompleted(interaction);
              }
            });
          }
        };

        return wrapped;
      }

      var subscribers = null;

      if (enableSchedulerTracing) {
        subscribers = new Set();
      }

      function unstable_subscribe(subscriber) {
        if (enableSchedulerTracing) {
          subscribers.add(subscriber);

          if (subscribers.size === 1) {
            exports.__subscriberRef.current = {
              onInteractionScheduledWorkCompleted: onInteractionScheduledWorkCompleted,
              onInteractionTraced: onInteractionTraced,
              onWorkCanceled: onWorkCanceled,
              onWorkScheduled: onWorkScheduled,
              onWorkStarted: onWorkStarted,
              onWorkStopped: onWorkStopped
            };
          }
        }
      }

      function unstable_unsubscribe(subscriber) {
        if (enableSchedulerTracing) {
          subscribers.delete(subscriber);

          if (subscribers.size === 0) {
            exports.__subscriberRef.current = null;
          }
        }
      }

      function onInteractionTraced(interaction) {
        var didCatchError = false;
        var caughtError = null;
        subscribers.forEach(function (subscriber) {
          try {
            subscriber.onInteractionTraced(interaction);
          } catch (error) {
            if (!didCatchError) {
              didCatchError = true;
              caughtError = error;
            }
          }
        });

        if (didCatchError) {
          throw caughtError;
        }
      }

      function onInteractionScheduledWorkCompleted(interaction) {
        var didCatchError = false;
        var caughtError = null;
        subscribers.forEach(function (subscriber) {
          try {
            subscriber.onInteractionScheduledWorkCompleted(interaction);
          } catch (error) {
            if (!didCatchError) {
              didCatchError = true;
              caughtError = error;
            }
          }
        });

        if (didCatchError) {
          throw caughtError;
        }
      }

      function onWorkScheduled(interactions, threadID) {
        var didCatchError = false;
        var caughtError = null;
        subscribers.forEach(function (subscriber) {
          try {
            subscriber.onWorkScheduled(interactions, threadID);
          } catch (error) {
            if (!didCatchError) {
              didCatchError = true;
              caughtError = error;
            }
          }
        });

        if (didCatchError) {
          throw caughtError;
        }
      }

      function onWorkStarted(interactions, threadID) {
        var didCatchError = false;
        var caughtError = null;
        subscribers.forEach(function (subscriber) {
          try {
            subscriber.onWorkStarted(interactions, threadID);
          } catch (error) {
            if (!didCatchError) {
              didCatchError = true;
              caughtError = error;
            }
          }
        });

        if (didCatchError) {
          throw caughtError;
        }
      }

      function onWorkStopped(interactions, threadID) {
        var didCatchError = false;
        var caughtError = null;
        subscribers.forEach(function (subscriber) {
          try {
            subscriber.onWorkStopped(interactions, threadID);
          } catch (error) {
            if (!didCatchError) {
              didCatchError = true;
              caughtError = error;
            }
          }
        });

        if (didCatchError) {
          throw caughtError;
        }
      }

      function onWorkCanceled(interactions, threadID) {
        var didCatchError = false;
        var caughtError = null;
        subscribers.forEach(function (subscriber) {
          try {
            subscriber.onWorkCanceled(interactions, threadID);
          } catch (error) {
            if (!didCatchError) {
              didCatchError = true;
              caughtError = error;
            }
          }
        });

        if (didCatchError) {
          throw caughtError;
        }
      }

      exports.unstable_clear = unstable_clear;
      exports.unstable_getCurrent = unstable_getCurrent;
      exports.unstable_getThreadID = unstable_getThreadID;
      exports.unstable_trace = unstable_trace;
      exports.unstable_wrap = unstable_wrap;
      exports.unstable_subscribe = unstable_subscribe;
      exports.unstable_unsubscribe = unstable_unsubscribe;
    })();
  }
},203,[],"node_modules/scheduler/cjs/scheduler-tracing.development.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  "use strict";

  var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");

  _$$_REQUIRE(_dependencyMap[1], "react-native/Libraries/ReactPrivate/ReactNativePrivateInitializeCore");

  var ReactNativePrivateInterface = _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface"),
      React = _$$_REQUIRE(_dependencyMap[3], "react"),
      Scheduler = _$$_REQUIRE(_dependencyMap[4], "scheduler");

  function ReactError(error) {
    error.name = "Invariant Violation";
    return error;
  }

  var eventPluginOrder = null,
      namesToPlugins = {};

  function recomputePluginOrdering() {
    if (eventPluginOrder) for (var pluginName in namesToPlugins) {
      var pluginModule = namesToPlugins[pluginName],
          pluginIndex = eventPluginOrder.indexOf(pluginName);
      if (!(-1 < pluginIndex)) throw ReactError(Error("EventPluginRegistry: Cannot inject event plugins that do not exist in the plugin ordering, `" + pluginName + "`."));

      if (!plugins[pluginIndex]) {
        if (!pluginModule.extractEvents) throw ReactError(Error("EventPluginRegistry: Event plugins must implement an `extractEvents` method, but `" + pluginName + "` does not."));
        plugins[pluginIndex] = pluginModule;
        pluginIndex = pluginModule.eventTypes;

        for (var eventName in pluginIndex) {
          var JSCompiler_inline_result = void 0;
          var dispatchConfig = pluginIndex[eventName],
              pluginModule$jscomp$0 = pluginModule,
              eventName$jscomp$0 = eventName;
          if (eventNameDispatchConfigs.hasOwnProperty(eventName$jscomp$0)) throw ReactError(Error("EventPluginHub: More than one plugin attempted to publish the same event name, `" + eventName$jscomp$0 + "`."));
          eventNameDispatchConfigs[eventName$jscomp$0] = dispatchConfig;
          var phasedRegistrationNames = dispatchConfig.phasedRegistrationNames;

          if (phasedRegistrationNames) {
            for (JSCompiler_inline_result in phasedRegistrationNames) {
              phasedRegistrationNames.hasOwnProperty(JSCompiler_inline_result) && publishRegistrationName(phasedRegistrationNames[JSCompiler_inline_result], pluginModule$jscomp$0, eventName$jscomp$0);
            }

            JSCompiler_inline_result = !0;
          } else dispatchConfig.registrationName ? (publishRegistrationName(dispatchConfig.registrationName, pluginModule$jscomp$0, eventName$jscomp$0), JSCompiler_inline_result = !0) : JSCompiler_inline_result = !1;

          if (!JSCompiler_inline_result) throw ReactError(Error("EventPluginRegistry: Failed to publish event `" + eventName + "` for plugin `" + pluginName + "`."));
        }
      }
    }
  }

  function publishRegistrationName(registrationName, pluginModule) {
    if (registrationNameModules[registrationName]) throw ReactError(Error("EventPluginHub: More than one plugin attempted to publish the same registration name, `" + registrationName + "`."));
    registrationNameModules[registrationName] = pluginModule;
  }

  var plugins = [],
      eventNameDispatchConfigs = {},
      registrationNameModules = {};

  function invokeGuardedCallbackImpl(name, func, context, a, b, c, d, e, f) {
    var funcArgs = Array.prototype.slice.call(arguments, 3);

    try {
      func.apply(context, funcArgs);
    } catch (error) {
      this.onError(error);
    }
  }

  var hasError = !1,
      caughtError = null,
      hasRethrowError = !1,
      rethrowError = null,
      reporter = {
    onError: function onError(error) {
      hasError = !0;
      caughtError = error;
    }
  };

  function invokeGuardedCallback(name, func, context, a, b, c, d, e, f) {
    hasError = !1;
    caughtError = null;
    invokeGuardedCallbackImpl.apply(reporter, arguments);
  }

  function invokeGuardedCallbackAndCatchFirstError(name, func, context, a, b, c, d, e, f) {
    invokeGuardedCallback.apply(this, arguments);

    if (hasError) {
      if (hasError) {
        var error = caughtError;
        hasError = !1;
        caughtError = null;
      } else throw ReactError(Error("clearCaughtError was called but no error was captured. This error is likely caused by a bug in React. Please file an issue."));

      hasRethrowError || (hasRethrowError = !0, rethrowError = error);
    }
  }

  var getFiberCurrentPropsFromNode = null,
      getInstanceFromNode = null,
      getNodeFromInstance = null;

  function executeDispatch(event, listener, inst) {
    var type = event.type || "unknown-event";
    event.currentTarget = getNodeFromInstance(inst);
    invokeGuardedCallbackAndCatchFirstError(type, listener, void 0, event);
    event.currentTarget = null;
  }

  function executeDirectDispatch(event) {
    var dispatchListener = event._dispatchListeners,
        dispatchInstance = event._dispatchInstances;
    if (Array.isArray(dispatchListener)) throw ReactError(Error("executeDirectDispatch(...): Invalid `event`."));
    event.currentTarget = dispatchListener ? getNodeFromInstance(dispatchInstance) : null;
    dispatchListener = dispatchListener ? dispatchListener(event) : null;
    event.currentTarget = null;
    event._dispatchListeners = null;
    event._dispatchInstances = null;
    return dispatchListener;
  }

  function accumulateInto(current, next) {
    if (null == next) throw ReactError(Error("accumulateInto(...): Accumulated items must not be null or undefined."));
    if (null == current) return next;

    if (Array.isArray(current)) {
      if (Array.isArray(next)) return current.push.apply(current, next), current;
      current.push(next);
      return current;
    }

    return Array.isArray(next) ? [current].concat(next) : [current, next];
  }

  function forEachAccumulated(arr, cb, scope) {
    Array.isArray(arr) ? arr.forEach(cb, scope) : arr && cb.call(scope, arr);
  }

  var eventQueue = null;

  function executeDispatchesAndReleaseTopLevel(e) {
    if (e) {
      var dispatchListeners = e._dispatchListeners,
          dispatchInstances = e._dispatchInstances;
      if (Array.isArray(dispatchListeners)) for (var i = 0; i < dispatchListeners.length && !e.isPropagationStopped(); i++) {
        executeDispatch(e, dispatchListeners[i], dispatchInstances[i]);
      } else dispatchListeners && executeDispatch(e, dispatchListeners, dispatchInstances);
      e._dispatchListeners = null;
      e._dispatchInstances = null;
      e.isPersistent() || e.constructor.release(e);
    }
  }

  var injection = {
    injectEventPluginOrder: function injectEventPluginOrder(injectedEventPluginOrder) {
      if (eventPluginOrder) throw ReactError(Error("EventPluginRegistry: Cannot inject event plugin ordering more than once. You are likely trying to load more than one copy of React."));
      eventPluginOrder = Array.prototype.slice.call(injectedEventPluginOrder);
      recomputePluginOrdering();
    },
    injectEventPluginsByName: function injectEventPluginsByName(injectedNamesToPlugins) {
      var isOrderingDirty = !1,
          pluginName;

      for (pluginName in injectedNamesToPlugins) {
        if (injectedNamesToPlugins.hasOwnProperty(pluginName)) {
          var pluginModule = injectedNamesToPlugins[pluginName];

          if (!namesToPlugins.hasOwnProperty(pluginName) || namesToPlugins[pluginName] !== pluginModule) {
            if (namesToPlugins[pluginName]) throw ReactError(Error("EventPluginRegistry: Cannot inject two different event plugins using the same name, `" + pluginName + "`."));
            namesToPlugins[pluginName] = pluginModule;
            isOrderingDirty = !0;
          }
        }
      }

      isOrderingDirty && recomputePluginOrdering();
    }
  };

  function getListener(inst, registrationName) {
    var listener = inst.stateNode;
    if (!listener) return null;
    var props = getFiberCurrentPropsFromNode(listener);
    if (!props) return null;
    listener = props[registrationName];

    a: switch (registrationName) {
      case "onClick":
      case "onClickCapture":
      case "onDoubleClick":
      case "onDoubleClickCapture":
      case "onMouseDown":
      case "onMouseDownCapture":
      case "onMouseMove":
      case "onMouseMoveCapture":
      case "onMouseUp":
      case "onMouseUpCapture":
        (props = !props.disabled) || (inst = inst.type, props = !("button" === inst || "input" === inst || "select" === inst || "textarea" === inst));
        inst = !props;
        break a;

      default:
        inst = !1;
    }

    if (inst) return null;
    if (listener && "function" !== typeof listener) throw ReactError(Error("Expected `" + registrationName + "` listener to be a function, instead got a value of `" + typeof listener + "` type."));
    return listener;
  }

  function getParent(inst) {
    do {
      inst = inst.return;
    } while (inst && 5 !== inst.tag);

    return inst ? inst : null;
  }

  function traverseTwoPhase(inst, fn, arg) {
    for (var path = []; inst;) {
      path.push(inst), inst = getParent(inst);
    }

    for (inst = path.length; 0 < inst--;) {
      fn(path[inst], "captured", arg);
    }

    for (inst = 0; inst < path.length; inst++) {
      fn(path[inst], "bubbled", arg);
    }
  }

  function accumulateDirectionalDispatches(inst, phase, event) {
    if (phase = getListener(inst, event.dispatchConfig.phasedRegistrationNames[phase])) event._dispatchListeners = accumulateInto(event._dispatchListeners, phase), event._dispatchInstances = accumulateInto(event._dispatchInstances, inst);
  }

  function accumulateTwoPhaseDispatchesSingle(event) {
    event && event.dispatchConfig.phasedRegistrationNames && traverseTwoPhase(event._targetInst, accumulateDirectionalDispatches, event);
  }

  function accumulateTwoPhaseDispatchesSingleSkipTarget(event) {
    if (event && event.dispatchConfig.phasedRegistrationNames) {
      var targetInst = event._targetInst;
      targetInst = targetInst ? getParent(targetInst) : null;
      traverseTwoPhase(targetInst, accumulateDirectionalDispatches, event);
    }
  }

  function accumulateDirectDispatchesSingle(event) {
    if (event && event.dispatchConfig.registrationName) {
      var inst = event._targetInst;

      if (inst && event && event.dispatchConfig.registrationName) {
        var listener = getListener(inst, event.dispatchConfig.registrationName);
        listener && (event._dispatchListeners = accumulateInto(event._dispatchListeners, listener), event._dispatchInstances = accumulateInto(event._dispatchInstances, inst));
      }
    }
  }

  function functionThatReturnsTrue() {
    return !0;
  }

  function functionThatReturnsFalse() {
    return !1;
  }

  function SyntheticEvent(dispatchConfig, targetInst, nativeEvent, nativeEventTarget) {
    this.dispatchConfig = dispatchConfig;
    this._targetInst = targetInst;
    this.nativeEvent = nativeEvent;
    dispatchConfig = this.constructor.Interface;

    for (var propName in dispatchConfig) {
      dispatchConfig.hasOwnProperty(propName) && ((targetInst = dispatchConfig[propName]) ? this[propName] = targetInst(nativeEvent) : "target" === propName ? this.target = nativeEventTarget : this[propName] = nativeEvent[propName]);
    }

    this.isDefaultPrevented = (null != nativeEvent.defaultPrevented ? nativeEvent.defaultPrevented : !1 === nativeEvent.returnValue) ? functionThatReturnsTrue : functionThatReturnsFalse;
    this.isPropagationStopped = functionThatReturnsFalse;
    return this;
  }

  _extends(SyntheticEvent.prototype, {
    preventDefault: function preventDefault() {
      this.defaultPrevented = !0;
      var event = this.nativeEvent;
      event && (event.preventDefault ? event.preventDefault() : "unknown" !== typeof event.returnValue && (event.returnValue = !1), this.isDefaultPrevented = functionThatReturnsTrue);
    },
    stopPropagation: function stopPropagation() {
      var event = this.nativeEvent;
      event && (event.stopPropagation ? event.stopPropagation() : "unknown" !== typeof event.cancelBubble && (event.cancelBubble = !0), this.isPropagationStopped = functionThatReturnsTrue);
    },
    persist: function persist() {
      this.isPersistent = functionThatReturnsTrue;
    },
    isPersistent: functionThatReturnsFalse,
    destructor: function destructor() {
      var Interface = this.constructor.Interface,
          propName;

      for (propName in Interface) {
        this[propName] = null;
      }

      this.nativeEvent = this._targetInst = this.dispatchConfig = null;
      this.isPropagationStopped = this.isDefaultPrevented = functionThatReturnsFalse;
      this._dispatchInstances = this._dispatchListeners = null;
    }
  });

  SyntheticEvent.Interface = {
    type: null,
    target: null,
    currentTarget: function currentTarget() {
      return null;
    },
    eventPhase: null,
    bubbles: null,
    cancelable: null,
    timeStamp: function timeStamp(event) {
      return event.timeStamp || Date.now();
    },
    defaultPrevented: null,
    isTrusted: null
  };

  SyntheticEvent.extend = function (Interface) {
    function E() {}

    function Class() {
      return Super.apply(this, arguments);
    }

    var Super = this;
    E.prototype = Super.prototype;
    var prototype = new E();

    _extends(prototype, Class.prototype);

    Class.prototype = prototype;
    Class.prototype.constructor = Class;
    Class.Interface = _extends({}, Super.Interface, Interface);
    Class.extend = Super.extend;
    addEventPoolingTo(Class);
    return Class;
  };

  addEventPoolingTo(SyntheticEvent);

  function getPooledEvent(dispatchConfig, targetInst, nativeEvent, nativeInst) {
    if (this.eventPool.length) {
      var instance = this.eventPool.pop();
      this.call(instance, dispatchConfig, targetInst, nativeEvent, nativeInst);
      return instance;
    }

    return new this(dispatchConfig, targetInst, nativeEvent, nativeInst);
  }

  function releasePooledEvent(event) {
    if (!(event instanceof this)) throw ReactError(Error("Trying to release an event instance into a pool of a different type."));
    event.destructor();
    10 > this.eventPool.length && this.eventPool.push(event);
  }

  function addEventPoolingTo(EventConstructor) {
    EventConstructor.eventPool = [];
    EventConstructor.getPooled = getPooledEvent;
    EventConstructor.release = releasePooledEvent;
  }

  var ResponderSyntheticEvent = SyntheticEvent.extend({
    touchHistory: function touchHistory() {
      return null;
    }
  });

  function isStartish(topLevelType) {
    return "topTouchStart" === topLevelType;
  }

  function isMoveish(topLevelType) {
    return "topTouchMove" === topLevelType;
  }

  var startDependencies = ["topTouchStart"],
      moveDependencies = ["topTouchMove"],
      endDependencies = ["topTouchCancel", "topTouchEnd"],
      touchBank = [],
      touchHistory = {
    touchBank: touchBank,
    numberActiveTouches: 0,
    indexOfSingleActiveTouch: -1,
    mostRecentTimeStamp: 0
  };

  function timestampForTouch(touch) {
    return touch.timeStamp || touch.timestamp;
  }

  function getTouchIdentifier(_ref) {
    _ref = _ref.identifier;
    if (null == _ref) throw ReactError(Error("Touch object is missing identifier."));
    return _ref;
  }

  function recordTouchStart(touch) {
    var identifier = getTouchIdentifier(touch),
        touchRecord = touchBank[identifier];
    touchRecord ? (touchRecord.touchActive = !0, touchRecord.startPageX = touch.pageX, touchRecord.startPageY = touch.pageY, touchRecord.startTimeStamp = timestampForTouch(touch), touchRecord.currentPageX = touch.pageX, touchRecord.currentPageY = touch.pageY, touchRecord.currentTimeStamp = timestampForTouch(touch), touchRecord.previousPageX = touch.pageX, touchRecord.previousPageY = touch.pageY, touchRecord.previousTimeStamp = timestampForTouch(touch)) : (touchRecord = {
      touchActive: !0,
      startPageX: touch.pageX,
      startPageY: touch.pageY,
      startTimeStamp: timestampForTouch(touch),
      currentPageX: touch.pageX,
      currentPageY: touch.pageY,
      currentTimeStamp: timestampForTouch(touch),
      previousPageX: touch.pageX,
      previousPageY: touch.pageY,
      previousTimeStamp: timestampForTouch(touch)
    }, touchBank[identifier] = touchRecord);
    touchHistory.mostRecentTimeStamp = timestampForTouch(touch);
  }

  function recordTouchMove(touch) {
    var touchRecord = touchBank[getTouchIdentifier(touch)];
    touchRecord ? (touchRecord.touchActive = !0, touchRecord.previousPageX = touchRecord.currentPageX, touchRecord.previousPageY = touchRecord.currentPageY, touchRecord.previousTimeStamp = touchRecord.currentTimeStamp, touchRecord.currentPageX = touch.pageX, touchRecord.currentPageY = touch.pageY, touchRecord.currentTimeStamp = timestampForTouch(touch), touchHistory.mostRecentTimeStamp = timestampForTouch(touch)) : console.warn("Cannot record touch move without a touch start.\nTouch Move: %s\n", "Touch Bank: %s", printTouch(touch), printTouchBank());
  }

  function recordTouchEnd(touch) {
    var touchRecord = touchBank[getTouchIdentifier(touch)];
    touchRecord ? (touchRecord.touchActive = !1, touchRecord.previousPageX = touchRecord.currentPageX, touchRecord.previousPageY = touchRecord.currentPageY, touchRecord.previousTimeStamp = touchRecord.currentTimeStamp, touchRecord.currentPageX = touch.pageX, touchRecord.currentPageY = touch.pageY, touchRecord.currentTimeStamp = timestampForTouch(touch), touchHistory.mostRecentTimeStamp = timestampForTouch(touch)) : console.warn("Cannot record touch end without a touch start.\nTouch End: %s\n", "Touch Bank: %s", printTouch(touch), printTouchBank());
  }

  function printTouch(touch) {
    return JSON.stringify({
      identifier: touch.identifier,
      pageX: touch.pageX,
      pageY: touch.pageY,
      timestamp: timestampForTouch(touch)
    });
  }

  function printTouchBank() {
    var printed = JSON.stringify(touchBank.slice(0, 20));
    20 < touchBank.length && (printed += " (original size: " + touchBank.length + ")");
    return printed;
  }

  var ResponderTouchHistoryStore = {
    recordTouchTrack: function recordTouchTrack(topLevelType, nativeEvent) {
      if (isMoveish(topLevelType)) nativeEvent.changedTouches.forEach(recordTouchMove);else if (isStartish(topLevelType)) nativeEvent.changedTouches.forEach(recordTouchStart), touchHistory.numberActiveTouches = nativeEvent.touches.length, 1 === touchHistory.numberActiveTouches && (touchHistory.indexOfSingleActiveTouch = nativeEvent.touches[0].identifier);else if ("topTouchEnd" === topLevelType || "topTouchCancel" === topLevelType) if (nativeEvent.changedTouches.forEach(recordTouchEnd), touchHistory.numberActiveTouches = nativeEvent.touches.length, 1 === touchHistory.numberActiveTouches) for (topLevelType = 0; topLevelType < touchBank.length; topLevelType++) {
        if (nativeEvent = touchBank[topLevelType], null != nativeEvent && nativeEvent.touchActive) {
          touchHistory.indexOfSingleActiveTouch = topLevelType;
          break;
        }
      }
    },
    touchHistory: touchHistory
  };

  function accumulate(current, next) {
    if (null == next) throw ReactError(Error("accumulate(...): Accumulated items must not be null or undefined."));
    return null == current ? next : Array.isArray(current) ? current.concat(next) : Array.isArray(next) ? [current].concat(next) : [current, next];
  }

  var responderInst = null,
      trackedTouchCount = 0;

  function changeResponder(nextResponderInst, blockHostResponder) {
    var oldResponderInst = responderInst;
    responderInst = nextResponderInst;
    if (null !== ResponderEventPlugin.GlobalResponderHandler) ResponderEventPlugin.GlobalResponderHandler.onChange(oldResponderInst, nextResponderInst, blockHostResponder);
  }

  var eventTypes = {
    startShouldSetResponder: {
      phasedRegistrationNames: {
        bubbled: "onStartShouldSetResponder",
        captured: "onStartShouldSetResponderCapture"
      },
      dependencies: startDependencies
    },
    scrollShouldSetResponder: {
      phasedRegistrationNames: {
        bubbled: "onScrollShouldSetResponder",
        captured: "onScrollShouldSetResponderCapture"
      },
      dependencies: ["topScroll"]
    },
    selectionChangeShouldSetResponder: {
      phasedRegistrationNames: {
        bubbled: "onSelectionChangeShouldSetResponder",
        captured: "onSelectionChangeShouldSetResponderCapture"
      },
      dependencies: ["topSelectionChange"]
    },
    moveShouldSetResponder: {
      phasedRegistrationNames: {
        bubbled: "onMoveShouldSetResponder",
        captured: "onMoveShouldSetResponderCapture"
      },
      dependencies: moveDependencies
    },
    responderStart: {
      registrationName: "onResponderStart",
      dependencies: startDependencies
    },
    responderMove: {
      registrationName: "onResponderMove",
      dependencies: moveDependencies
    },
    responderEnd: {
      registrationName: "onResponderEnd",
      dependencies: endDependencies
    },
    responderRelease: {
      registrationName: "onResponderRelease",
      dependencies: endDependencies
    },
    responderTerminationRequest: {
      registrationName: "onResponderTerminationRequest",
      dependencies: []
    },
    responderGrant: {
      registrationName: "onResponderGrant",
      dependencies: []
    },
    responderReject: {
      registrationName: "onResponderReject",
      dependencies: []
    },
    responderTerminate: {
      registrationName: "onResponderTerminate",
      dependencies: []
    }
  },
      ResponderEventPlugin = {
    _getResponder: function _getResponder() {
      return responderInst;
    },
    eventTypes: eventTypes,
    extractEvents: function extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
      if (isStartish(topLevelType)) trackedTouchCount += 1;else if ("topTouchEnd" === topLevelType || "topTouchCancel" === topLevelType) if (0 <= trackedTouchCount) --trackedTouchCount;else return console.error("Ended a touch event which was not counted in `trackedTouchCount`."), null;
      ResponderTouchHistoryStore.recordTouchTrack(topLevelType, nativeEvent);

      if (targetInst && ("topScroll" === topLevelType && !nativeEvent.responderIgnoreScroll || 0 < trackedTouchCount && "topSelectionChange" === topLevelType || isStartish(topLevelType) || isMoveish(topLevelType))) {
        var JSCompiler_temp = isStartish(topLevelType) ? eventTypes.startShouldSetResponder : isMoveish(topLevelType) ? eventTypes.moveShouldSetResponder : "topSelectionChange" === topLevelType ? eventTypes.selectionChangeShouldSetResponder : eventTypes.scrollShouldSetResponder;
        if (responderInst) b: {
          var JSCompiler_temp$jscomp$0 = responderInst;

          for (var depthA = 0, tempA = JSCompiler_temp$jscomp$0; tempA; tempA = getParent(tempA)) {
            depthA++;
          }

          tempA = 0;

          for (var tempB = targetInst; tempB; tempB = getParent(tempB)) {
            tempA++;
          }

          for (; 0 < depthA - tempA;) {
            JSCompiler_temp$jscomp$0 = getParent(JSCompiler_temp$jscomp$0), depthA--;
          }

          for (; 0 < tempA - depthA;) {
            targetInst = getParent(targetInst), tempA--;
          }

          for (; depthA--;) {
            if (JSCompiler_temp$jscomp$0 === targetInst || JSCompiler_temp$jscomp$0 === targetInst.alternate) break b;
            JSCompiler_temp$jscomp$0 = getParent(JSCompiler_temp$jscomp$0);
            targetInst = getParent(targetInst);
          }

          JSCompiler_temp$jscomp$0 = null;
        } else JSCompiler_temp$jscomp$0 = targetInst;
        targetInst = JSCompiler_temp$jscomp$0 === responderInst;
        JSCompiler_temp$jscomp$0 = ResponderSyntheticEvent.getPooled(JSCompiler_temp, JSCompiler_temp$jscomp$0, nativeEvent, nativeEventTarget);
        JSCompiler_temp$jscomp$0.touchHistory = ResponderTouchHistoryStore.touchHistory;
        targetInst ? forEachAccumulated(JSCompiler_temp$jscomp$0, accumulateTwoPhaseDispatchesSingleSkipTarget) : forEachAccumulated(JSCompiler_temp$jscomp$0, accumulateTwoPhaseDispatchesSingle);

        b: {
          JSCompiler_temp = JSCompiler_temp$jscomp$0._dispatchListeners;
          targetInst = JSCompiler_temp$jscomp$0._dispatchInstances;
          if (Array.isArray(JSCompiler_temp)) for (depthA = 0; depthA < JSCompiler_temp.length && !JSCompiler_temp$jscomp$0.isPropagationStopped(); depthA++) {
            if (JSCompiler_temp[depthA](JSCompiler_temp$jscomp$0, targetInst[depthA])) {
              JSCompiler_temp = targetInst[depthA];
              break b;
            }
          } else if (JSCompiler_temp && JSCompiler_temp(JSCompiler_temp$jscomp$0, targetInst)) {
            JSCompiler_temp = targetInst;
            break b;
          }
          JSCompiler_temp = null;
        }

        JSCompiler_temp$jscomp$0._dispatchInstances = null;
        JSCompiler_temp$jscomp$0._dispatchListeners = null;
        JSCompiler_temp$jscomp$0.isPersistent() || JSCompiler_temp$jscomp$0.constructor.release(JSCompiler_temp$jscomp$0);
        JSCompiler_temp && JSCompiler_temp !== responderInst ? (JSCompiler_temp$jscomp$0 = void 0, targetInst = ResponderSyntheticEvent.getPooled(eventTypes.responderGrant, JSCompiler_temp, nativeEvent, nativeEventTarget), targetInst.touchHistory = ResponderTouchHistoryStore.touchHistory, forEachAccumulated(targetInst, accumulateDirectDispatchesSingle), depthA = !0 === executeDirectDispatch(targetInst), responderInst ? (tempA = ResponderSyntheticEvent.getPooled(eventTypes.responderTerminationRequest, responderInst, nativeEvent, nativeEventTarget), tempA.touchHistory = ResponderTouchHistoryStore.touchHistory, forEachAccumulated(tempA, accumulateDirectDispatchesSingle), tempB = !tempA._dispatchListeners || executeDirectDispatch(tempA), tempA.isPersistent() || tempA.constructor.release(tempA), tempB ? (tempA = ResponderSyntheticEvent.getPooled(eventTypes.responderTerminate, responderInst, nativeEvent, nativeEventTarget), tempA.touchHistory = ResponderTouchHistoryStore.touchHistory, forEachAccumulated(tempA, accumulateDirectDispatchesSingle), JSCompiler_temp$jscomp$0 = accumulate(JSCompiler_temp$jscomp$0, [targetInst, tempA]), changeResponder(JSCompiler_temp, depthA)) : (JSCompiler_temp = ResponderSyntheticEvent.getPooled(eventTypes.responderReject, JSCompiler_temp, nativeEvent, nativeEventTarget), JSCompiler_temp.touchHistory = ResponderTouchHistoryStore.touchHistory, forEachAccumulated(JSCompiler_temp, accumulateDirectDispatchesSingle), JSCompiler_temp$jscomp$0 = accumulate(JSCompiler_temp$jscomp$0, JSCompiler_temp))) : (JSCompiler_temp$jscomp$0 = accumulate(JSCompiler_temp$jscomp$0, targetInst), changeResponder(JSCompiler_temp, depthA)), JSCompiler_temp = JSCompiler_temp$jscomp$0) : JSCompiler_temp = null;
      } else JSCompiler_temp = null;

      JSCompiler_temp$jscomp$0 = responderInst && isStartish(topLevelType);
      targetInst = responderInst && isMoveish(topLevelType);
      depthA = responderInst && ("topTouchEnd" === topLevelType || "topTouchCancel" === topLevelType);
      if (JSCompiler_temp$jscomp$0 = JSCompiler_temp$jscomp$0 ? eventTypes.responderStart : targetInst ? eventTypes.responderMove : depthA ? eventTypes.responderEnd : null) JSCompiler_temp$jscomp$0 = ResponderSyntheticEvent.getPooled(JSCompiler_temp$jscomp$0, responderInst, nativeEvent, nativeEventTarget), JSCompiler_temp$jscomp$0.touchHistory = ResponderTouchHistoryStore.touchHistory, forEachAccumulated(JSCompiler_temp$jscomp$0, accumulateDirectDispatchesSingle), JSCompiler_temp = accumulate(JSCompiler_temp, JSCompiler_temp$jscomp$0);
      JSCompiler_temp$jscomp$0 = responderInst && "topTouchCancel" === topLevelType;
      if (topLevelType = responderInst && !JSCompiler_temp$jscomp$0 && ("topTouchEnd" === topLevelType || "topTouchCancel" === topLevelType)) a: {
        if ((topLevelType = nativeEvent.touches) && 0 !== topLevelType.length) for (targetInst = 0; targetInst < topLevelType.length; targetInst++) {
          if (depthA = topLevelType[targetInst].target, null !== depthA && void 0 !== depthA && 0 !== depthA) {
            tempA = getInstanceFromNode(depthA);

            b: {
              for (depthA = responderInst; tempA;) {
                if (depthA === tempA || depthA === tempA.alternate) {
                  depthA = !0;
                  break b;
                }

                tempA = getParent(tempA);
              }

              depthA = !1;
            }

            if (depthA) {
              topLevelType = !1;
              break a;
            }
          }
        }
        topLevelType = !0;
      }
      if (topLevelType = JSCompiler_temp$jscomp$0 ? eventTypes.responderTerminate : topLevelType ? eventTypes.responderRelease : null) nativeEvent = ResponderSyntheticEvent.getPooled(topLevelType, responderInst, nativeEvent, nativeEventTarget), nativeEvent.touchHistory = ResponderTouchHistoryStore.touchHistory, forEachAccumulated(nativeEvent, accumulateDirectDispatchesSingle), JSCompiler_temp = accumulate(JSCompiler_temp, nativeEvent), changeResponder(null);
      return JSCompiler_temp;
    },
    GlobalResponderHandler: null,
    injection: {
      injectGlobalResponderHandler: function injectGlobalResponderHandler(GlobalResponderHandler) {
        ResponderEventPlugin.GlobalResponderHandler = GlobalResponderHandler;
      }
    }
  },
      customBubblingEventTypes = ReactNativePrivateInterface.ReactNativeViewConfigRegistry.customBubblingEventTypes,
      customDirectEventTypes = ReactNativePrivateInterface.ReactNativeViewConfigRegistry.customDirectEventTypes;
  injection.injectEventPluginOrder(["ResponderEventPlugin", "ReactNativeBridgeEventPlugin"]);
  injection.injectEventPluginsByName({
    ResponderEventPlugin: ResponderEventPlugin,
    ReactNativeBridgeEventPlugin: {
      eventTypes: {},
      extractEvents: function extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
        if (null == targetInst) return null;
        var bubbleDispatchConfig = customBubblingEventTypes[topLevelType],
            directDispatchConfig = customDirectEventTypes[topLevelType];
        if (!bubbleDispatchConfig && !directDispatchConfig) throw ReactError(Error('Unsupported top level event type "' + topLevelType + '" dispatched'));
        topLevelType = SyntheticEvent.getPooled(bubbleDispatchConfig || directDispatchConfig, targetInst, nativeEvent, nativeEventTarget);
        if (bubbleDispatchConfig) forEachAccumulated(topLevelType, accumulateTwoPhaseDispatchesSingle);else if (directDispatchConfig) forEachAccumulated(topLevelType, accumulateDirectDispatchesSingle);else return null;
        return topLevelType;
      }
    }
  });
  var instanceCache = new Map(),
      instanceProps = new Map();

  function getInstanceFromTag(tag) {
    return instanceCache.get(tag) || null;
  }

  var restoreTarget = null,
      restoreQueue = null;

  function restoreStateOfTarget(target) {
    if (getInstanceFromNode(target)) throw ReactError(Error("setRestoreImplementation() needs to be called to handle a target for controlled events. This error is likely caused by a bug in React. Please file an issue."));
  }

  function batchedUpdatesImpl(fn, bookkeeping) {
    return fn(bookkeeping);
  }

  function flushDiscreteUpdatesImpl() {}

  var isInsideEventHandler = !1;

  function batchedUpdates(fn, bookkeeping) {
    if (isInsideEventHandler) return fn(bookkeeping);
    isInsideEventHandler = !0;

    try {
      return batchedUpdatesImpl(fn, bookkeeping);
    } finally {
      if (isInsideEventHandler = !1, null !== restoreTarget || null !== restoreQueue) if (flushDiscreteUpdatesImpl(), restoreTarget && (bookkeeping = restoreTarget, fn = restoreQueue, restoreQueue = restoreTarget = null, restoreStateOfTarget(bookkeeping), fn)) for (bookkeeping = 0; bookkeeping < fn.length; bookkeeping++) {
        restoreStateOfTarget(fn[bookkeeping]);
      }
    }
  }

  var EMPTY_NATIVE_EVENT = {};

  function _receiveRootNodeIDEvent(rootNodeID, topLevelType, nativeEventParam) {
    var nativeEvent = nativeEventParam || EMPTY_NATIVE_EVENT,
        inst = getInstanceFromTag(rootNodeID);
    batchedUpdates(function () {
      var events = nativeEvent.target;

      for (var events$jscomp$0 = null, i = 0; i < plugins.length; i++) {
        var possiblePlugin = plugins[i];
        possiblePlugin && (possiblePlugin = possiblePlugin.extractEvents(topLevelType, inst, nativeEvent, events)) && (events$jscomp$0 = accumulateInto(events$jscomp$0, possiblePlugin));
      }

      events = events$jscomp$0;
      null !== events && (eventQueue = accumulateInto(eventQueue, events));
      events = eventQueue;
      eventQueue = null;

      if (events) {
        forEachAccumulated(events, executeDispatchesAndReleaseTopLevel);
        if (eventQueue) throw ReactError(Error("processEventQueue(): Additional events were enqueued while processing an event queue. Support for this has not yet been implemented."));
        if (hasRethrowError) throw events = rethrowError, hasRethrowError = !1, rethrowError = null, events;
      }
    });
  }

  ReactNativePrivateInterface.RCTEventEmitter.register({
    receiveEvent: function receiveEvent(rootNodeID, topLevelType, nativeEventParam) {
      _receiveRootNodeIDEvent(rootNodeID, topLevelType, nativeEventParam);
    },
    receiveTouches: function receiveTouches(eventTopLevelType, touches, changedIndices) {
      if ("topTouchEnd" === eventTopLevelType || "topTouchCancel" === eventTopLevelType) {
        var JSCompiler_temp = [];

        for (var i = 0; i < changedIndices.length; i++) {
          var index = changedIndices[i];
          JSCompiler_temp.push(touches[index]);
          touches[index] = null;
        }

        for (i = changedIndices = 0; i < touches.length; i++) {
          index = touches[i], null !== index && (touches[changedIndices++] = index);
        }

        touches.length = changedIndices;
      } else for (JSCompiler_temp = [], i = 0; i < changedIndices.length; i++) {
        JSCompiler_temp.push(touches[changedIndices[i]]);
      }

      for (changedIndices = 0; changedIndices < JSCompiler_temp.length; changedIndices++) {
        i = JSCompiler_temp[changedIndices];
        i.changedTouches = JSCompiler_temp;
        i.touches = touches;
        index = null;
        var target = i.target;
        null === target || void 0 === target || 1 > target || (index = target);

        _receiveRootNodeIDEvent(index, eventTopLevelType, i);
      }
    }
  });

  getFiberCurrentPropsFromNode = function getFiberCurrentPropsFromNode(stateNode) {
    return instanceProps.get(stateNode._nativeTag) || null;
  };

  getInstanceFromNode = getInstanceFromTag;

  getNodeFromInstance = function getNodeFromInstance(inst) {
    var tag = inst.stateNode._nativeTag;
    void 0 === tag && (tag = inst.stateNode.canonical._nativeTag);
    if (!tag) throw ReactError(Error("All native instances should have a tag."));
    return tag;
  };

  ResponderEventPlugin.injection.injectGlobalResponderHandler({
    onChange: function onChange(from, to, blockNativeResponder) {
      null !== to ? ReactNativePrivateInterface.UIManager.setJSResponder(to.stateNode._nativeTag, blockNativeResponder) : ReactNativePrivateInterface.UIManager.clearJSResponder();
    }
  });
  var ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
  ReactSharedInternals.hasOwnProperty("ReactCurrentDispatcher") || (ReactSharedInternals.ReactCurrentDispatcher = {
    current: null
  });
  ReactSharedInternals.hasOwnProperty("ReactCurrentBatchConfig") || (ReactSharedInternals.ReactCurrentBatchConfig = {
    suspense: null
  });
  var hasSymbol = "function" === typeof Symbol && (typeof Symbol === "function" ? Symbol.for : "@@for"),
      REACT_ELEMENT_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.element") : 60103,
      REACT_PORTAL_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.portal") : 60106,
      REACT_FRAGMENT_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.fragment") : 60107,
      REACT_STRICT_MODE_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.strict_mode") : 60108,
      REACT_PROFILER_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.profiler") : 60114,
      REACT_PROVIDER_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.provider") : 60109,
      REACT_CONTEXT_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.context") : 60110,
      REACT_CONCURRENT_MODE_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.concurrent_mode") : 60111,
      REACT_FORWARD_REF_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.forward_ref") : 60112,
      REACT_SUSPENSE_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.suspense") : 60113,
      REACT_SUSPENSE_LIST_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.suspense_list") : 60120,
      REACT_MEMO_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.memo") : 60115,
      REACT_LAZY_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.lazy") : 60116;
  hasSymbol && (typeof Symbol === "function" ? Symbol.for : "@@for")("react.fundamental");
  hasSymbol && (typeof Symbol === "function" ? Symbol.for : "@@for")("react.responder");
  var MAYBE_ITERATOR_SYMBOL = "function" === typeof Symbol && (typeof Symbol === "function" ? Symbol.iterator : "@@iterator");

  function getIteratorFn(maybeIterable) {
    if (null === maybeIterable || "object" !== typeof maybeIterable) return null;
    maybeIterable = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable["@@iterator"];
    return "function" === typeof maybeIterable ? maybeIterable : null;
  }

  function getComponentName(type) {
    if (null == type) return null;
    if ("function" === typeof type) return type.displayName || type.name || null;
    if ("string" === typeof type) return type;

    switch (type) {
      case REACT_FRAGMENT_TYPE:
        return "Fragment";

      case REACT_PORTAL_TYPE:
        return "Portal";

      case REACT_PROFILER_TYPE:
        return "Profiler";

      case REACT_STRICT_MODE_TYPE:
        return "StrictMode";

      case REACT_SUSPENSE_TYPE:
        return "Suspense";

      case REACT_SUSPENSE_LIST_TYPE:
        return "SuspenseList";
    }

    if ("object" === typeof type) switch (type.$$typeof) {
      case REACT_CONTEXT_TYPE:
        return "Context.Consumer";

      case REACT_PROVIDER_TYPE:
        return "Context.Provider";

      case REACT_FORWARD_REF_TYPE:
        var innerType = type.render;
        innerType = innerType.displayName || innerType.name || "";
        return type.displayName || ("" !== innerType ? "ForwardRef(" + innerType + ")" : "ForwardRef");

      case REACT_MEMO_TYPE:
        return getComponentName(type.type);

      case REACT_LAZY_TYPE:
        if (type = 1 === type._status ? type._result : null) return getComponentName(type);
    }
    return null;
  }

  function isFiberMountedImpl(fiber) {
    var node = fiber;
    if (fiber.alternate) for (; node.return;) {
      node = node.return;
    } else {
      if (0 !== (node.effectTag & 2)) return 1;

      for (; node.return;) {
        if (node = node.return, 0 !== (node.effectTag & 2)) return 1;
      }
    }
    return 3 === node.tag ? 2 : 3;
  }

  function assertIsMounted(fiber) {
    if (2 !== isFiberMountedImpl(fiber)) throw ReactError(Error("Unable to find node on an unmounted component."));
  }

  function findCurrentFiberUsingSlowPath(fiber) {
    var alternate = fiber.alternate;

    if (!alternate) {
      alternate = isFiberMountedImpl(fiber);
      if (3 === alternate) throw ReactError(Error("Unable to find node on an unmounted component."));
      return 1 === alternate ? null : fiber;
    }

    for (var a = fiber, b = alternate;;) {
      var parentA = a.return;
      if (null === parentA) break;
      var parentB = parentA.alternate;

      if (null === parentB) {
        b = parentA.return;

        if (null !== b) {
          a = b;
          continue;
        }

        break;
      }

      if (parentA.child === parentB.child) {
        for (parentB = parentA.child; parentB;) {
          if (parentB === a) return assertIsMounted(parentA), fiber;
          if (parentB === b) return assertIsMounted(parentA), alternate;
          parentB = parentB.sibling;
        }

        throw ReactError(Error("Unable to find node on an unmounted component."));
      }

      if (a.return !== b.return) a = parentA, b = parentB;else {
        for (var didFindChild = !1, _child = parentA.child; _child;) {
          if (_child === a) {
            didFindChild = !0;
            a = parentA;
            b = parentB;
            break;
          }

          if (_child === b) {
            didFindChild = !0;
            b = parentA;
            a = parentB;
            break;
          }

          _child = _child.sibling;
        }

        if (!didFindChild) {
          for (_child = parentB.child; _child;) {
            if (_child === a) {
              didFindChild = !0;
              a = parentB;
              b = parentA;
              break;
            }

            if (_child === b) {
              didFindChild = !0;
              b = parentB;
              a = parentA;
              break;
            }

            _child = _child.sibling;
          }

          if (!didFindChild) throw ReactError(Error("Child was not found in either parent set. This indicates a bug in React related to the return pointer. Please file an issue."));
        }
      }
      if (a.alternate !== b) throw ReactError(Error("Return fibers should always be each others' alternates. This error is likely caused by a bug in React. Please file an issue."));
    }

    if (3 !== a.tag) throw ReactError(Error("Unable to find node on an unmounted component."));
    return a.stateNode.current === a ? fiber : alternate;
  }

  function findCurrentHostFiber(parent) {
    parent = findCurrentFiberUsingSlowPath(parent);
    if (!parent) return null;

    for (var node = parent;;) {
      if (5 === node.tag || 6 === node.tag) return node;
      if (node.child) node.child.return = node, node = node.child;else {
        if (node === parent) break;

        for (; !node.sibling;) {
          if (!node.return || node.return === parent) return null;
          node = node.return;
        }

        node.sibling.return = node.return;
        node = node.sibling;
      }
    }

    return null;
  }

  var emptyObject = {},
      removedKeys = null,
      removedKeyCount = 0;

  function restoreDeletedValuesInNestedArray(updatePayload, node, validAttributes) {
    if (Array.isArray(node)) for (var i = node.length; i-- && 0 < removedKeyCount;) {
      restoreDeletedValuesInNestedArray(updatePayload, node[i], validAttributes);
    } else if (node && 0 < removedKeyCount) for (i in removedKeys) {
      if (removedKeys[i]) {
        var nextProp = node[i];

        if (void 0 !== nextProp) {
          var attributeConfig = validAttributes[i];

          if (attributeConfig) {
            "function" === typeof nextProp && (nextProp = !0);
            "undefined" === typeof nextProp && (nextProp = null);
            if ("object" !== typeof attributeConfig) updatePayload[i] = nextProp;else if ("function" === typeof attributeConfig.diff || "function" === typeof attributeConfig.process) nextProp = "function" === typeof attributeConfig.process ? attributeConfig.process(nextProp) : nextProp, updatePayload[i] = nextProp;
            removedKeys[i] = !1;
            removedKeyCount--;
          }
        }
      }
    }
  }

  function diffNestedProperty(updatePayload, prevProp, nextProp, validAttributes) {
    if (!updatePayload && prevProp === nextProp) return updatePayload;
    if (!prevProp || !nextProp) return nextProp ? addNestedProperty(updatePayload, nextProp, validAttributes) : prevProp ? clearNestedProperty(updatePayload, prevProp, validAttributes) : updatePayload;
    if (!Array.isArray(prevProp) && !Array.isArray(nextProp)) return diffProperties(updatePayload, prevProp, nextProp, validAttributes);

    if (Array.isArray(prevProp) && Array.isArray(nextProp)) {
      var minLength = prevProp.length < nextProp.length ? prevProp.length : nextProp.length,
          i;

      for (i = 0; i < minLength; i++) {
        updatePayload = diffNestedProperty(updatePayload, prevProp[i], nextProp[i], validAttributes);
      }

      for (; i < prevProp.length; i++) {
        updatePayload = clearNestedProperty(updatePayload, prevProp[i], validAttributes);
      }

      for (; i < nextProp.length; i++) {
        updatePayload = addNestedProperty(updatePayload, nextProp[i], validAttributes);
      }

      return updatePayload;
    }

    return Array.isArray(prevProp) ? diffProperties(updatePayload, ReactNativePrivateInterface.flattenStyle(prevProp), nextProp, validAttributes) : diffProperties(updatePayload, prevProp, ReactNativePrivateInterface.flattenStyle(nextProp), validAttributes);
  }

  function addNestedProperty(updatePayload, nextProp, validAttributes) {
    if (!nextProp) return updatePayload;
    if (!Array.isArray(nextProp)) return diffProperties(updatePayload, emptyObject, nextProp, validAttributes);

    for (var i = 0; i < nextProp.length; i++) {
      updatePayload = addNestedProperty(updatePayload, nextProp[i], validAttributes);
    }

    return updatePayload;
  }

  function clearNestedProperty(updatePayload, prevProp, validAttributes) {
    if (!prevProp) return updatePayload;
    if (!Array.isArray(prevProp)) return diffProperties(updatePayload, prevProp, emptyObject, validAttributes);

    for (var i = 0; i < prevProp.length; i++) {
      updatePayload = clearNestedProperty(updatePayload, prevProp[i], validAttributes);
    }

    return updatePayload;
  }

  function diffProperties(updatePayload, prevProps, nextProps, validAttributes) {
    var attributeConfig, propKey;

    for (propKey in nextProps) {
      if (attributeConfig = validAttributes[propKey]) {
        var prevProp = prevProps[propKey];
        var nextProp = nextProps[propKey];
        "function" === typeof nextProp && (nextProp = !0, "function" === typeof prevProp && (prevProp = !0));
        "undefined" === typeof nextProp && (nextProp = null, "undefined" === typeof prevProp && (prevProp = null));
        removedKeys && (removedKeys[propKey] = !1);
        if (updatePayload && void 0 !== updatePayload[propKey]) {
          if ("object" !== typeof attributeConfig) updatePayload[propKey] = nextProp;else {
            if ("function" === typeof attributeConfig.diff || "function" === typeof attributeConfig.process) attributeConfig = "function" === typeof attributeConfig.process ? attributeConfig.process(nextProp) : nextProp, updatePayload[propKey] = attributeConfig;
          }
        } else if (prevProp !== nextProp) if ("object" !== typeof attributeConfig) ("object" !== typeof nextProp || null === nextProp || ReactNativePrivateInterface.deepDiffer(prevProp, nextProp)) && ((updatePayload || (updatePayload = {}))[propKey] = nextProp);else if ("function" === typeof attributeConfig.diff || "function" === typeof attributeConfig.process) {
          if (void 0 === prevProp || ("function" === typeof attributeConfig.diff ? attributeConfig.diff(prevProp, nextProp) : "object" !== typeof nextProp || null === nextProp || ReactNativePrivateInterface.deepDiffer(prevProp, nextProp))) attributeConfig = "function" === typeof attributeConfig.process ? attributeConfig.process(nextProp) : nextProp, (updatePayload || (updatePayload = {}))[propKey] = attributeConfig;
        } else removedKeys = null, removedKeyCount = 0, updatePayload = diffNestedProperty(updatePayload, prevProp, nextProp, attributeConfig), 0 < removedKeyCount && updatePayload && (restoreDeletedValuesInNestedArray(updatePayload, nextProp, attributeConfig), removedKeys = null);
      }
    }

    for (var _propKey in prevProps) {
      void 0 === nextProps[_propKey] && (!(attributeConfig = validAttributes[_propKey]) || updatePayload && void 0 !== updatePayload[_propKey] || (prevProp = prevProps[_propKey], void 0 !== prevProp && ("object" !== typeof attributeConfig || "function" === typeof attributeConfig.diff || "function" === typeof attributeConfig.process ? ((updatePayload || (updatePayload = {}))[_propKey] = null, removedKeys || (removedKeys = {}), removedKeys[_propKey] || (removedKeys[_propKey] = !0, removedKeyCount++)) : updatePayload = clearNestedProperty(updatePayload, prevProp, attributeConfig))));
    }

    return updatePayload;
  }

  function mountSafeCallback_NOT_REALLY_SAFE(context, callback) {
    return function () {
      if (callback && ("boolean" !== typeof context.__isMounted || context.__isMounted)) return callback.apply(context, arguments);
    };
  }

  var ReactNativeFiberHostComponent = function () {
    function ReactNativeFiberHostComponent(tag, viewConfig) {
      if (!(this instanceof ReactNativeFiberHostComponent)) throw new TypeError("Cannot call a class as a function");
      this._nativeTag = tag;
      this._children = [];
      this.viewConfig = viewConfig;
    }

    ReactNativeFiberHostComponent.prototype.blur = function () {
      ReactNativePrivateInterface.TextInputState.blurTextInput(this._nativeTag);
    };

    ReactNativeFiberHostComponent.prototype.focus = function () {
      ReactNativePrivateInterface.TextInputState.focusTextInput(this._nativeTag);
    };

    ReactNativeFiberHostComponent.prototype.measure = function (callback) {
      ReactNativePrivateInterface.UIManager.measure(this._nativeTag, mountSafeCallback_NOT_REALLY_SAFE(this, callback));
    };

    ReactNativeFiberHostComponent.prototype.measureInWindow = function (callback) {
      ReactNativePrivateInterface.UIManager.measureInWindow(this._nativeTag, mountSafeCallback_NOT_REALLY_SAFE(this, callback));
    };

    ReactNativeFiberHostComponent.prototype.measureLayout = function (relativeToNativeNode, onSuccess, onFail) {
      var relativeNode = void 0;
      "number" === typeof relativeToNativeNode ? relativeNode = relativeToNativeNode : relativeToNativeNode._nativeTag ? relativeNode = relativeToNativeNode._nativeTag : relativeToNativeNode.canonical && relativeToNativeNode.canonical._nativeTag && (relativeNode = relativeToNativeNode.canonical._nativeTag);
      null != relativeNode && ReactNativePrivateInterface.UIManager.measureLayout(this._nativeTag, relativeNode, mountSafeCallback_NOT_REALLY_SAFE(this, onFail), mountSafeCallback_NOT_REALLY_SAFE(this, onSuccess));
    };

    ReactNativeFiberHostComponent.prototype.setNativeProps = function (nativeProps) {
      nativeProps = diffProperties(null, emptyObject, nativeProps, this.viewConfig.validAttributes);
      null != nativeProps && ReactNativePrivateInterface.UIManager.updateView(this._nativeTag, this.viewConfig.uiViewClassName, nativeProps);
    };

    return ReactNativeFiberHostComponent;
  }();

  function shim$1() {
    throw ReactError(Error("The current renderer does not support hydration. This error is likely caused by a bug in React. Please file an issue."));
  }

  var getViewConfigForType = ReactNativePrivateInterface.ReactNativeViewConfigRegistry.get,
      UPDATE_SIGNAL = {},
      nextReactTag = 3;

  function allocateTag() {
    var tag = nextReactTag;
    1 === tag % 10 && (tag += 2);
    nextReactTag = tag + 2;
    return tag;
  }

  function recursivelyUncacheFiberNode(node) {
    if ("number" === typeof node) instanceCache.delete(node), instanceProps.delete(node);else {
      var tag = node._nativeTag;
      instanceCache.delete(tag);
      instanceProps.delete(tag);

      node._children.forEach(recursivelyUncacheFiberNode);
    }
  }

  function finalizeInitialChildren(parentInstance) {
    if (0 === parentInstance._children.length) return !1;

    var nativeTags = parentInstance._children.map(function (child) {
      return "number" === typeof child ? child : child._nativeTag;
    });

    ReactNativePrivateInterface.UIManager.setChildren(parentInstance._nativeTag, nativeTags);
    return !1;
  }

  var scheduleTimeout = setTimeout,
      cancelTimeout = clearTimeout,
      BEFORE_SLASH_RE = /^(.*)[\\\/]/;

  function getStackByFiberInDevAndProd(workInProgress) {
    var info = "";

    do {
      a: switch (workInProgress.tag) {
        case 3:
        case 4:
        case 6:
        case 7:
        case 10:
        case 9:
          var JSCompiler_inline_result = "";
          break a;

        default:
          var owner = workInProgress._debugOwner,
              source = workInProgress._debugSource,
              name = getComponentName(workInProgress.type);
          JSCompiler_inline_result = null;
          owner && (JSCompiler_inline_result = getComponentName(owner.type));
          owner = name;
          name = "";
          source ? name = " (at " + source.fileName.replace(BEFORE_SLASH_RE, "") + ":" + source.lineNumber + ")" : JSCompiler_inline_result && (name = " (created by " + JSCompiler_inline_result + ")");
          JSCompiler_inline_result = "\n    in " + (owner || "Unknown") + name;
      }

      info += JSCompiler_inline_result;
      workInProgress = workInProgress.return;
    } while (workInProgress);

    return info;
  }

  new Set();
  var valueStack = [],
      index = -1;

  function pop(cursor) {
    0 > index || (cursor.current = valueStack[index], valueStack[index] = null, index--);
  }

  function push(cursor, value) {
    index++;
    valueStack[index] = cursor.current;
    cursor.current = value;
  }

  var emptyContextObject = {},
      contextStackCursor = {
    current: emptyContextObject
  },
      didPerformWorkStackCursor = {
    current: !1
  },
      previousContext = emptyContextObject;

  function getMaskedContext(workInProgress, unmaskedContext) {
    var contextTypes = workInProgress.type.contextTypes;
    if (!contextTypes) return emptyContextObject;
    var instance = workInProgress.stateNode;
    if (instance && instance.__reactInternalMemoizedUnmaskedChildContext === unmaskedContext) return instance.__reactInternalMemoizedMaskedChildContext;
    var context = {},
        key;

    for (key in contextTypes) {
      context[key] = unmaskedContext[key];
    }

    instance && (workInProgress = workInProgress.stateNode, workInProgress.__reactInternalMemoizedUnmaskedChildContext = unmaskedContext, workInProgress.__reactInternalMemoizedMaskedChildContext = context);
    return context;
  }

  function isContextProvider(type) {
    type = type.childContextTypes;
    return null !== type && void 0 !== type;
  }

  function popContext(fiber) {
    pop(didPerformWorkStackCursor, fiber);
    pop(contextStackCursor, fiber);
  }

  function popTopLevelContextObject(fiber) {
    pop(didPerformWorkStackCursor, fiber);
    pop(contextStackCursor, fiber);
  }

  function pushTopLevelContextObject(fiber, context, didChange) {
    if (contextStackCursor.current !== emptyContextObject) throw ReactError(Error("Unexpected context found on stack. This error is likely caused by a bug in React. Please file an issue."));
    push(contextStackCursor, context, fiber);
    push(didPerformWorkStackCursor, didChange, fiber);
  }

  function processChildContext(fiber, type, parentContext) {
    var instance = fiber.stateNode;
    fiber = type.childContextTypes;
    if ("function" !== typeof instance.getChildContext) return parentContext;
    instance = instance.getChildContext();

    for (var contextKey in instance) {
      if (!(contextKey in fiber)) throw ReactError(Error((getComponentName(type) || "Unknown") + '.getChildContext(): key "' + contextKey + '" is not defined in childContextTypes.'));
    }

    return _extends({}, parentContext, instance);
  }

  function pushContextProvider(workInProgress) {
    var instance = workInProgress.stateNode;
    instance = instance && instance.__reactInternalMemoizedMergedChildContext || emptyContextObject;
    previousContext = contextStackCursor.current;
    push(contextStackCursor, instance, workInProgress);
    push(didPerformWorkStackCursor, didPerformWorkStackCursor.current, workInProgress);
    return !0;
  }

  function invalidateContextProvider(workInProgress, type, didChange) {
    var instance = workInProgress.stateNode;
    if (!instance) throw ReactError(Error("Expected to have an instance by this point. This error is likely caused by a bug in React. Please file an issue."));
    didChange ? (type = processChildContext(workInProgress, type, previousContext), instance.__reactInternalMemoizedMergedChildContext = type, pop(didPerformWorkStackCursor, workInProgress), pop(contextStackCursor, workInProgress), push(contextStackCursor, type, workInProgress)) : pop(didPerformWorkStackCursor, workInProgress);
    push(didPerformWorkStackCursor, didChange, workInProgress);
  }

  var Scheduler_runWithPriority = Scheduler.unstable_runWithPriority,
      Scheduler_scheduleCallback = Scheduler.unstable_scheduleCallback,
      Scheduler_cancelCallback = Scheduler.unstable_cancelCallback,
      Scheduler_shouldYield = Scheduler.unstable_shouldYield,
      Scheduler_requestPaint = Scheduler.unstable_requestPaint,
      Scheduler_now = Scheduler.unstable_now,
      Scheduler_getCurrentPriorityLevel = Scheduler.unstable_getCurrentPriorityLevel,
      Scheduler_ImmediatePriority = Scheduler.unstable_ImmediatePriority,
      Scheduler_UserBlockingPriority = Scheduler.unstable_UserBlockingPriority,
      Scheduler_NormalPriority = Scheduler.unstable_NormalPriority,
      Scheduler_LowPriority = Scheduler.unstable_LowPriority,
      Scheduler_IdlePriority = Scheduler.unstable_IdlePriority,
      fakeCallbackNode = {},
      requestPaint = void 0 !== Scheduler_requestPaint ? Scheduler_requestPaint : function () {},
      syncQueue = null,
      immediateQueueCallbackNode = null,
      isFlushingSyncQueue = !1,
      initialTimeMs = Scheduler_now(),
      now = 1e4 > initialTimeMs ? Scheduler_now : function () {
    return Scheduler_now() - initialTimeMs;
  };

  function getCurrentPriorityLevel() {
    switch (Scheduler_getCurrentPriorityLevel()) {
      case Scheduler_ImmediatePriority:
        return 99;

      case Scheduler_UserBlockingPriority:
        return 98;

      case Scheduler_NormalPriority:
        return 97;

      case Scheduler_LowPriority:
        return 96;

      case Scheduler_IdlePriority:
        return 95;

      default:
        throw ReactError(Error("Unknown priority level."));
    }
  }

  function reactPriorityToSchedulerPriority(reactPriorityLevel) {
    switch (reactPriorityLevel) {
      case 99:
        return Scheduler_ImmediatePriority;

      case 98:
        return Scheduler_UserBlockingPriority;

      case 97:
        return Scheduler_NormalPriority;

      case 96:
        return Scheduler_LowPriority;

      case 95:
        return Scheduler_IdlePriority;

      default:
        throw ReactError(Error("Unknown priority level."));
    }
  }

  function runWithPriority(reactPriorityLevel, fn) {
    reactPriorityLevel = reactPriorityToSchedulerPriority(reactPriorityLevel);
    return Scheduler_runWithPriority(reactPriorityLevel, fn);
  }

  function scheduleCallback(reactPriorityLevel, callback, options) {
    reactPriorityLevel = reactPriorityToSchedulerPriority(reactPriorityLevel);
    return Scheduler_scheduleCallback(reactPriorityLevel, callback, options);
  }

  function scheduleSyncCallback(callback) {
    null === syncQueue ? (syncQueue = [callback], immediateQueueCallbackNode = Scheduler_scheduleCallback(Scheduler_ImmediatePriority, flushSyncCallbackQueueImpl)) : syncQueue.push(callback);
    return fakeCallbackNode;
  }

  function flushSyncCallbackQueue() {
    null !== immediateQueueCallbackNode && Scheduler_cancelCallback(immediateQueueCallbackNode);
    flushSyncCallbackQueueImpl();
  }

  function flushSyncCallbackQueueImpl() {
    if (!isFlushingSyncQueue && null !== syncQueue) {
      isFlushingSyncQueue = !0;
      var i = 0;

      try {
        var queue = syncQueue;
        runWithPriority(99, function () {
          for (; i < queue.length; i++) {
            var callback = queue[i];

            do {
              callback = callback(!0);
            } while (null !== callback);
          }
        });
        syncQueue = null;
      } catch (error) {
        throw null !== syncQueue && (syncQueue = syncQueue.slice(i + 1)), Scheduler_scheduleCallback(Scheduler_ImmediatePriority, flushSyncCallbackQueue), error;
      } finally {
        isFlushingSyncQueue = !1;
      }
    }
  }

  function inferPriorityFromExpirationTime(currentTime, expirationTime) {
    if (1073741823 === expirationTime) return 99;
    if (1 === expirationTime) return 95;
    currentTime = 10 * (1073741821 - expirationTime) - 10 * (1073741821 - currentTime);
    return 0 >= currentTime ? 99 : 250 >= currentTime ? 98 : 5250 >= currentTime ? 97 : 95;
  }

  function is(x, y) {
    return x === y && (0 !== x || 1 / x === 1 / y) || x !== x && y !== y;
  }

  var hasOwnProperty = Object.prototype.hasOwnProperty;

  function shallowEqual(objA, objB) {
    if (is(objA, objB)) return !0;
    if ("object" !== typeof objA || null === objA || "object" !== typeof objB || null === objB) return !1;
    var keysA = Object.keys(objA),
        keysB = Object.keys(objB);
    if (keysA.length !== keysB.length) return !1;

    for (keysB = 0; keysB < keysA.length; keysB++) {
      if (!hasOwnProperty.call(objB, keysA[keysB]) || !is(objA[keysA[keysB]], objB[keysA[keysB]])) return !1;
    }

    return !0;
  }

  function resolveDefaultProps(Component, baseProps) {
    if (Component && Component.defaultProps) {
      baseProps = _extends({}, baseProps);
      Component = Component.defaultProps;

      for (var propName in Component) {
        void 0 === baseProps[propName] && (baseProps[propName] = Component[propName]);
      }
    }

    return baseProps;
  }

  function readLazyComponentType(lazyComponent) {
    var result = lazyComponent._result;

    switch (lazyComponent._status) {
      case 1:
        return result;

      case 2:
        throw result;

      case 0:
        throw result;

      default:
        lazyComponent._status = 0;
        result = lazyComponent._ctor;
        result = result();
        result.then(function (moduleObject) {
          0 === lazyComponent._status && (moduleObject = moduleObject.default, lazyComponent._status = 1, lazyComponent._result = moduleObject);
        }, function (error) {
          0 === lazyComponent._status && (lazyComponent._status = 2, lazyComponent._result = error);
        });

        switch (lazyComponent._status) {
          case 1:
            return lazyComponent._result;

          case 2:
            throw lazyComponent._result;
        }

        lazyComponent._result = result;
        throw result;
    }
  }

  var valueCursor = {
    current: null
  },
      currentlyRenderingFiber = null,
      lastContextDependency = null,
      lastContextWithAllBitsObserved = null;

  function resetContextDependencies() {
    lastContextWithAllBitsObserved = lastContextDependency = currentlyRenderingFiber = null;
  }

  function pushProvider(providerFiber, nextValue) {
    var context = providerFiber.type._context;
    push(valueCursor, context._currentValue, providerFiber);
    context._currentValue = nextValue;
  }

  function popProvider(providerFiber) {
    var currentValue = valueCursor.current;
    pop(valueCursor, providerFiber);
    providerFiber.type._context._currentValue = currentValue;
  }

  function scheduleWorkOnParentPath(parent, renderExpirationTime) {
    for (; null !== parent;) {
      var alternate = parent.alternate;
      if (parent.childExpirationTime < renderExpirationTime) parent.childExpirationTime = renderExpirationTime, null !== alternate && alternate.childExpirationTime < renderExpirationTime && (alternate.childExpirationTime = renderExpirationTime);else if (null !== alternate && alternate.childExpirationTime < renderExpirationTime) alternate.childExpirationTime = renderExpirationTime;else break;
      parent = parent.return;
    }
  }

  function prepareToReadContext(workInProgress, renderExpirationTime) {
    currentlyRenderingFiber = workInProgress;
    lastContextWithAllBitsObserved = lastContextDependency = null;
    workInProgress = workInProgress.dependencies;
    null !== workInProgress && null !== workInProgress.firstContext && (workInProgress.expirationTime >= renderExpirationTime && (didReceiveUpdate = !0), workInProgress.firstContext = null);
  }

  function readContext(context, observedBits) {
    if (lastContextWithAllBitsObserved !== context && !1 !== observedBits && 0 !== observedBits) {
      if ("number" !== typeof observedBits || 1073741823 === observedBits) lastContextWithAllBitsObserved = context, observedBits = 1073741823;
      observedBits = {
        context: context,
        observedBits: observedBits,
        next: null
      };

      if (null === lastContextDependency) {
        if (null === currentlyRenderingFiber) throw ReactError(Error("Context can only be read while React is rendering. In classes, you can read it in the render method or getDerivedStateFromProps. In function components, you can read it directly in the function body, but not inside Hooks like useReducer() or useMemo()."));
        lastContextDependency = observedBits;
        currentlyRenderingFiber.dependencies = {
          expirationTime: 0,
          firstContext: observedBits,
          responders: null
        };
      } else lastContextDependency = lastContextDependency.next = observedBits;
    }

    return context._currentValue;
  }

  var hasForceUpdate = !1;

  function createUpdateQueue(baseState) {
    return {
      baseState: baseState,
      firstUpdate: null,
      lastUpdate: null,
      firstCapturedUpdate: null,
      lastCapturedUpdate: null,
      firstEffect: null,
      lastEffect: null,
      firstCapturedEffect: null,
      lastCapturedEffect: null
    };
  }

  function cloneUpdateQueue(currentQueue) {
    return {
      baseState: currentQueue.baseState,
      firstUpdate: currentQueue.firstUpdate,
      lastUpdate: currentQueue.lastUpdate,
      firstCapturedUpdate: null,
      lastCapturedUpdate: null,
      firstEffect: null,
      lastEffect: null,
      firstCapturedEffect: null,
      lastCapturedEffect: null
    };
  }

  function createUpdate(expirationTime, suspenseConfig) {
    return {
      expirationTime: expirationTime,
      suspenseConfig: suspenseConfig,
      tag: 0,
      payload: null,
      callback: null,
      next: null,
      nextEffect: null
    };
  }

  function appendUpdateToQueue(queue, update) {
    null === queue.lastUpdate ? queue.firstUpdate = queue.lastUpdate = update : (queue.lastUpdate.next = update, queue.lastUpdate = update);
  }

  function enqueueUpdate(fiber, update) {
    var alternate = fiber.alternate;

    if (null === alternate) {
      var queue1 = fiber.updateQueue;
      var queue2 = null;
      null === queue1 && (queue1 = fiber.updateQueue = createUpdateQueue(fiber.memoizedState));
    } else queue1 = fiber.updateQueue, queue2 = alternate.updateQueue, null === queue1 ? null === queue2 ? (queue1 = fiber.updateQueue = createUpdateQueue(fiber.memoizedState), queue2 = alternate.updateQueue = createUpdateQueue(alternate.memoizedState)) : queue1 = fiber.updateQueue = cloneUpdateQueue(queue2) : null === queue2 && (queue2 = alternate.updateQueue = cloneUpdateQueue(queue1));

    null === queue2 || queue1 === queue2 ? appendUpdateToQueue(queue1, update) : null === queue1.lastUpdate || null === queue2.lastUpdate ? (appendUpdateToQueue(queue1, update), appendUpdateToQueue(queue2, update)) : (appendUpdateToQueue(queue1, update), queue2.lastUpdate = update);
  }

  function enqueueCapturedUpdate(workInProgress, update) {
    var workInProgressQueue = workInProgress.updateQueue;
    workInProgressQueue = null === workInProgressQueue ? workInProgress.updateQueue = createUpdateQueue(workInProgress.memoizedState) : ensureWorkInProgressQueueIsAClone(workInProgress, workInProgressQueue);
    null === workInProgressQueue.lastCapturedUpdate ? workInProgressQueue.firstCapturedUpdate = workInProgressQueue.lastCapturedUpdate = update : (workInProgressQueue.lastCapturedUpdate.next = update, workInProgressQueue.lastCapturedUpdate = update);
  }

  function ensureWorkInProgressQueueIsAClone(workInProgress, queue) {
    var current = workInProgress.alternate;
    null !== current && queue === current.updateQueue && (queue = workInProgress.updateQueue = cloneUpdateQueue(queue));
    return queue;
  }

  function getStateFromUpdate(workInProgress, queue, update, prevState, nextProps, instance) {
    switch (update.tag) {
      case 1:
        return workInProgress = update.payload, "function" === typeof workInProgress ? workInProgress.call(instance, prevState, nextProps) : workInProgress;

      case 3:
        workInProgress.effectTag = workInProgress.effectTag & -2049 | 64;

      case 0:
        workInProgress = update.payload;
        nextProps = "function" === typeof workInProgress ? workInProgress.call(instance, prevState, nextProps) : workInProgress;
        if (null === nextProps || void 0 === nextProps) break;
        return _extends({}, prevState, nextProps);

      case 2:
        hasForceUpdate = !0;
    }

    return prevState;
  }

  function processUpdateQueue(workInProgress, queue, props, instance, renderExpirationTime) {
    hasForceUpdate = !1;
    queue = ensureWorkInProgressQueueIsAClone(workInProgress, queue);

    for (var newBaseState = queue.baseState, newFirstUpdate = null, newExpirationTime = 0, update = queue.firstUpdate, resultState = newBaseState; null !== update;) {
      var updateExpirationTime = update.expirationTime;
      updateExpirationTime < renderExpirationTime ? (null === newFirstUpdate && (newFirstUpdate = update, newBaseState = resultState), newExpirationTime < updateExpirationTime && (newExpirationTime = updateExpirationTime)) : (markRenderEventTimeAndConfig(updateExpirationTime, update.suspenseConfig), resultState = getStateFromUpdate(workInProgress, queue, update, resultState, props, instance), null !== update.callback && (workInProgress.effectTag |= 32, update.nextEffect = null, null === queue.lastEffect ? queue.firstEffect = queue.lastEffect = update : (queue.lastEffect.nextEffect = update, queue.lastEffect = update)));
      update = update.next;
    }

    updateExpirationTime = null;

    for (update = queue.firstCapturedUpdate; null !== update;) {
      var _updateExpirationTime = update.expirationTime;
      _updateExpirationTime < renderExpirationTime ? (null === updateExpirationTime && (updateExpirationTime = update, null === newFirstUpdate && (newBaseState = resultState)), newExpirationTime < _updateExpirationTime && (newExpirationTime = _updateExpirationTime)) : (resultState = getStateFromUpdate(workInProgress, queue, update, resultState, props, instance), null !== update.callback && (workInProgress.effectTag |= 32, update.nextEffect = null, null === queue.lastCapturedEffect ? queue.firstCapturedEffect = queue.lastCapturedEffect = update : (queue.lastCapturedEffect.nextEffect = update, queue.lastCapturedEffect = update)));
      update = update.next;
    }

    null === newFirstUpdate && (queue.lastUpdate = null);
    null === updateExpirationTime ? queue.lastCapturedUpdate = null : workInProgress.effectTag |= 32;
    null === newFirstUpdate && null === updateExpirationTime && (newBaseState = resultState);
    queue.baseState = newBaseState;
    queue.firstUpdate = newFirstUpdate;
    queue.firstCapturedUpdate = updateExpirationTime;
    workInProgress.expirationTime = newExpirationTime;
    workInProgress.memoizedState = resultState;
  }

  function commitUpdateQueue(finishedWork, finishedQueue, instance) {
    null !== finishedQueue.firstCapturedUpdate && (null !== finishedQueue.lastUpdate && (finishedQueue.lastUpdate.next = finishedQueue.firstCapturedUpdate, finishedQueue.lastUpdate = finishedQueue.lastCapturedUpdate), finishedQueue.firstCapturedUpdate = finishedQueue.lastCapturedUpdate = null);
    commitUpdateEffects(finishedQueue.firstEffect, instance);
    finishedQueue.firstEffect = finishedQueue.lastEffect = null;
    commitUpdateEffects(finishedQueue.firstCapturedEffect, instance);
    finishedQueue.firstCapturedEffect = finishedQueue.lastCapturedEffect = null;
  }

  function commitUpdateEffects(effect, instance) {
    for (; null !== effect;) {
      var _callback3 = effect.callback;

      if (null !== _callback3) {
        effect.callback = null;
        var context = instance;
        if ("function" !== typeof _callback3) throw ReactError(Error("Invalid argument passed as callback. Expected a function. Instead received: " + _callback3));

        _callback3.call(context);
      }

      effect = effect.nextEffect;
    }
  }

  var ReactCurrentBatchConfig = ReactSharedInternals.ReactCurrentBatchConfig,
      emptyRefsObject = new React.Component().refs;

  function applyDerivedStateFromProps(workInProgress, ctor, getDerivedStateFromProps, nextProps) {
    ctor = workInProgress.memoizedState;
    getDerivedStateFromProps = getDerivedStateFromProps(nextProps, ctor);
    getDerivedStateFromProps = null === getDerivedStateFromProps || void 0 === getDerivedStateFromProps ? ctor : _extends({}, ctor, getDerivedStateFromProps);
    workInProgress.memoizedState = getDerivedStateFromProps;
    nextProps = workInProgress.updateQueue;
    null !== nextProps && 0 === workInProgress.expirationTime && (nextProps.baseState = getDerivedStateFromProps);
  }

  var classComponentUpdater = {
    isMounted: function isMounted(component) {
      return (component = component._reactInternalFiber) ? 2 === isFiberMountedImpl(component) : !1;
    },
    enqueueSetState: function enqueueSetState(inst, payload, callback) {
      inst = inst._reactInternalFiber;
      var currentTime = requestCurrentTime(),
          suspenseConfig = ReactCurrentBatchConfig.suspense;
      currentTime = computeExpirationForFiber(currentTime, inst, suspenseConfig);
      suspenseConfig = createUpdate(currentTime, suspenseConfig);
      suspenseConfig.payload = payload;
      void 0 !== callback && null !== callback && (suspenseConfig.callback = callback);
      enqueueUpdate(inst, suspenseConfig);
      scheduleUpdateOnFiber(inst, currentTime);
    },
    enqueueReplaceState: function enqueueReplaceState(inst, payload, callback) {
      inst = inst._reactInternalFiber;
      var currentTime = requestCurrentTime(),
          suspenseConfig = ReactCurrentBatchConfig.suspense;
      currentTime = computeExpirationForFiber(currentTime, inst, suspenseConfig);
      suspenseConfig = createUpdate(currentTime, suspenseConfig);
      suspenseConfig.tag = 1;
      suspenseConfig.payload = payload;
      void 0 !== callback && null !== callback && (suspenseConfig.callback = callback);
      enqueueUpdate(inst, suspenseConfig);
      scheduleUpdateOnFiber(inst, currentTime);
    },
    enqueueForceUpdate: function enqueueForceUpdate(inst, callback) {
      inst = inst._reactInternalFiber;
      var currentTime = requestCurrentTime(),
          suspenseConfig = ReactCurrentBatchConfig.suspense;
      currentTime = computeExpirationForFiber(currentTime, inst, suspenseConfig);
      suspenseConfig = createUpdate(currentTime, suspenseConfig);
      suspenseConfig.tag = 2;
      void 0 !== callback && null !== callback && (suspenseConfig.callback = callback);
      enqueueUpdate(inst, suspenseConfig);
      scheduleUpdateOnFiber(inst, currentTime);
    }
  };

  function checkShouldComponentUpdate(workInProgress, ctor, oldProps, newProps, oldState, newState, nextContext) {
    workInProgress = workInProgress.stateNode;
    return "function" === typeof workInProgress.shouldComponentUpdate ? workInProgress.shouldComponentUpdate(newProps, newState, nextContext) : ctor.prototype && ctor.prototype.isPureReactComponent ? !shallowEqual(oldProps, newProps) || !shallowEqual(oldState, newState) : !0;
  }

  function constructClassInstance(workInProgress, ctor, props) {
    var isLegacyContextConsumer = !1,
        unmaskedContext = emptyContextObject;
    var context = ctor.contextType;
    "object" === typeof context && null !== context ? context = readContext(context) : (unmaskedContext = isContextProvider(ctor) ? previousContext : contextStackCursor.current, isLegacyContextConsumer = ctor.contextTypes, context = (isLegacyContextConsumer = null !== isLegacyContextConsumer && void 0 !== isLegacyContextConsumer) ? getMaskedContext(workInProgress, unmaskedContext) : emptyContextObject);
    ctor = new ctor(props, context);
    workInProgress.memoizedState = null !== ctor.state && void 0 !== ctor.state ? ctor.state : null;
    ctor.updater = classComponentUpdater;
    workInProgress.stateNode = ctor;
    ctor._reactInternalFiber = workInProgress;
    isLegacyContextConsumer && (workInProgress = workInProgress.stateNode, workInProgress.__reactInternalMemoizedUnmaskedChildContext = unmaskedContext, workInProgress.__reactInternalMemoizedMaskedChildContext = context);
    return ctor;
  }

  function callComponentWillReceiveProps(workInProgress, instance, newProps, nextContext) {
    workInProgress = instance.state;
    "function" === typeof instance.componentWillReceiveProps && instance.componentWillReceiveProps(newProps, nextContext);
    "function" === typeof instance.UNSAFE_componentWillReceiveProps && instance.UNSAFE_componentWillReceiveProps(newProps, nextContext);
    instance.state !== workInProgress && classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
  }

  function mountClassInstance(workInProgress, ctor, newProps, renderExpirationTime) {
    var instance = workInProgress.stateNode;
    instance.props = newProps;
    instance.state = workInProgress.memoizedState;
    instance.refs = emptyRefsObject;
    var contextType = ctor.contextType;
    "object" === typeof contextType && null !== contextType ? instance.context = readContext(contextType) : (contextType = isContextProvider(ctor) ? previousContext : contextStackCursor.current, instance.context = getMaskedContext(workInProgress, contextType));
    contextType = workInProgress.updateQueue;
    null !== contextType && (processUpdateQueue(workInProgress, contextType, newProps, instance, renderExpirationTime), instance.state = workInProgress.memoizedState);
    contextType = ctor.getDerivedStateFromProps;
    "function" === typeof contextType && (applyDerivedStateFromProps(workInProgress, ctor, contextType, newProps), instance.state = workInProgress.memoizedState);
    "function" === typeof ctor.getDerivedStateFromProps || "function" === typeof instance.getSnapshotBeforeUpdate || "function" !== typeof instance.UNSAFE_componentWillMount && "function" !== typeof instance.componentWillMount || (ctor = instance.state, "function" === typeof instance.componentWillMount && instance.componentWillMount(), "function" === typeof instance.UNSAFE_componentWillMount && instance.UNSAFE_componentWillMount(), ctor !== instance.state && classComponentUpdater.enqueueReplaceState(instance, instance.state, null), contextType = workInProgress.updateQueue, null !== contextType && (processUpdateQueue(workInProgress, contextType, newProps, instance, renderExpirationTime), instance.state = workInProgress.memoizedState));
    "function" === typeof instance.componentDidMount && (workInProgress.effectTag |= 4);
  }

  var isArray = Array.isArray;

  function coerceRef(returnFiber, current$$1, element) {
    returnFiber = element.ref;

    if (null !== returnFiber && "function" !== typeof returnFiber && "object" !== typeof returnFiber) {
      if (element._owner) {
        element = element._owner;
        var inst = void 0;

        if (element) {
          if (1 !== element.tag) throw ReactError(Error("Function components cannot have refs. Did you mean to use React.forwardRef()?"));
          inst = element.stateNode;
        }

        if (!inst) throw ReactError(Error("Missing owner for string ref " + returnFiber + ". This error is likely caused by a bug in React. Please file an issue."));
        var stringRef = "" + returnFiber;
        if (null !== current$$1 && null !== current$$1.ref && "function" === typeof current$$1.ref && current$$1.ref._stringRef === stringRef) return current$$1.ref;

        current$$1 = function current$$1(value) {
          var refs = inst.refs;
          refs === emptyRefsObject && (refs = inst.refs = {});
          null === value ? delete refs[stringRef] : refs[stringRef] = value;
        };

        current$$1._stringRef = stringRef;
        return current$$1;
      }

      if ("string" !== typeof returnFiber) throw ReactError(Error("Expected ref to be a function, a string, an object returned by React.createRef(), or null."));
      if (!element._owner) throw ReactError(Error("Element ref was specified as a string (" + returnFiber + ") but no owner was set. This could happen for one of the following reasons:\n1. You may be adding a ref to a function component\n2. You may be adding a ref to a component that was not created inside a component's render method\n3. You have multiple copies of React loaded\nSee https://fb.me/react-refs-must-have-owner for more information."));
    }

    return returnFiber;
  }

  function throwOnInvalidObjectType(returnFiber, newChild) {
    if ("textarea" !== returnFiber.type) throw ReactError(Error("Objects are not valid as a React child (found: " + ("[object Object]" === Object.prototype.toString.call(newChild) ? "object with keys {" + Object.keys(newChild).join(", ") + "}" : newChild) + ")."));
  }

  function ChildReconciler(shouldTrackSideEffects) {
    function deleteChild(returnFiber, childToDelete) {
      if (shouldTrackSideEffects) {
        var last = returnFiber.lastEffect;
        null !== last ? (last.nextEffect = childToDelete, returnFiber.lastEffect = childToDelete) : returnFiber.firstEffect = returnFiber.lastEffect = childToDelete;
        childToDelete.nextEffect = null;
        childToDelete.effectTag = 8;
      }
    }

    function deleteRemainingChildren(returnFiber, currentFirstChild) {
      if (!shouldTrackSideEffects) return null;

      for (; null !== currentFirstChild;) {
        deleteChild(returnFiber, currentFirstChild), currentFirstChild = currentFirstChild.sibling;
      }

      return null;
    }

    function mapRemainingChildren(returnFiber, currentFirstChild) {
      for (returnFiber = new Map(); null !== currentFirstChild;) {
        null !== currentFirstChild.key ? returnFiber.set(currentFirstChild.key, currentFirstChild) : returnFiber.set(currentFirstChild.index, currentFirstChild), currentFirstChild = currentFirstChild.sibling;
      }

      return returnFiber;
    }

    function useFiber(fiber, pendingProps, expirationTime) {
      fiber = createWorkInProgress(fiber, pendingProps, expirationTime);
      fiber.index = 0;
      fiber.sibling = null;
      return fiber;
    }

    function placeChild(newFiber, lastPlacedIndex, newIndex) {
      newFiber.index = newIndex;
      if (!shouldTrackSideEffects) return lastPlacedIndex;
      newIndex = newFiber.alternate;
      if (null !== newIndex) return newIndex = newIndex.index, newIndex < lastPlacedIndex ? (newFiber.effectTag = 2, lastPlacedIndex) : newIndex;
      newFiber.effectTag = 2;
      return lastPlacedIndex;
    }

    function placeSingleChild(newFiber) {
      shouldTrackSideEffects && null === newFiber.alternate && (newFiber.effectTag = 2);
      return newFiber;
    }

    function updateTextNode(returnFiber, current$$1, textContent, expirationTime) {
      if (null === current$$1 || 6 !== current$$1.tag) return current$$1 = createFiberFromText(textContent, returnFiber.mode, expirationTime), current$$1.return = returnFiber, current$$1;
      current$$1 = useFiber(current$$1, textContent, expirationTime);
      current$$1.return = returnFiber;
      return current$$1;
    }

    function updateElement(returnFiber, current$$1, element, expirationTime) {
      if (null !== current$$1 && current$$1.elementType === element.type) return expirationTime = useFiber(current$$1, element.props, expirationTime), expirationTime.ref = coerceRef(returnFiber, current$$1, element), expirationTime.return = returnFiber, expirationTime;
      expirationTime = createFiberFromTypeAndProps(element.type, element.key, element.props, null, returnFiber.mode, expirationTime);
      expirationTime.ref = coerceRef(returnFiber, current$$1, element);
      expirationTime.return = returnFiber;
      return expirationTime;
    }

    function updatePortal(returnFiber, current$$1, portal, expirationTime) {
      if (null === current$$1 || 4 !== current$$1.tag || current$$1.stateNode.containerInfo !== portal.containerInfo || current$$1.stateNode.implementation !== portal.implementation) return current$$1 = createFiberFromPortal(portal, returnFiber.mode, expirationTime), current$$1.return = returnFiber, current$$1;
      current$$1 = useFiber(current$$1, portal.children || [], expirationTime);
      current$$1.return = returnFiber;
      return current$$1;
    }

    function updateFragment(returnFiber, current$$1, fragment, expirationTime, key) {
      if (null === current$$1 || 7 !== current$$1.tag) return current$$1 = createFiberFromFragment(fragment, returnFiber.mode, expirationTime, key), current$$1.return = returnFiber, current$$1;
      current$$1 = useFiber(current$$1, fragment, expirationTime);
      current$$1.return = returnFiber;
      return current$$1;
    }

    function createChild(returnFiber, newChild, expirationTime) {
      if ("string" === typeof newChild || "number" === typeof newChild) return newChild = createFiberFromText("" + newChild, returnFiber.mode, expirationTime), newChild.return = returnFiber, newChild;

      if ("object" === typeof newChild && null !== newChild) {
        switch (newChild.$$typeof) {
          case REACT_ELEMENT_TYPE:
            return expirationTime = createFiberFromTypeAndProps(newChild.type, newChild.key, newChild.props, null, returnFiber.mode, expirationTime), expirationTime.ref = coerceRef(returnFiber, null, newChild), expirationTime.return = returnFiber, expirationTime;

          case REACT_PORTAL_TYPE:
            return newChild = createFiberFromPortal(newChild, returnFiber.mode, expirationTime), newChild.return = returnFiber, newChild;
        }

        if (isArray(newChild) || getIteratorFn(newChild)) return newChild = createFiberFromFragment(newChild, returnFiber.mode, expirationTime, null), newChild.return = returnFiber, newChild;
        throwOnInvalidObjectType(returnFiber, newChild);
      }

      return null;
    }

    function updateSlot(returnFiber, oldFiber, newChild, expirationTime) {
      var key = null !== oldFiber ? oldFiber.key : null;
      if ("string" === typeof newChild || "number" === typeof newChild) return null !== key ? null : updateTextNode(returnFiber, oldFiber, "" + newChild, expirationTime);

      if ("object" === typeof newChild && null !== newChild) {
        switch (newChild.$$typeof) {
          case REACT_ELEMENT_TYPE:
            return newChild.key === key ? newChild.type === REACT_FRAGMENT_TYPE ? updateFragment(returnFiber, oldFiber, newChild.props.children, expirationTime, key) : updateElement(returnFiber, oldFiber, newChild, expirationTime) : null;

          case REACT_PORTAL_TYPE:
            return newChild.key === key ? updatePortal(returnFiber, oldFiber, newChild, expirationTime) : null;
        }

        if (isArray(newChild) || getIteratorFn(newChild)) return null !== key ? null : updateFragment(returnFiber, oldFiber, newChild, expirationTime, null);
        throwOnInvalidObjectType(returnFiber, newChild);
      }

      return null;
    }

    function updateFromMap(existingChildren, returnFiber, newIdx, newChild, expirationTime) {
      if ("string" === typeof newChild || "number" === typeof newChild) return existingChildren = existingChildren.get(newIdx) || null, updateTextNode(returnFiber, existingChildren, "" + newChild, expirationTime);

      if ("object" === typeof newChild && null !== newChild) {
        switch (newChild.$$typeof) {
          case REACT_ELEMENT_TYPE:
            return existingChildren = existingChildren.get(null === newChild.key ? newIdx : newChild.key) || null, newChild.type === REACT_FRAGMENT_TYPE ? updateFragment(returnFiber, existingChildren, newChild.props.children, expirationTime, newChild.key) : updateElement(returnFiber, existingChildren, newChild, expirationTime);

          case REACT_PORTAL_TYPE:
            return existingChildren = existingChildren.get(null === newChild.key ? newIdx : newChild.key) || null, updatePortal(returnFiber, existingChildren, newChild, expirationTime);
        }

        if (isArray(newChild) || getIteratorFn(newChild)) return existingChildren = existingChildren.get(newIdx) || null, updateFragment(returnFiber, existingChildren, newChild, expirationTime, null);
        throwOnInvalidObjectType(returnFiber, newChild);
      }

      return null;
    }

    function reconcileChildrenArray(returnFiber, currentFirstChild, newChildren, expirationTime) {
      for (var resultingFirstChild = null, previousNewFiber = null, oldFiber = currentFirstChild, newIdx = currentFirstChild = 0, nextOldFiber = null; null !== oldFiber && newIdx < newChildren.length; newIdx++) {
        oldFiber.index > newIdx ? (nextOldFiber = oldFiber, oldFiber = null) : nextOldFiber = oldFiber.sibling;
        var newFiber = updateSlot(returnFiber, oldFiber, newChildren[newIdx], expirationTime);

        if (null === newFiber) {
          null === oldFiber && (oldFiber = nextOldFiber);
          break;
        }

        shouldTrackSideEffects && oldFiber && null === newFiber.alternate && deleteChild(returnFiber, oldFiber);
        currentFirstChild = placeChild(newFiber, currentFirstChild, newIdx);
        null === previousNewFiber ? resultingFirstChild = newFiber : previousNewFiber.sibling = newFiber;
        previousNewFiber = newFiber;
        oldFiber = nextOldFiber;
      }

      if (newIdx === newChildren.length) return deleteRemainingChildren(returnFiber, oldFiber), resultingFirstChild;

      if (null === oldFiber) {
        for (; newIdx < newChildren.length; newIdx++) {
          oldFiber = createChild(returnFiber, newChildren[newIdx], expirationTime), null !== oldFiber && (currentFirstChild = placeChild(oldFiber, currentFirstChild, newIdx), null === previousNewFiber ? resultingFirstChild = oldFiber : previousNewFiber.sibling = oldFiber, previousNewFiber = oldFiber);
        }

        return resultingFirstChild;
      }

      for (oldFiber = mapRemainingChildren(returnFiber, oldFiber); newIdx < newChildren.length; newIdx++) {
        nextOldFiber = updateFromMap(oldFiber, returnFiber, newIdx, newChildren[newIdx], expirationTime), null !== nextOldFiber && (shouldTrackSideEffects && null !== nextOldFiber.alternate && oldFiber.delete(null === nextOldFiber.key ? newIdx : nextOldFiber.key), currentFirstChild = placeChild(nextOldFiber, currentFirstChild, newIdx), null === previousNewFiber ? resultingFirstChild = nextOldFiber : previousNewFiber.sibling = nextOldFiber, previousNewFiber = nextOldFiber);
      }

      shouldTrackSideEffects && oldFiber.forEach(function (child) {
        return deleteChild(returnFiber, child);
      });
      return resultingFirstChild;
    }

    function reconcileChildrenIterator(returnFiber, currentFirstChild, newChildrenIterable, expirationTime) {
      var iteratorFn = getIteratorFn(newChildrenIterable);
      if ("function" !== typeof iteratorFn) throw ReactError(Error("An object is not an iterable. This error is likely caused by a bug in React. Please file an issue."));
      newChildrenIterable = iteratorFn.call(newChildrenIterable);
      if (null == newChildrenIterable) throw ReactError(Error("An iterable object provided no iterator."));

      for (var previousNewFiber = iteratorFn = null, oldFiber = currentFirstChild, newIdx = currentFirstChild = 0, nextOldFiber = null, step = newChildrenIterable.next(); null !== oldFiber && !step.done; newIdx++, step = newChildrenIterable.next()) {
        oldFiber.index > newIdx ? (nextOldFiber = oldFiber, oldFiber = null) : nextOldFiber = oldFiber.sibling;
        var newFiber = updateSlot(returnFiber, oldFiber, step.value, expirationTime);

        if (null === newFiber) {
          null === oldFiber && (oldFiber = nextOldFiber);
          break;
        }

        shouldTrackSideEffects && oldFiber && null === newFiber.alternate && deleteChild(returnFiber, oldFiber);
        currentFirstChild = placeChild(newFiber, currentFirstChild, newIdx);
        null === previousNewFiber ? iteratorFn = newFiber : previousNewFiber.sibling = newFiber;
        previousNewFiber = newFiber;
        oldFiber = nextOldFiber;
      }

      if (step.done) return deleteRemainingChildren(returnFiber, oldFiber), iteratorFn;

      if (null === oldFiber) {
        for (; !step.done; newIdx++, step = newChildrenIterable.next()) {
          step = createChild(returnFiber, step.value, expirationTime), null !== step && (currentFirstChild = placeChild(step, currentFirstChild, newIdx), null === previousNewFiber ? iteratorFn = step : previousNewFiber.sibling = step, previousNewFiber = step);
        }

        return iteratorFn;
      }

      for (oldFiber = mapRemainingChildren(returnFiber, oldFiber); !step.done; newIdx++, step = newChildrenIterable.next()) {
        step = updateFromMap(oldFiber, returnFiber, newIdx, step.value, expirationTime), null !== step && (shouldTrackSideEffects && null !== step.alternate && oldFiber.delete(null === step.key ? newIdx : step.key), currentFirstChild = placeChild(step, currentFirstChild, newIdx), null === previousNewFiber ? iteratorFn = step : previousNewFiber.sibling = step, previousNewFiber = step);
      }

      shouldTrackSideEffects && oldFiber.forEach(function (child) {
        return deleteChild(returnFiber, child);
      });
      return iteratorFn;
    }

    return function (returnFiber, currentFirstChild, newChild, expirationTime) {
      var isUnkeyedTopLevelFragment = "object" === typeof newChild && null !== newChild && newChild.type === REACT_FRAGMENT_TYPE && null === newChild.key;
      isUnkeyedTopLevelFragment && (newChild = newChild.props.children);
      var isObject = "object" === typeof newChild && null !== newChild;
      if (isObject) switch (newChild.$$typeof) {
        case REACT_ELEMENT_TYPE:
          a: {
            isObject = newChild.key;

            for (isUnkeyedTopLevelFragment = currentFirstChild; null !== isUnkeyedTopLevelFragment;) {
              if (isUnkeyedTopLevelFragment.key === isObject) {
                if (7 === isUnkeyedTopLevelFragment.tag ? newChild.type === REACT_FRAGMENT_TYPE : isUnkeyedTopLevelFragment.elementType === newChild.type) {
                  deleteRemainingChildren(returnFiber, isUnkeyedTopLevelFragment.sibling);
                  currentFirstChild = useFiber(isUnkeyedTopLevelFragment, newChild.type === REACT_FRAGMENT_TYPE ? newChild.props.children : newChild.props, expirationTime);
                  currentFirstChild.ref = coerceRef(returnFiber, isUnkeyedTopLevelFragment, newChild);
                  currentFirstChild.return = returnFiber;
                  returnFiber = currentFirstChild;
                  break a;
                }

                deleteRemainingChildren(returnFiber, isUnkeyedTopLevelFragment);
                break;
              } else deleteChild(returnFiber, isUnkeyedTopLevelFragment);

              isUnkeyedTopLevelFragment = isUnkeyedTopLevelFragment.sibling;
            }

            newChild.type === REACT_FRAGMENT_TYPE ? (currentFirstChild = createFiberFromFragment(newChild.props.children, returnFiber.mode, expirationTime, newChild.key), currentFirstChild.return = returnFiber, returnFiber = currentFirstChild) : (expirationTime = createFiberFromTypeAndProps(newChild.type, newChild.key, newChild.props, null, returnFiber.mode, expirationTime), expirationTime.ref = coerceRef(returnFiber, currentFirstChild, newChild), expirationTime.return = returnFiber, returnFiber = expirationTime);
          }

          return placeSingleChild(returnFiber);

        case REACT_PORTAL_TYPE:
          a: {
            for (isUnkeyedTopLevelFragment = newChild.key; null !== currentFirstChild;) {
              if (currentFirstChild.key === isUnkeyedTopLevelFragment) {
                if (4 === currentFirstChild.tag && currentFirstChild.stateNode.containerInfo === newChild.containerInfo && currentFirstChild.stateNode.implementation === newChild.implementation) {
                  deleteRemainingChildren(returnFiber, currentFirstChild.sibling);
                  currentFirstChild = useFiber(currentFirstChild, newChild.children || [], expirationTime);
                  currentFirstChild.return = returnFiber;
                  returnFiber = currentFirstChild;
                  break a;
                }

                deleteRemainingChildren(returnFiber, currentFirstChild);
                break;
              } else deleteChild(returnFiber, currentFirstChild);

              currentFirstChild = currentFirstChild.sibling;
            }

            currentFirstChild = createFiberFromPortal(newChild, returnFiber.mode, expirationTime);
            currentFirstChild.return = returnFiber;
            returnFiber = currentFirstChild;
          }

          return placeSingleChild(returnFiber);
      }
      if ("string" === typeof newChild || "number" === typeof newChild) return newChild = "" + newChild, null !== currentFirstChild && 6 === currentFirstChild.tag ? (deleteRemainingChildren(returnFiber, currentFirstChild.sibling), currentFirstChild = useFiber(currentFirstChild, newChild, expirationTime), currentFirstChild.return = returnFiber, returnFiber = currentFirstChild) : (deleteRemainingChildren(returnFiber, currentFirstChild), currentFirstChild = createFiberFromText(newChild, returnFiber.mode, expirationTime), currentFirstChild.return = returnFiber, returnFiber = currentFirstChild), placeSingleChild(returnFiber);
      if (isArray(newChild)) return reconcileChildrenArray(returnFiber, currentFirstChild, newChild, expirationTime);
      if (getIteratorFn(newChild)) return reconcileChildrenIterator(returnFiber, currentFirstChild, newChild, expirationTime);
      isObject && throwOnInvalidObjectType(returnFiber, newChild);
      if ("undefined" === typeof newChild && !isUnkeyedTopLevelFragment) switch (returnFiber.tag) {
        case 1:
        case 0:
          throw returnFiber = returnFiber.type, ReactError(Error((returnFiber.displayName || returnFiber.name || "Component") + "(...): Nothing was returned from render. This usually means a return statement is missing. Or, to render nothing, return null."));
      }
      return deleteRemainingChildren(returnFiber, currentFirstChild);
    };
  }

  var reconcileChildFibers = ChildReconciler(!0),
      mountChildFibers = ChildReconciler(!1),
      NO_CONTEXT = {},
      contextStackCursor$1 = {
    current: NO_CONTEXT
  },
      contextFiberStackCursor = {
    current: NO_CONTEXT
  },
      rootInstanceStackCursor = {
    current: NO_CONTEXT
  };

  function requiredContext(c) {
    if (c === NO_CONTEXT) throw ReactError(Error("Expected host context to exist. This error is likely caused by a bug in React. Please file an issue."));
    return c;
  }

  function pushHostContainer(fiber, nextRootInstance) {
    push(rootInstanceStackCursor, nextRootInstance, fiber);
    push(contextFiberStackCursor, fiber, fiber);
    push(contextStackCursor$1, NO_CONTEXT, fiber);
    pop(contextStackCursor$1, fiber);
    push(contextStackCursor$1, {
      isInAParentText: !1
    }, fiber);
  }

  function popHostContainer(fiber) {
    pop(contextStackCursor$1, fiber);
    pop(contextFiberStackCursor, fiber);
    pop(rootInstanceStackCursor, fiber);
  }

  function pushHostContext(fiber) {
    requiredContext(rootInstanceStackCursor.current);
    var context = requiredContext(contextStackCursor$1.current);
    var nextContext = fiber.type;
    nextContext = "AndroidTextInput" === nextContext || "RCTMultilineTextInputView" === nextContext || "RCTSinglelineTextInputView" === nextContext || "RCTText" === nextContext || "RCTVirtualText" === nextContext;
    nextContext = context.isInAParentText !== nextContext ? {
      isInAParentText: nextContext
    } : context;
    context !== nextContext && (push(contextFiberStackCursor, fiber, fiber), push(contextStackCursor$1, nextContext, fiber));
  }

  function popHostContext(fiber) {
    contextFiberStackCursor.current === fiber && (pop(contextStackCursor$1, fiber), pop(contextFiberStackCursor, fiber));
  }

  var SubtreeSuspenseContextMask = 1,
      InvisibleParentSuspenseContext = 1,
      ForceSuspenseFallback = 2,
      suspenseStackCursor = {
    current: 0
  };

  function findFirstSuspended(row) {
    for (var node = row; null !== node;) {
      if (13 === node.tag) {
        if (null !== node.memoizedState) return node;
      } else if (19 === node.tag && void 0 !== node.memoizedProps.revealOrder) {
        if (0 !== (node.effectTag & 64)) return node;
      } else if (null !== node.child) {
        node.child.return = node;
        node = node.child;
        continue;
      }

      if (node === row) break;

      for (; null === node.sibling;) {
        if (null === node.return || node.return === row) return null;
        node = node.return;
      }

      node.sibling.return = node.return;
      node = node.sibling;
    }

    return null;
  }

  function createResponderListener(responder, props) {
    return {
      responder: responder,
      props: props
    };
  }

  var NoEffect$1 = 0,
      UnmountSnapshot = 2,
      UnmountMutation = 4,
      MountMutation = 8,
      UnmountLayout = 16,
      MountLayout = 32,
      MountPassive = 64,
      UnmountPassive = 128,
      ReactCurrentDispatcher$1 = ReactSharedInternals.ReactCurrentDispatcher,
      renderExpirationTime$1 = 0,
      currentlyRenderingFiber$1 = null,
      currentHook = null,
      nextCurrentHook = null,
      firstWorkInProgressHook = null,
      workInProgressHook = null,
      nextWorkInProgressHook = null,
      remainingExpirationTime = 0,
      componentUpdateQueue = null,
      sideEffectTag = 0,
      didScheduleRenderPhaseUpdate = !1,
      renderPhaseUpdates = null,
      numberOfReRenders = 0;

  function throwInvalidHookError() {
    throw ReactError(Error("Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of the following reasons:\n1. You might have mismatching versions of React and the renderer (such as React DOM)\n2. You might be breaking the Rules of Hooks\n3. You might have more than one copy of React in the same app\nSee https://fb.me/react-invalid-hook-call for tips about how to debug and fix this problem."));
  }

  function areHookInputsEqual(nextDeps, prevDeps) {
    if (null === prevDeps) return !1;

    for (var i = 0; i < prevDeps.length && i < nextDeps.length; i++) {
      if (!is(nextDeps[i], prevDeps[i])) return !1;
    }

    return !0;
  }

  function renderWithHooks(current, workInProgress, Component, props, refOrContext, nextRenderExpirationTime) {
    renderExpirationTime$1 = nextRenderExpirationTime;
    currentlyRenderingFiber$1 = workInProgress;
    nextCurrentHook = null !== current ? current.memoizedState : null;
    ReactCurrentDispatcher$1.current = null === nextCurrentHook ? HooksDispatcherOnMount : HooksDispatcherOnUpdate;
    workInProgress = Component(props, refOrContext);

    if (didScheduleRenderPhaseUpdate) {
      do {
        didScheduleRenderPhaseUpdate = !1, numberOfReRenders += 1, nextCurrentHook = null !== current ? current.memoizedState : null, nextWorkInProgressHook = firstWorkInProgressHook, componentUpdateQueue = workInProgressHook = currentHook = null, ReactCurrentDispatcher$1.current = HooksDispatcherOnUpdate, workInProgress = Component(props, refOrContext);
      } while (didScheduleRenderPhaseUpdate);

      renderPhaseUpdates = null;
      numberOfReRenders = 0;
    }

    ReactCurrentDispatcher$1.current = ContextOnlyDispatcher;
    current = currentlyRenderingFiber$1;
    current.memoizedState = firstWorkInProgressHook;
    current.expirationTime = remainingExpirationTime;
    current.updateQueue = componentUpdateQueue;
    current.effectTag |= sideEffectTag;
    current = null !== currentHook && null !== currentHook.next;
    renderExpirationTime$1 = 0;
    nextWorkInProgressHook = workInProgressHook = firstWorkInProgressHook = nextCurrentHook = currentHook = currentlyRenderingFiber$1 = null;
    remainingExpirationTime = 0;
    componentUpdateQueue = null;
    sideEffectTag = 0;
    if (current) throw ReactError(Error("Rendered fewer hooks than expected. This may be caused by an accidental early return statement."));
    return workInProgress;
  }

  function resetHooks() {
    ReactCurrentDispatcher$1.current = ContextOnlyDispatcher;
    renderExpirationTime$1 = 0;
    nextWorkInProgressHook = workInProgressHook = firstWorkInProgressHook = nextCurrentHook = currentHook = currentlyRenderingFiber$1 = null;
    remainingExpirationTime = 0;
    componentUpdateQueue = null;
    sideEffectTag = 0;
    didScheduleRenderPhaseUpdate = !1;
    renderPhaseUpdates = null;
    numberOfReRenders = 0;
  }

  function mountWorkInProgressHook() {
    var hook = {
      memoizedState: null,
      baseState: null,
      queue: null,
      baseUpdate: null,
      next: null
    };
    null === workInProgressHook ? firstWorkInProgressHook = workInProgressHook = hook : workInProgressHook = workInProgressHook.next = hook;
    return workInProgressHook;
  }

  function updateWorkInProgressHook() {
    if (null !== nextWorkInProgressHook) workInProgressHook = nextWorkInProgressHook, nextWorkInProgressHook = workInProgressHook.next, currentHook = nextCurrentHook, nextCurrentHook = null !== currentHook ? currentHook.next : null;else {
      if (null === nextCurrentHook) throw ReactError(Error("Rendered more hooks than during the previous render."));
      currentHook = nextCurrentHook;
      var newHook = {
        memoizedState: currentHook.memoizedState,
        baseState: currentHook.baseState,
        queue: currentHook.queue,
        baseUpdate: currentHook.baseUpdate,
        next: null
      };
      workInProgressHook = null === workInProgressHook ? firstWorkInProgressHook = newHook : workInProgressHook.next = newHook;
      nextCurrentHook = currentHook.next;
    }
    return workInProgressHook;
  }

  function basicStateReducer(state, action) {
    return "function" === typeof action ? action(state) : action;
  }

  function updateReducer(reducer) {
    var hook = updateWorkInProgressHook(),
        queue = hook.queue;
    if (null === queue) throw ReactError(Error("Should have a queue. This is likely a bug in React. Please file an issue."));
    queue.lastRenderedReducer = reducer;

    if (0 < numberOfReRenders) {
      var _dispatch = queue.dispatch;

      if (null !== renderPhaseUpdates) {
        var firstRenderPhaseUpdate = renderPhaseUpdates.get(queue);

        if (void 0 !== firstRenderPhaseUpdate) {
          renderPhaseUpdates.delete(queue);
          var newState = hook.memoizedState;

          do {
            newState = reducer(newState, firstRenderPhaseUpdate.action), firstRenderPhaseUpdate = firstRenderPhaseUpdate.next;
          } while (null !== firstRenderPhaseUpdate);

          is(newState, hook.memoizedState) || (didReceiveUpdate = !0);
          hook.memoizedState = newState;
          hook.baseUpdate === queue.last && (hook.baseState = newState);
          queue.lastRenderedState = newState;
          return [newState, _dispatch];
        }
      }

      return [hook.memoizedState, _dispatch];
    }

    _dispatch = queue.last;
    var baseUpdate = hook.baseUpdate;
    newState = hook.baseState;
    null !== baseUpdate ? (null !== _dispatch && (_dispatch.next = null), _dispatch = baseUpdate.next) : _dispatch = null !== _dispatch ? _dispatch.next : null;

    if (null !== _dispatch) {
      var newBaseUpdate = firstRenderPhaseUpdate = null,
          _update = _dispatch,
          didSkip = !1;

      do {
        var updateExpirationTime = _update.expirationTime;
        updateExpirationTime < renderExpirationTime$1 ? (didSkip || (didSkip = !0, newBaseUpdate = baseUpdate, firstRenderPhaseUpdate = newState), updateExpirationTime > remainingExpirationTime && (remainingExpirationTime = updateExpirationTime)) : (markRenderEventTimeAndConfig(updateExpirationTime, _update.suspenseConfig), newState = _update.eagerReducer === reducer ? _update.eagerState : reducer(newState, _update.action));
        baseUpdate = _update;
        _update = _update.next;
      } while (null !== _update && _update !== _dispatch);

      didSkip || (newBaseUpdate = baseUpdate, firstRenderPhaseUpdate = newState);
      is(newState, hook.memoizedState) || (didReceiveUpdate = !0);
      hook.memoizedState = newState;
      hook.baseUpdate = newBaseUpdate;
      hook.baseState = firstRenderPhaseUpdate;
      queue.lastRenderedState = newState;
    }

    return [hook.memoizedState, queue.dispatch];
  }

  function pushEffect(tag, create, destroy, deps) {
    tag = {
      tag: tag,
      create: create,
      destroy: destroy,
      deps: deps,
      next: null
    };
    null === componentUpdateQueue ? (componentUpdateQueue = {
      lastEffect: null
    }, componentUpdateQueue.lastEffect = tag.next = tag) : (create = componentUpdateQueue.lastEffect, null === create ? componentUpdateQueue.lastEffect = tag.next = tag : (destroy = create.next, create.next = tag, tag.next = destroy, componentUpdateQueue.lastEffect = tag));
    return tag;
  }

  function mountEffectImpl(fiberEffectTag, hookEffectTag, create, deps) {
    var hook = mountWorkInProgressHook();
    sideEffectTag |= fiberEffectTag;
    hook.memoizedState = pushEffect(hookEffectTag, create, void 0, void 0 === deps ? null : deps);
  }

  function updateEffectImpl(fiberEffectTag, hookEffectTag, create, deps) {
    var hook = updateWorkInProgressHook();
    deps = void 0 === deps ? null : deps;
    var destroy = void 0;

    if (null !== currentHook) {
      var prevEffect = currentHook.memoizedState;
      destroy = prevEffect.destroy;

      if (null !== deps && areHookInputsEqual(deps, prevEffect.deps)) {
        pushEffect(NoEffect$1, create, destroy, deps);
        return;
      }
    }

    sideEffectTag |= fiberEffectTag;
    hook.memoizedState = pushEffect(hookEffectTag, create, destroy, deps);
  }

  function imperativeHandleEffect(create, ref) {
    if ("function" === typeof ref) return create = create(), ref(create), function () {
      ref(null);
    };
    if (null !== ref && void 0 !== ref) return create = create(), ref.current = create, function () {
      ref.current = null;
    };
  }

  function mountDebugValue() {}

  function dispatchAction(fiber, queue, action) {
    if (!(25 > numberOfReRenders)) throw ReactError(Error("Too many re-renders. React limits the number of renders to prevent an infinite loop."));
    var alternate = fiber.alternate;
    if (fiber === currentlyRenderingFiber$1 || null !== alternate && alternate === currentlyRenderingFiber$1) {
      if (didScheduleRenderPhaseUpdate = !0, fiber = {
        expirationTime: renderExpirationTime$1,
        suspenseConfig: null,
        action: action,
        eagerReducer: null,
        eagerState: null,
        next: null
      }, null === renderPhaseUpdates && (renderPhaseUpdates = new Map()), action = renderPhaseUpdates.get(queue), void 0 === action) renderPhaseUpdates.set(queue, fiber);else {
        for (queue = action; null !== queue.next;) {
          queue = queue.next;
        }

        queue.next = fiber;
      }
    } else {
      var currentTime = requestCurrentTime(),
          _suspenseConfig = ReactCurrentBatchConfig.suspense;
      currentTime = computeExpirationForFiber(currentTime, fiber, _suspenseConfig);
      _suspenseConfig = {
        expirationTime: currentTime,
        suspenseConfig: _suspenseConfig,
        action: action,
        eagerReducer: null,
        eagerState: null,
        next: null
      };
      var _last = queue.last;
      if (null === _last) _suspenseConfig.next = _suspenseConfig;else {
        var first = _last.next;
        null !== first && (_suspenseConfig.next = first);
        _last.next = _suspenseConfig;
      }
      queue.last = _suspenseConfig;
      if (0 === fiber.expirationTime && (null === alternate || 0 === alternate.expirationTime) && (alternate = queue.lastRenderedReducer, null !== alternate)) try {
        var currentState = queue.lastRenderedState,
            _eagerState = alternate(currentState, action);

        _suspenseConfig.eagerReducer = alternate;
        _suspenseConfig.eagerState = _eagerState;
        if (is(_eagerState, currentState)) return;
      } catch (error) {} finally {}
      scheduleUpdateOnFiber(fiber, currentTime);
    }
  }

  var ContextOnlyDispatcher = {
    readContext: readContext,
    useCallback: throwInvalidHookError,
    useContext: throwInvalidHookError,
    useEffect: throwInvalidHookError,
    useImperativeHandle: throwInvalidHookError,
    useLayoutEffect: throwInvalidHookError,
    useMemo: throwInvalidHookError,
    useReducer: throwInvalidHookError,
    useRef: throwInvalidHookError,
    useState: throwInvalidHookError,
    useDebugValue: throwInvalidHookError,
    useResponder: throwInvalidHookError
  },
      HooksDispatcherOnMount = {
    readContext: readContext,
    useCallback: function useCallback(callback, deps) {
      mountWorkInProgressHook().memoizedState = [callback, void 0 === deps ? null : deps];
      return callback;
    },
    useContext: readContext,
    useEffect: function useEffect(create, deps) {
      return mountEffectImpl(516, UnmountPassive | MountPassive, create, deps);
    },
    useImperativeHandle: function useImperativeHandle(ref, create, deps) {
      deps = null !== deps && void 0 !== deps ? deps.concat([ref]) : null;
      return mountEffectImpl(4, UnmountMutation | MountLayout, imperativeHandleEffect.bind(null, create, ref), deps);
    },
    useLayoutEffect: function useLayoutEffect(create, deps) {
      return mountEffectImpl(4, UnmountMutation | MountLayout, create, deps);
    },
    useMemo: function useMemo(nextCreate, deps) {
      var hook = mountWorkInProgressHook();
      deps = void 0 === deps ? null : deps;
      nextCreate = nextCreate();
      hook.memoizedState = [nextCreate, deps];
      return nextCreate;
    },
    useReducer: function useReducer(reducer, initialArg, init) {
      var hook = mountWorkInProgressHook();
      initialArg = void 0 !== init ? init(initialArg) : initialArg;
      hook.memoizedState = hook.baseState = initialArg;
      reducer = hook.queue = {
        last: null,
        dispatch: null,
        lastRenderedReducer: reducer,
        lastRenderedState: initialArg
      };
      reducer = reducer.dispatch = dispatchAction.bind(null, currentlyRenderingFiber$1, reducer);
      return [hook.memoizedState, reducer];
    },
    useRef: function useRef(initialValue) {
      var hook = mountWorkInProgressHook();
      initialValue = {
        current: initialValue
      };
      return hook.memoizedState = initialValue;
    },
    useState: function useState(initialState) {
      var hook = mountWorkInProgressHook();
      "function" === typeof initialState && (initialState = initialState());
      hook.memoizedState = hook.baseState = initialState;
      initialState = hook.queue = {
        last: null,
        dispatch: null,
        lastRenderedReducer: basicStateReducer,
        lastRenderedState: initialState
      };
      initialState = initialState.dispatch = dispatchAction.bind(null, currentlyRenderingFiber$1, initialState);
      return [hook.memoizedState, initialState];
    },
    useDebugValue: mountDebugValue,
    useResponder: createResponderListener
  },
      HooksDispatcherOnUpdate = {
    readContext: readContext,
    useCallback: function useCallback(callback, deps) {
      var hook = updateWorkInProgressHook();
      deps = void 0 === deps ? null : deps;
      var prevState = hook.memoizedState;
      if (null !== prevState && null !== deps && areHookInputsEqual(deps, prevState[1])) return prevState[0];
      hook.memoizedState = [callback, deps];
      return callback;
    },
    useContext: readContext,
    useEffect: function useEffect(create, deps) {
      return updateEffectImpl(516, UnmountPassive | MountPassive, create, deps);
    },
    useImperativeHandle: function useImperativeHandle(ref, create, deps) {
      deps = null !== deps && void 0 !== deps ? deps.concat([ref]) : null;
      return updateEffectImpl(4, UnmountMutation | MountLayout, imperativeHandleEffect.bind(null, create, ref), deps);
    },
    useLayoutEffect: function useLayoutEffect(create, deps) {
      return updateEffectImpl(4, UnmountMutation | MountLayout, create, deps);
    },
    useMemo: function useMemo(nextCreate, deps) {
      var hook = updateWorkInProgressHook();
      deps = void 0 === deps ? null : deps;
      var prevState = hook.memoizedState;
      if (null !== prevState && null !== deps && areHookInputsEqual(deps, prevState[1])) return prevState[0];
      nextCreate = nextCreate();
      hook.memoizedState = [nextCreate, deps];
      return nextCreate;
    },
    useReducer: updateReducer,
    useRef: function useRef() {
      return updateWorkInProgressHook().memoizedState;
    },
    useState: function useState(initialState) {
      return updateReducer(basicStateReducer, initialState);
    },
    useDebugValue: mountDebugValue,
    useResponder: createResponderListener
  },
      hydrationParentFiber = null,
      nextHydratableInstance = null,
      isHydrating = !1;

  function tryHydrate(fiber, nextInstance) {
    switch (fiber.tag) {
      case 5:
        return nextInstance = shim$1(nextInstance, fiber.type, fiber.pendingProps), null !== nextInstance ? (fiber.stateNode = nextInstance, !0) : !1;

      case 6:
        return nextInstance = shim$1(nextInstance, fiber.pendingProps), null !== nextInstance ? (fiber.stateNode = nextInstance, !0) : !1;

      case 13:
        return !1;

      default:
        return !1;
    }
  }

  function tryToClaimNextHydratableInstance(fiber$jscomp$0) {
    if (isHydrating) {
      var nextInstance = nextHydratableInstance;

      if (nextInstance) {
        var firstAttemptedInstance = nextInstance;

        if (!tryHydrate(fiber$jscomp$0, nextInstance)) {
          nextInstance = shim$1(firstAttemptedInstance);

          if (!nextInstance || !tryHydrate(fiber$jscomp$0, nextInstance)) {
            fiber$jscomp$0.effectTag |= 2;
            isHydrating = !1;
            hydrationParentFiber = fiber$jscomp$0;
            return;
          }

          var returnFiber = hydrationParentFiber,
              fiber = createFiber(5, null, null, 0);
          fiber.elementType = "DELETED";
          fiber.type = "DELETED";
          fiber.stateNode = firstAttemptedInstance;
          fiber.return = returnFiber;
          fiber.effectTag = 8;
          null !== returnFiber.lastEffect ? (returnFiber.lastEffect.nextEffect = fiber, returnFiber.lastEffect = fiber) : returnFiber.firstEffect = returnFiber.lastEffect = fiber;
        }

        hydrationParentFiber = fiber$jscomp$0;
        nextHydratableInstance = shim$1(nextInstance);
      } else fiber$jscomp$0.effectTag |= 2, isHydrating = !1, hydrationParentFiber = fiber$jscomp$0;
    }
  }

  var ReactCurrentOwner$3 = ReactSharedInternals.ReactCurrentOwner,
      didReceiveUpdate = !1;

  function reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime) {
    workInProgress.child = null === current$$1 ? mountChildFibers(workInProgress, null, nextChildren, renderExpirationTime) : reconcileChildFibers(workInProgress, current$$1.child, nextChildren, renderExpirationTime);
  }

  function updateForwardRef(current$$1, workInProgress, Component, nextProps, renderExpirationTime) {
    Component = Component.render;
    var ref = workInProgress.ref;
    prepareToReadContext(workInProgress, renderExpirationTime);
    nextProps = renderWithHooks(current$$1, workInProgress, Component, nextProps, ref, renderExpirationTime);
    if (null !== current$$1 && !didReceiveUpdate) return workInProgress.updateQueue = current$$1.updateQueue, workInProgress.effectTag &= -517, current$$1.expirationTime <= renderExpirationTime && (current$$1.expirationTime = 0), bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
    workInProgress.effectTag |= 1;
    reconcileChildren(current$$1, workInProgress, nextProps, renderExpirationTime);
    return workInProgress.child;
  }

  function updateMemoComponent(current$$1, workInProgress, Component, nextProps, updateExpirationTime, renderExpirationTime) {
    if (null === current$$1) {
      var type = Component.type;
      if ("function" === typeof type && !shouldConstruct(type) && void 0 === type.defaultProps && null === Component.compare && void 0 === Component.defaultProps) return workInProgress.tag = 15, workInProgress.type = type, updateSimpleMemoComponent(current$$1, workInProgress, type, nextProps, updateExpirationTime, renderExpirationTime);
      current$$1 = createFiberFromTypeAndProps(Component.type, null, nextProps, null, workInProgress.mode, renderExpirationTime);
      current$$1.ref = workInProgress.ref;
      current$$1.return = workInProgress;
      return workInProgress.child = current$$1;
    }

    type = current$$1.child;
    if (updateExpirationTime < renderExpirationTime && (updateExpirationTime = type.memoizedProps, Component = Component.compare, Component = null !== Component ? Component : shallowEqual, Component(updateExpirationTime, nextProps) && current$$1.ref === workInProgress.ref)) return bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
    workInProgress.effectTag |= 1;
    current$$1 = createWorkInProgress(type, nextProps, renderExpirationTime);
    current$$1.ref = workInProgress.ref;
    current$$1.return = workInProgress;
    return workInProgress.child = current$$1;
  }

  function updateSimpleMemoComponent(current$$1, workInProgress, Component, nextProps, updateExpirationTime, renderExpirationTime) {
    return null !== current$$1 && shallowEqual(current$$1.memoizedProps, nextProps) && current$$1.ref === workInProgress.ref && (didReceiveUpdate = !1, updateExpirationTime < renderExpirationTime) ? bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime) : updateFunctionComponent(current$$1, workInProgress, Component, nextProps, renderExpirationTime);
  }

  function markRef(current$$1, workInProgress) {
    var ref = workInProgress.ref;
    if (null === current$$1 && null !== ref || null !== current$$1 && current$$1.ref !== ref) workInProgress.effectTag |= 128;
  }

  function updateFunctionComponent(current$$1, workInProgress, Component, nextProps, renderExpirationTime) {
    var context = isContextProvider(Component) ? previousContext : contextStackCursor.current;
    context = getMaskedContext(workInProgress, context);
    prepareToReadContext(workInProgress, renderExpirationTime);
    Component = renderWithHooks(current$$1, workInProgress, Component, nextProps, context, renderExpirationTime);
    if (null !== current$$1 && !didReceiveUpdate) return workInProgress.updateQueue = current$$1.updateQueue, workInProgress.effectTag &= -517, current$$1.expirationTime <= renderExpirationTime && (current$$1.expirationTime = 0), bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
    workInProgress.effectTag |= 1;
    reconcileChildren(current$$1, workInProgress, Component, renderExpirationTime);
    return workInProgress.child;
  }

  function updateClassComponent(current$$1, workInProgress, Component, nextProps, renderExpirationTime) {
    if (isContextProvider(Component)) {
      var hasContext = !0;
      pushContextProvider(workInProgress);
    } else hasContext = !1;

    prepareToReadContext(workInProgress, renderExpirationTime);
    if (null === workInProgress.stateNode) null !== current$$1 && (current$$1.alternate = null, workInProgress.alternate = null, workInProgress.effectTag |= 2), constructClassInstance(workInProgress, Component, nextProps, renderExpirationTime), mountClassInstance(workInProgress, Component, nextProps, renderExpirationTime), nextProps = !0;else if (null === current$$1) {
      var instance = workInProgress.stateNode,
          oldProps = workInProgress.memoizedProps;
      instance.props = oldProps;
      var oldContext = instance.context,
          contextType = Component.contextType;
      "object" === typeof contextType && null !== contextType ? contextType = readContext(contextType) : (contextType = isContextProvider(Component) ? previousContext : contextStackCursor.current, contextType = getMaskedContext(workInProgress, contextType));
      var getDerivedStateFromProps = Component.getDerivedStateFromProps,
          hasNewLifecycles = "function" === typeof getDerivedStateFromProps || "function" === typeof instance.getSnapshotBeforeUpdate;
      hasNewLifecycles || "function" !== typeof instance.UNSAFE_componentWillReceiveProps && "function" !== typeof instance.componentWillReceiveProps || (oldProps !== nextProps || oldContext !== contextType) && callComponentWillReceiveProps(workInProgress, instance, nextProps, contextType);
      hasForceUpdate = !1;
      var oldState = workInProgress.memoizedState;
      oldContext = instance.state = oldState;
      var updateQueue = workInProgress.updateQueue;
      null !== updateQueue && (processUpdateQueue(workInProgress, updateQueue, nextProps, instance, renderExpirationTime), oldContext = workInProgress.memoizedState);
      oldProps !== nextProps || oldState !== oldContext || didPerformWorkStackCursor.current || hasForceUpdate ? ("function" === typeof getDerivedStateFromProps && (applyDerivedStateFromProps(workInProgress, Component, getDerivedStateFromProps, nextProps), oldContext = workInProgress.memoizedState), (oldProps = hasForceUpdate || checkShouldComponentUpdate(workInProgress, Component, oldProps, nextProps, oldState, oldContext, contextType)) ? (hasNewLifecycles || "function" !== typeof instance.UNSAFE_componentWillMount && "function" !== typeof instance.componentWillMount || ("function" === typeof instance.componentWillMount && instance.componentWillMount(), "function" === typeof instance.UNSAFE_componentWillMount && instance.UNSAFE_componentWillMount()), "function" === typeof instance.componentDidMount && (workInProgress.effectTag |= 4)) : ("function" === typeof instance.componentDidMount && (workInProgress.effectTag |= 4), workInProgress.memoizedProps = nextProps, workInProgress.memoizedState = oldContext), instance.props = nextProps, instance.state = oldContext, instance.context = contextType, nextProps = oldProps) : ("function" === typeof instance.componentDidMount && (workInProgress.effectTag |= 4), nextProps = !1);
    } else instance = workInProgress.stateNode, oldProps = workInProgress.memoizedProps, instance.props = workInProgress.type === workInProgress.elementType ? oldProps : resolveDefaultProps(workInProgress.type, oldProps), oldContext = instance.context, contextType = Component.contextType, "object" === typeof contextType && null !== contextType ? contextType = readContext(contextType) : (contextType = isContextProvider(Component) ? previousContext : contextStackCursor.current, contextType = getMaskedContext(workInProgress, contextType)), getDerivedStateFromProps = Component.getDerivedStateFromProps, (hasNewLifecycles = "function" === typeof getDerivedStateFromProps || "function" === typeof instance.getSnapshotBeforeUpdate) || "function" !== typeof instance.UNSAFE_componentWillReceiveProps && "function" !== typeof instance.componentWillReceiveProps || (oldProps !== nextProps || oldContext !== contextType) && callComponentWillReceiveProps(workInProgress, instance, nextProps, contextType), hasForceUpdate = !1, oldContext = workInProgress.memoizedState, oldState = instance.state = oldContext, updateQueue = workInProgress.updateQueue, null !== updateQueue && (processUpdateQueue(workInProgress, updateQueue, nextProps, instance, renderExpirationTime), oldState = workInProgress.memoizedState), oldProps !== nextProps || oldContext !== oldState || didPerformWorkStackCursor.current || hasForceUpdate ? ("function" === typeof getDerivedStateFromProps && (applyDerivedStateFromProps(workInProgress, Component, getDerivedStateFromProps, nextProps), oldState = workInProgress.memoizedState), (getDerivedStateFromProps = hasForceUpdate || checkShouldComponentUpdate(workInProgress, Component, oldProps, nextProps, oldContext, oldState, contextType)) ? (hasNewLifecycles || "function" !== typeof instance.UNSAFE_componentWillUpdate && "function" !== typeof instance.componentWillUpdate || ("function" === typeof instance.componentWillUpdate && instance.componentWillUpdate(nextProps, oldState, contextType), "function" === typeof instance.UNSAFE_componentWillUpdate && instance.UNSAFE_componentWillUpdate(nextProps, oldState, contextType)), "function" === typeof instance.componentDidUpdate && (workInProgress.effectTag |= 4), "function" === typeof instance.getSnapshotBeforeUpdate && (workInProgress.effectTag |= 256)) : ("function" !== typeof instance.componentDidUpdate || oldProps === current$$1.memoizedProps && oldContext === current$$1.memoizedState || (workInProgress.effectTag |= 4), "function" !== typeof instance.getSnapshotBeforeUpdate || oldProps === current$$1.memoizedProps && oldContext === current$$1.memoizedState || (workInProgress.effectTag |= 256), workInProgress.memoizedProps = nextProps, workInProgress.memoizedState = oldState), instance.props = nextProps, instance.state = oldState, instance.context = contextType, nextProps = getDerivedStateFromProps) : ("function" !== typeof instance.componentDidUpdate || oldProps === current$$1.memoizedProps && oldContext === current$$1.memoizedState || (workInProgress.effectTag |= 4), "function" !== typeof instance.getSnapshotBeforeUpdate || oldProps === current$$1.memoizedProps && oldContext === current$$1.memoizedState || (workInProgress.effectTag |= 256), nextProps = !1);
    return finishClassComponent(current$$1, workInProgress, Component, nextProps, hasContext, renderExpirationTime);
  }

  function finishClassComponent(current$$1, workInProgress, Component, shouldUpdate, hasContext, renderExpirationTime) {
    markRef(current$$1, workInProgress);
    var didCaptureError = 0 !== (workInProgress.effectTag & 64);
    if (!shouldUpdate && !didCaptureError) return hasContext && invalidateContextProvider(workInProgress, Component, !1), bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
    shouldUpdate = workInProgress.stateNode;
    ReactCurrentOwner$3.current = workInProgress;
    var nextChildren = didCaptureError && "function" !== typeof Component.getDerivedStateFromError ? null : shouldUpdate.render();
    workInProgress.effectTag |= 1;
    null !== current$$1 && didCaptureError ? (workInProgress.child = reconcileChildFibers(workInProgress, current$$1.child, null, renderExpirationTime), workInProgress.child = reconcileChildFibers(workInProgress, null, nextChildren, renderExpirationTime)) : reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime);
    workInProgress.memoizedState = shouldUpdate.state;
    hasContext && invalidateContextProvider(workInProgress, Component, !0);
    return workInProgress.child;
  }

  function pushHostRootContext(workInProgress) {
    var root = workInProgress.stateNode;
    root.pendingContext ? pushTopLevelContextObject(workInProgress, root.pendingContext, root.pendingContext !== root.context) : root.context && pushTopLevelContextObject(workInProgress, root.context, !1);
    pushHostContainer(workInProgress, root.containerInfo);
  }

  var SUSPENDED_MARKER = {};

  function updateSuspenseComponent(current$$1, workInProgress, renderExpirationTime) {
    var mode = workInProgress.mode,
        nextProps = workInProgress.pendingProps,
        suspenseContext = suspenseStackCursor.current,
        nextState = null,
        nextDidTimeout = !1,
        JSCompiler_temp;
    (JSCompiler_temp = 0 !== (workInProgress.effectTag & 64)) || (JSCompiler_temp = 0 !== (suspenseContext & ForceSuspenseFallback) && (null === current$$1 || null !== current$$1.memoizedState));
    JSCompiler_temp ? (nextState = SUSPENDED_MARKER, nextDidTimeout = !0, workInProgress.effectTag &= -65) : null !== current$$1 && null === current$$1.memoizedState || void 0 === nextProps.fallback || !0 === nextProps.unstable_avoidThisFallback || (suspenseContext |= InvisibleParentSuspenseContext);
    suspenseContext &= SubtreeSuspenseContextMask;
    push(suspenseStackCursor, suspenseContext, workInProgress);
    if (null === current$$1) {
      if (nextDidTimeout) {
        nextProps = nextProps.fallback;
        current$$1 = createFiberFromFragment(null, mode, 0, null);
        current$$1.return = workInProgress;
        if (0 === (workInProgress.mode & 2)) for (nextDidTimeout = null !== workInProgress.memoizedState ? workInProgress.child.child : workInProgress.child, current$$1.child = nextDidTimeout; null !== nextDidTimeout;) {
          nextDidTimeout.return = current$$1, nextDidTimeout = nextDidTimeout.sibling;
        }
        renderExpirationTime = createFiberFromFragment(nextProps, mode, renderExpirationTime, null);
        renderExpirationTime.return = workInProgress;
        current$$1.sibling = renderExpirationTime;
        mode = current$$1;
      } else mode = renderExpirationTime = mountChildFibers(workInProgress, null, nextProps.children, renderExpirationTime);
    } else {
      if (null !== current$$1.memoizedState) {
        if (suspenseContext = current$$1.child, mode = suspenseContext.sibling, nextDidTimeout) {
          nextProps = nextProps.fallback;
          renderExpirationTime = createWorkInProgress(suspenseContext, suspenseContext.pendingProps, 0);
          renderExpirationTime.return = workInProgress;
          if (0 === (workInProgress.mode & 2) && (nextDidTimeout = null !== workInProgress.memoizedState ? workInProgress.child.child : workInProgress.child, nextDidTimeout !== suspenseContext.child)) for (renderExpirationTime.child = nextDidTimeout; null !== nextDidTimeout;) {
            nextDidTimeout.return = renderExpirationTime, nextDidTimeout = nextDidTimeout.sibling;
          }
          nextProps = createWorkInProgress(mode, nextProps, mode.expirationTime);
          nextProps.return = workInProgress;
          renderExpirationTime.sibling = nextProps;
          mode = renderExpirationTime;
          renderExpirationTime.childExpirationTime = 0;
          renderExpirationTime = nextProps;
        } else mode = renderExpirationTime = reconcileChildFibers(workInProgress, suspenseContext.child, nextProps.children, renderExpirationTime);
      } else if (suspenseContext = current$$1.child, nextDidTimeout) {
        nextDidTimeout = nextProps.fallback;
        nextProps = createFiberFromFragment(null, mode, 0, null);
        nextProps.return = workInProgress;
        nextProps.child = suspenseContext;
        null !== suspenseContext && (suspenseContext.return = nextProps);
        if (0 === (workInProgress.mode & 2)) for (suspenseContext = null !== workInProgress.memoizedState ? workInProgress.child.child : workInProgress.child, nextProps.child = suspenseContext; null !== suspenseContext;) {
          suspenseContext.return = nextProps, suspenseContext = suspenseContext.sibling;
        }
        renderExpirationTime = createFiberFromFragment(nextDidTimeout, mode, renderExpirationTime, null);
        renderExpirationTime.return = workInProgress;
        nextProps.sibling = renderExpirationTime;
        renderExpirationTime.effectTag |= 2;
        mode = nextProps;
        nextProps.childExpirationTime = 0;
      } else renderExpirationTime = mode = reconcileChildFibers(workInProgress, suspenseContext, nextProps.children, renderExpirationTime);
      workInProgress.stateNode = current$$1.stateNode;
    }
    workInProgress.memoizedState = nextState;
    workInProgress.child = mode;
    return renderExpirationTime;
  }

  function initSuspenseListRenderState(workInProgress, isBackwards, tail, lastContentRow, tailMode) {
    var renderState = workInProgress.memoizedState;
    null === renderState ? workInProgress.memoizedState = {
      isBackwards: isBackwards,
      rendering: null,
      last: lastContentRow,
      tail: tail,
      tailExpiration: 0,
      tailMode: tailMode
    } : (renderState.isBackwards = isBackwards, renderState.rendering = null, renderState.last = lastContentRow, renderState.tail = tail, renderState.tailExpiration = 0, renderState.tailMode = tailMode);
  }

  function updateSuspenseListComponent(current$$1, workInProgress, renderExpirationTime) {
    var nextProps = workInProgress.pendingProps,
        revealOrder = nextProps.revealOrder,
        tailMode = nextProps.tail;
    reconcileChildren(current$$1, workInProgress, nextProps.children, renderExpirationTime);
    nextProps = suspenseStackCursor.current;
    if (0 !== (nextProps & ForceSuspenseFallback)) nextProps = nextProps & SubtreeSuspenseContextMask | ForceSuspenseFallback, workInProgress.effectTag |= 64;else {
      if (null !== current$$1 && 0 !== (current$$1.effectTag & 64)) a: for (current$$1 = workInProgress.child; null !== current$$1;) {
        if (13 === current$$1.tag) {
          if (null !== current$$1.memoizedState) {
            current$$1.expirationTime < renderExpirationTime && (current$$1.expirationTime = renderExpirationTime);
            var alternate = current$$1.alternate;
            null !== alternate && alternate.expirationTime < renderExpirationTime && (alternate.expirationTime = renderExpirationTime);
            scheduleWorkOnParentPath(current$$1.return, renderExpirationTime);
          }
        } else if (null !== current$$1.child) {
          current$$1.child.return = current$$1;
          current$$1 = current$$1.child;
          continue;
        }

        if (current$$1 === workInProgress) break a;

        for (; null === current$$1.sibling;) {
          if (null === current$$1.return || current$$1.return === workInProgress) break a;
          current$$1 = current$$1.return;
        }

        current$$1.sibling.return = current$$1.return;
        current$$1 = current$$1.sibling;
      }
      nextProps &= SubtreeSuspenseContextMask;
    }
    push(suspenseStackCursor, nextProps, workInProgress);
    if (0 === (workInProgress.mode & 2)) workInProgress.memoizedState = null;else switch (revealOrder) {
      case "forwards":
        renderExpirationTime = workInProgress.child;

        for (revealOrder = null; null !== renderExpirationTime;) {
          nextProps = renderExpirationTime.alternate, null !== nextProps && null === findFirstSuspended(nextProps) && (revealOrder = renderExpirationTime), renderExpirationTime = renderExpirationTime.sibling;
        }

        renderExpirationTime = revealOrder;
        null === renderExpirationTime ? (revealOrder = workInProgress.child, workInProgress.child = null) : (revealOrder = renderExpirationTime.sibling, renderExpirationTime.sibling = null);
        initSuspenseListRenderState(workInProgress, !1, revealOrder, renderExpirationTime, tailMode);
        break;

      case "backwards":
        renderExpirationTime = null;
        revealOrder = workInProgress.child;

        for (workInProgress.child = null; null !== revealOrder;) {
          nextProps = revealOrder.alternate;

          if (null !== nextProps && null === findFirstSuspended(nextProps)) {
            workInProgress.child = revealOrder;
            break;
          }

          nextProps = revealOrder.sibling;
          revealOrder.sibling = renderExpirationTime;
          renderExpirationTime = revealOrder;
          revealOrder = nextProps;
        }

        initSuspenseListRenderState(workInProgress, !0, renderExpirationTime, null, tailMode);
        break;

      case "together":
        initSuspenseListRenderState(workInProgress, !1, null, null, void 0);
        break;

      default:
        workInProgress.memoizedState = null;
    }
    return workInProgress.child;
  }

  function bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime) {
    null !== current$$1 && (workInProgress.dependencies = current$$1.dependencies);
    if (workInProgress.childExpirationTime < renderExpirationTime) return null;
    if (null !== current$$1 && workInProgress.child !== current$$1.child) throw ReactError(Error("Resuming work not yet implemented."));

    if (null !== workInProgress.child) {
      current$$1 = workInProgress.child;
      renderExpirationTime = createWorkInProgress(current$$1, current$$1.pendingProps, current$$1.expirationTime);
      workInProgress.child = renderExpirationTime;

      for (renderExpirationTime.return = workInProgress; null !== current$$1.sibling;) {
        current$$1 = current$$1.sibling, renderExpirationTime = renderExpirationTime.sibling = createWorkInProgress(current$$1, current$$1.pendingProps, current$$1.expirationTime), renderExpirationTime.return = workInProgress;
      }

      renderExpirationTime.sibling = null;
    }

    return workInProgress.child;
  }

  var appendAllChildren = void 0,
      updateHostContainer = void 0,
      updateHostComponent$1 = void 0,
      updateHostText$1 = void 0;

  appendAllChildren = function appendAllChildren(parent, workInProgress) {
    for (var node = workInProgress.child; null !== node;) {
      if (5 === node.tag || 6 === node.tag) parent._children.push(node.stateNode);else if (4 !== node.tag && null !== node.child) {
        node.child.return = node;
        node = node.child;
        continue;
      }
      if (node === workInProgress) break;

      for (; null === node.sibling;) {
        if (null === node.return || node.return === workInProgress) return;
        node = node.return;
      }

      node.sibling.return = node.return;
      node = node.sibling;
    }
  };

  updateHostContainer = function updateHostContainer() {};

  updateHostComponent$1 = function updateHostComponent$1(current, workInProgress, type, newProps) {
    current.memoizedProps !== newProps && (requiredContext(contextStackCursor$1.current), workInProgress.updateQueue = UPDATE_SIGNAL) && (workInProgress.effectTag |= 4);
  };

  updateHostText$1 = function updateHostText$1(current, workInProgress, oldText, newText) {
    oldText !== newText && (workInProgress.effectTag |= 4);
  };

  function cutOffTailIfNeeded(renderState, hasRenderedATailFallback) {
    switch (renderState.tailMode) {
      case "hidden":
        hasRenderedATailFallback = renderState.tail;

        for (var lastTailNode = null; null !== hasRenderedATailFallback;) {
          null !== hasRenderedATailFallback.alternate && (lastTailNode = hasRenderedATailFallback), hasRenderedATailFallback = hasRenderedATailFallback.sibling;
        }

        null === lastTailNode ? renderState.tail = null : lastTailNode.sibling = null;
        break;

      case "collapsed":
        lastTailNode = renderState.tail;

        for (var _lastTailNode = null; null !== lastTailNode;) {
          null !== lastTailNode.alternate && (_lastTailNode = lastTailNode), lastTailNode = lastTailNode.sibling;
        }

        null === _lastTailNode ? hasRenderedATailFallback || null === renderState.tail ? renderState.tail = null : renderState.tail.sibling = null : _lastTailNode.sibling = null;
    }
  }

  function unwindWork(workInProgress) {
    switch (workInProgress.tag) {
      case 1:
        isContextProvider(workInProgress.type) && popContext(workInProgress);
        var effectTag = workInProgress.effectTag;
        return effectTag & 2048 ? (workInProgress.effectTag = effectTag & -2049 | 64, workInProgress) : null;

      case 3:
        popHostContainer(workInProgress);
        popTopLevelContextObject(workInProgress);
        effectTag = workInProgress.effectTag;
        if (0 !== (effectTag & 64)) throw ReactError(Error("The root failed to unmount after an error. This is likely a bug in React. Please file an issue."));
        workInProgress.effectTag = effectTag & -2049 | 64;
        return workInProgress;

      case 5:
        return popHostContext(workInProgress), null;

      case 13:
        return pop(suspenseStackCursor, workInProgress), effectTag = workInProgress.effectTag, effectTag & 2048 ? (workInProgress.effectTag = effectTag & -2049 | 64, workInProgress) : null;

      case 18:
        return null;

      case 19:
        return pop(suspenseStackCursor, workInProgress), null;

      case 4:
        return popHostContainer(workInProgress), null;

      case 10:
        return popProvider(workInProgress), null;

      default:
        return null;
    }
  }

  function createCapturedValue(value, source) {
    return {
      value: value,
      source: source,
      stack: getStackByFiberInDevAndProd(source)
    };
  }

  if ("function" !== typeof ReactNativePrivateInterface.ReactFiberErrorDialog.showErrorDialog) throw ReactError(Error("Expected ReactFiberErrorDialog.showErrorDialog to be a function."));

  function logCapturedError(capturedError) {
    !1 !== ReactNativePrivateInterface.ReactFiberErrorDialog.showErrorDialog(capturedError) && console.error(capturedError.error);
  }

  var PossiblyWeakSet$1 = "function" === typeof WeakSet ? WeakSet : Set;

  function logError(boundary, errorInfo) {
    var source = errorInfo.source,
        stack = errorInfo.stack;
    null === stack && null !== source && (stack = getStackByFiberInDevAndProd(source));
    errorInfo = {
      componentName: null !== source ? getComponentName(source.type) : null,
      componentStack: null !== stack ? stack : "",
      error: errorInfo.value,
      errorBoundary: null,
      errorBoundaryName: null,
      errorBoundaryFound: !1,
      willRetry: !1
    };
    null !== boundary && 1 === boundary.tag && (errorInfo.errorBoundary = boundary.stateNode, errorInfo.errorBoundaryName = getComponentName(boundary.type), errorInfo.errorBoundaryFound = !0, errorInfo.willRetry = !0);

    try {
      logCapturedError(errorInfo);
    } catch (e) {
      setTimeout(function () {
        throw e;
      });
    }
  }

  function safelyCallComponentWillUnmount(current$$1, instance) {
    try {
      instance.props = current$$1.memoizedProps, instance.state = current$$1.memoizedState, instance.componentWillUnmount();
    } catch (unmountError) {
      captureCommitPhaseError(current$$1, unmountError);
    }
  }

  function safelyDetachRef(current$$1) {
    var ref = current$$1.ref;
    if (null !== ref) if ("function" === typeof ref) try {
      ref(null);
    } catch (refError) {
      captureCommitPhaseError(current$$1, refError);
    } else ref.current = null;
  }

  function commitHookEffectList(unmountTag, mountTag, finishedWork) {
    finishedWork = finishedWork.updateQueue;
    finishedWork = null !== finishedWork ? finishedWork.lastEffect : null;

    if (null !== finishedWork) {
      var effect = finishedWork = finishedWork.next;

      do {
        if ((effect.tag & unmountTag) !== NoEffect$1) {
          var destroy = effect.destroy;
          effect.destroy = void 0;
          void 0 !== destroy && destroy();
        }

        (effect.tag & mountTag) !== NoEffect$1 && (destroy = effect.create, effect.destroy = destroy());
        effect = effect.next;
      } while (effect !== finishedWork);
    }
  }

  function commitUnmount(current$$1$jscomp$0, renderPriorityLevel) {
    "function" === typeof onCommitFiberUnmount && onCommitFiberUnmount(current$$1$jscomp$0);

    switch (current$$1$jscomp$0.tag) {
      case 0:
      case 11:
      case 14:
      case 15:
        var updateQueue = current$$1$jscomp$0.updateQueue;

        if (null !== updateQueue && (updateQueue = updateQueue.lastEffect, null !== updateQueue)) {
          var firstEffect = updateQueue.next;
          runWithPriority(97 < renderPriorityLevel ? 97 : renderPriorityLevel, function () {
            var effect = firstEffect;

            do {
              var destroy = effect.destroy;

              if (void 0 !== destroy) {
                var current$$1 = current$$1$jscomp$0;

                try {
                  destroy();
                } catch (error) {
                  captureCommitPhaseError(current$$1, error);
                }
              }

              effect = effect.next;
            } while (effect !== firstEffect);
          });
        }

        break;

      case 1:
        safelyDetachRef(current$$1$jscomp$0);
        renderPriorityLevel = current$$1$jscomp$0.stateNode;
        "function" === typeof renderPriorityLevel.componentWillUnmount && safelyCallComponentWillUnmount(current$$1$jscomp$0, renderPriorityLevel);
        break;

      case 5:
        safelyDetachRef(current$$1$jscomp$0);
        break;

      case 4:
        unmountHostComponents(current$$1$jscomp$0, renderPriorityLevel);
    }
  }

  function detachFiber(current$$1) {
    var alternate = current$$1.alternate;
    current$$1.return = null;
    current$$1.child = null;
    current$$1.memoizedState = null;
    current$$1.updateQueue = null;
    current$$1.dependencies = null;
    current$$1.alternate = null;
    current$$1.firstEffect = null;
    current$$1.lastEffect = null;
    current$$1.pendingProps = null;
    current$$1.memoizedProps = null;
    null !== alternate && detachFiber(alternate);
  }

  function isHostParent(fiber) {
    return 5 === fiber.tag || 3 === fiber.tag || 4 === fiber.tag;
  }

  function commitPlacement(finishedWork) {
    a: {
      for (var parent = finishedWork.return; null !== parent;) {
        if (isHostParent(parent)) {
          var parentFiber = parent;
          break a;
        }

        parent = parent.return;
      }

      throw ReactError(Error("Expected to find a host parent. This error is likely caused by a bug in React. Please file an issue."));
    }

    parent = parentFiber.stateNode;

    switch (parentFiber.tag) {
      case 5:
        var isContainer = !1;
        break;

      case 3:
        parent = parent.containerInfo;
        isContainer = !0;
        break;

      case 4:
        parent = parent.containerInfo;
        isContainer = !0;
        break;

      default:
        throw ReactError(Error("Invalid host parent fiber. This error is likely caused by a bug in React. Please file an issue."));
    }

    parentFiber.effectTag & 16 && (parentFiber.effectTag &= -17);

    a: b: for (parentFiber = finishedWork;;) {
      for (; null === parentFiber.sibling;) {
        if (null === parentFiber.return || isHostParent(parentFiber.return)) {
          parentFiber = null;
          break a;
        }

        parentFiber = parentFiber.return;
      }

      parentFiber.sibling.return = parentFiber.return;

      for (parentFiber = parentFiber.sibling; 5 !== parentFiber.tag && 6 !== parentFiber.tag && 18 !== parentFiber.tag;) {
        if (parentFiber.effectTag & 2) continue b;
        if (null === parentFiber.child || 4 === parentFiber.tag) continue b;else parentFiber.child.return = parentFiber, parentFiber = parentFiber.child;
      }

      if (!(parentFiber.effectTag & 2)) {
        parentFiber = parentFiber.stateNode;
        break a;
      }
    }

    for (var node = finishedWork;;) {
      var isHost = 5 === node.tag || 6 === node.tag;

      if (isHost) {
        var stateNode = isHost ? node.stateNode : node.stateNode.instance;
        if (parentFiber) {
          if (isContainer) {
            if ("number" === typeof parent) throw ReactError(Error("Container does not support insertBefore operation"));
          } else {
            isHost = parent;
            var beforeChild = parentFiber,
                children = isHost._children,
                index = children.indexOf(stateNode);
            0 <= index ? (children.splice(index, 1), beforeChild = children.indexOf(beforeChild), children.splice(beforeChild, 0, stateNode), ReactNativePrivateInterface.UIManager.manageChildren(isHost._nativeTag, [index], [beforeChild], [], [], [])) : (index = children.indexOf(beforeChild), children.splice(index, 0, stateNode), ReactNativePrivateInterface.UIManager.manageChildren(isHost._nativeTag, [], [], ["number" === typeof stateNode ? stateNode : stateNode._nativeTag], [index], []));
          }
        } else isContainer ? ReactNativePrivateInterface.UIManager.setChildren(parent, ["number" === typeof stateNode ? stateNode : stateNode._nativeTag]) : (isHost = parent, children = "number" === typeof stateNode ? stateNode : stateNode._nativeTag, index = isHost._children, beforeChild = index.indexOf(stateNode), 0 <= beforeChild ? (index.splice(beforeChild, 1), index.push(stateNode), ReactNativePrivateInterface.UIManager.manageChildren(isHost._nativeTag, [beforeChild], [index.length - 1], [], [], [])) : (index.push(stateNode), ReactNativePrivateInterface.UIManager.manageChildren(isHost._nativeTag, [], [], [children], [index.length - 1], [])));
      } else if (4 !== node.tag && null !== node.child) {
        node.child.return = node;
        node = node.child;
        continue;
      }

      if (node === finishedWork) break;

      for (; null === node.sibling;) {
        if (null === node.return || node.return === finishedWork) return;
        node = node.return;
      }

      node.sibling.return = node.return;
      node = node.sibling;
    }
  }

  function unmountHostComponents(current$$1, renderPriorityLevel$jscomp$0) {
    for (var node = current$$1, currentParentIsValid = !1, currentParent = void 0, currentParentIsContainer = void 0;;) {
      if (!currentParentIsValid) {
        currentParentIsValid = node.return;

        a: for (;;) {
          if (null === currentParentIsValid) throw ReactError(Error("Expected to find a host parent. This error is likely caused by a bug in React. Please file an issue."));
          currentParent = currentParentIsValid.stateNode;

          switch (currentParentIsValid.tag) {
            case 5:
              currentParentIsContainer = !1;
              break a;

            case 3:
              currentParent = currentParent.containerInfo;
              currentParentIsContainer = !0;
              break a;

            case 4:
              currentParent = currentParent.containerInfo;
              currentParentIsContainer = !0;
              break a;
          }

          currentParentIsValid = currentParentIsValid.return;
        }

        currentParentIsValid = !0;
      }

      if (5 === node.tag || 6 === node.tag) {
        a: for (var root = node, renderPriorityLevel = renderPriorityLevel$jscomp$0, node$jscomp$0 = root;;) {
          if (commitUnmount(node$jscomp$0, renderPriorityLevel), null !== node$jscomp$0.child && 4 !== node$jscomp$0.tag) node$jscomp$0.child.return = node$jscomp$0, node$jscomp$0 = node$jscomp$0.child;else {
            if (node$jscomp$0 === root) break;

            for (; null === node$jscomp$0.sibling;) {
              if (null === node$jscomp$0.return || node$jscomp$0.return === root) break a;
              node$jscomp$0 = node$jscomp$0.return;
            }

            node$jscomp$0.sibling.return = node$jscomp$0.return;
            node$jscomp$0 = node$jscomp$0.sibling;
          }
        }

        currentParentIsContainer ? (root = currentParent, recursivelyUncacheFiberNode(node.stateNode), ReactNativePrivateInterface.UIManager.manageChildren(root, [], [], [], [], [0])) : (root = currentParent, node$jscomp$0 = node.stateNode, recursivelyUncacheFiberNode(node$jscomp$0), renderPriorityLevel = root._children, node$jscomp$0 = renderPriorityLevel.indexOf(node$jscomp$0), renderPriorityLevel.splice(node$jscomp$0, 1), ReactNativePrivateInterface.UIManager.manageChildren(root._nativeTag, [], [], [], [], [node$jscomp$0]));
      } else if (4 === node.tag) {
        if (null !== node.child) {
          currentParent = node.stateNode.containerInfo;
          currentParentIsContainer = !0;
          node.child.return = node;
          node = node.child;
          continue;
        }
      } else if (commitUnmount(node, renderPriorityLevel$jscomp$0), null !== node.child) {
        node.child.return = node;
        node = node.child;
        continue;
      }

      if (node === current$$1) break;

      for (; null === node.sibling;) {
        if (null === node.return || node.return === current$$1) return;
        node = node.return;
        4 === node.tag && (currentParentIsValid = !1);
      }

      node.sibling.return = node.return;
      node = node.sibling;
    }
  }

  function commitWork(current$$1, finishedWork) {
    switch (finishedWork.tag) {
      case 0:
      case 11:
      case 14:
      case 15:
        commitHookEffectList(UnmountMutation, MountMutation, finishedWork);
        break;

      case 1:
        break;

      case 5:
        var instance = finishedWork.stateNode;

        if (null != instance) {
          var newProps = finishedWork.memoizedProps;
          current$$1 = null !== current$$1 ? current$$1.memoizedProps : newProps;
          var updatePayload = finishedWork.updateQueue;
          finishedWork.updateQueue = null;
          null !== updatePayload && (finishedWork = instance.viewConfig, instanceProps.set(instance._nativeTag, newProps), newProps = diffProperties(null, current$$1, newProps, finishedWork.validAttributes), null != newProps && ReactNativePrivateInterface.UIManager.updateView(instance._nativeTag, finishedWork.uiViewClassName, newProps));
        }

        break;

      case 6:
        if (null === finishedWork.stateNode) throw ReactError(Error("This should have a text node initialized. This error is likely caused by a bug in React. Please file an issue."));
        ReactNativePrivateInterface.UIManager.updateView(finishedWork.stateNode, "RCTRawText", {
          text: finishedWork.memoizedProps
        });
        break;

      case 3:
        break;

      case 12:
        break;

      case 13:
        instance = finishedWork;
        null === finishedWork.memoizedState ? newProps = !1 : (newProps = !0, instance = finishedWork.child, globalMostRecentFallbackTime = now());
        if (null !== instance) a: for (current$$1 = instance;;) {
          if (5 === current$$1.tag) {
            if (updatePayload = current$$1.stateNode, newProps) {
              var viewConfig = updatePayload.viewConfig;
              var updatePayload$jscomp$0 = diffProperties(null, emptyObject, {
                style: {
                  display: "none"
                }
              }, viewConfig.validAttributes);
              ReactNativePrivateInterface.UIManager.updateView(updatePayload._nativeTag, viewConfig.uiViewClassName, updatePayload$jscomp$0);
            } else {
              updatePayload = current$$1.stateNode;
              updatePayload$jscomp$0 = current$$1.memoizedProps;
              viewConfig = updatePayload.viewConfig;

              var prevProps = _extends({}, updatePayload$jscomp$0, {
                style: [updatePayload$jscomp$0.style, {
                  display: "none"
                }]
              });

              updatePayload$jscomp$0 = diffProperties(null, prevProps, updatePayload$jscomp$0, viewConfig.validAttributes);
              ReactNativePrivateInterface.UIManager.updateView(updatePayload._nativeTag, viewConfig.uiViewClassName, updatePayload$jscomp$0);
            }
          } else {
            if (6 === current$$1.tag) throw Error("Not yet implemented.");

            if (13 === current$$1.tag && null !== current$$1.memoizedState) {
              updatePayload = current$$1.child.sibling;
              updatePayload.return = current$$1;
              current$$1 = updatePayload;
              continue;
            } else if (null !== current$$1.child) {
              current$$1.child.return = current$$1;
              current$$1 = current$$1.child;
              continue;
            }
          }
          if (current$$1 === instance) break a;

          for (; null === current$$1.sibling;) {
            if (null === current$$1.return || current$$1.return === instance) break a;
            current$$1 = current$$1.return;
          }

          current$$1.sibling.return = current$$1.return;
          current$$1 = current$$1.sibling;
        }
        attachSuspenseRetryListeners(finishedWork);
        break;

      case 19:
        attachSuspenseRetryListeners(finishedWork);
        break;

      case 17:
        break;

      case 20:
        break;

      default:
        throw ReactError(Error("This unit of work tag should not have side-effects. This error is likely caused by a bug in React. Please file an issue."));
    }
  }

  function attachSuspenseRetryListeners(finishedWork) {
    var thenables = finishedWork.updateQueue;

    if (null !== thenables) {
      finishedWork.updateQueue = null;
      var retryCache = finishedWork.stateNode;
      null === retryCache && (retryCache = finishedWork.stateNode = new PossiblyWeakSet$1());
      thenables.forEach(function (thenable) {
        var retry = resolveRetryThenable.bind(null, finishedWork, thenable);
        retryCache.has(thenable) || (retryCache.add(thenable), thenable.then(retry, retry));
      });
    }
  }

  var PossiblyWeakMap = "function" === typeof WeakMap ? WeakMap : Map;

  function createRootErrorUpdate(fiber, errorInfo, expirationTime) {
    expirationTime = createUpdate(expirationTime, null);
    expirationTime.tag = 3;
    expirationTime.payload = {
      element: null
    };
    var error = errorInfo.value;

    expirationTime.callback = function () {
      hasUncaughtError || (hasUncaughtError = !0, firstUncaughtError = error);
      logError(fiber, errorInfo);
    };

    return expirationTime;
  }

  function createClassErrorUpdate(fiber, errorInfo, expirationTime) {
    expirationTime = createUpdate(expirationTime, null);
    expirationTime.tag = 3;
    var getDerivedStateFromError = fiber.type.getDerivedStateFromError;

    if ("function" === typeof getDerivedStateFromError) {
      var error = errorInfo.value;

      expirationTime.payload = function () {
        logError(fiber, errorInfo);
        return getDerivedStateFromError(error);
      };
    }

    var inst = fiber.stateNode;
    null !== inst && "function" === typeof inst.componentDidCatch && (expirationTime.callback = function () {
      "function" !== typeof getDerivedStateFromError && (null === legacyErrorBoundariesThatAlreadyFailed ? legacyErrorBoundariesThatAlreadyFailed = new Set([this]) : legacyErrorBoundariesThatAlreadyFailed.add(this), logError(fiber, errorInfo));
      var stack = errorInfo.stack;
      this.componentDidCatch(errorInfo.value, {
        componentStack: null !== stack ? stack : ""
      });
    });
    return expirationTime;
  }

  var ceil = Math.ceil,
      ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher,
      ReactCurrentOwner$2 = ReactSharedInternals.ReactCurrentOwner,
      NoContext = 0,
      LegacyUnbatchedContext = 8,
      RenderContext = 16,
      CommitContext = 32,
      RootIncomplete = 0,
      RootErrored = 1,
      RootSuspended = 2,
      RootSuspendedWithDelay = 3,
      RootCompleted = 4,
      executionContext = NoContext,
      workInProgressRoot = null,
      workInProgress = null,
      renderExpirationTime = 0,
      workInProgressRootExitStatus = RootIncomplete,
      workInProgressRootLatestProcessedExpirationTime = 1073741823,
      workInProgressRootLatestSuspenseTimeout = 1073741823,
      workInProgressRootCanSuspendUsingConfig = null,
      workInProgressRootHasPendingPing = !1,
      globalMostRecentFallbackTime = 0,
      FALLBACK_THROTTLE_MS = 500,
      nextEffect = null,
      hasUncaughtError = !1,
      firstUncaughtError = null,
      legacyErrorBoundariesThatAlreadyFailed = null,
      rootDoesHavePassiveEffects = !1,
      rootWithPendingPassiveEffects = null,
      pendingPassiveEffectsRenderPriority = 90,
      pendingPassiveEffectsExpirationTime = 0,
      rootsWithPendingDiscreteUpdates = null,
      nestedUpdateCount = 0,
      rootWithNestedUpdates = null,
      currentEventTime = 0;

  function requestCurrentTime() {
    return (executionContext & (RenderContext | CommitContext)) !== NoContext ? 1073741821 - (now() / 10 | 0) : 0 !== currentEventTime ? currentEventTime : currentEventTime = 1073741821 - (now() / 10 | 0);
  }

  function computeExpirationForFiber(currentTime, fiber, suspenseConfig) {
    fiber = fiber.mode;
    if (0 === (fiber & 2)) return 1073741823;
    var priorityLevel = getCurrentPriorityLevel();
    if (0 === (fiber & 4)) return 99 === priorityLevel ? 1073741823 : 1073741822;
    if ((executionContext & RenderContext) !== NoContext) return renderExpirationTime;
    if (null !== suspenseConfig) currentTime = 1073741821 - 25 * (((1073741821 - currentTime + (suspenseConfig.timeoutMs | 0 || 5e3) / 10) / 25 | 0) + 1);else switch (priorityLevel) {
      case 99:
        currentTime = 1073741823;
        break;

      case 98:
        currentTime = 1073741821 - 10 * (((1073741821 - currentTime + 15) / 10 | 0) + 1);
        break;

      case 97:
      case 96:
        currentTime = 1073741821 - 25 * (((1073741821 - currentTime + 500) / 25 | 0) + 1);
        break;

      case 95:
        currentTime = 1;
        break;

      default:
        throw ReactError(Error("Expected a valid priority level"));
    }
    null !== workInProgressRoot && currentTime === renderExpirationTime && --currentTime;
    return currentTime;
  }

  function scheduleUpdateOnFiber(fiber, expirationTime) {
    if (50 < nestedUpdateCount) throw nestedUpdateCount = 0, rootWithNestedUpdates = null, ReactError(Error("Maximum update depth exceeded. This can happen when a component repeatedly calls setState inside componentWillUpdate or componentDidUpdate. React limits the number of nested updates to prevent infinite loops."));
    fiber = markUpdateTimeFromFiberToRoot(fiber, expirationTime);

    if (null !== fiber) {
      fiber.pingTime = 0;
      var priorityLevel = getCurrentPriorityLevel();
      if (1073741823 === expirationTime) {
        if ((executionContext & LegacyUnbatchedContext) !== NoContext && (executionContext & (RenderContext | CommitContext)) === NoContext) for (var callback = renderRoot(fiber, 1073741823, !0); null !== callback;) {
          callback = callback(!0);
        } else scheduleCallbackForRoot(fiber, 99, 1073741823), executionContext === NoContext && flushSyncCallbackQueue();
      } else scheduleCallbackForRoot(fiber, priorityLevel, expirationTime);
      (executionContext & 4) === NoContext || 98 !== priorityLevel && 99 !== priorityLevel || (null === rootsWithPendingDiscreteUpdates ? rootsWithPendingDiscreteUpdates = new Map([[fiber, expirationTime]]) : (priorityLevel = rootsWithPendingDiscreteUpdates.get(fiber), (void 0 === priorityLevel || priorityLevel > expirationTime) && rootsWithPendingDiscreteUpdates.set(fiber, expirationTime)));
    }
  }

  function markUpdateTimeFromFiberToRoot(fiber, expirationTime) {
    fiber.expirationTime < expirationTime && (fiber.expirationTime = expirationTime);
    var alternate = fiber.alternate;
    null !== alternate && alternate.expirationTime < expirationTime && (alternate.expirationTime = expirationTime);
    var node = fiber.return,
        root = null;
    if (null === node && 3 === fiber.tag) root = fiber.stateNode;else for (; null !== node;) {
      alternate = node.alternate;
      node.childExpirationTime < expirationTime && (node.childExpirationTime = expirationTime);
      null !== alternate && alternate.childExpirationTime < expirationTime && (alternate.childExpirationTime = expirationTime);

      if (null === node.return && 3 === node.tag) {
        root = node.stateNode;
        break;
      }

      node = node.return;
    }
    null !== root && (expirationTime > root.firstPendingTime && (root.firstPendingTime = expirationTime), fiber = root.lastPendingTime, 0 === fiber || expirationTime < fiber) && (root.lastPendingTime = expirationTime);
    return root;
  }

  function scheduleCallbackForRoot(root, priorityLevel, expirationTime) {
    if (root.callbackExpirationTime < expirationTime) {
      var existingCallbackNode = root.callbackNode;
      null !== existingCallbackNode && existingCallbackNode !== fakeCallbackNode && Scheduler_cancelCallback(existingCallbackNode);
      root.callbackExpirationTime = expirationTime;
      1073741823 === expirationTime ? root.callbackNode = scheduleSyncCallback(runRootCallback.bind(null, root, renderRoot.bind(null, root, expirationTime))) : (existingCallbackNode = null, 1 !== expirationTime && (existingCallbackNode = {
        timeout: 10 * (1073741821 - expirationTime) - now()
      }), root.callbackNode = scheduleCallback(priorityLevel, runRootCallback.bind(null, root, renderRoot.bind(null, root, expirationTime)), existingCallbackNode));
    }
  }

  function runRootCallback(root, callback, isSync) {
    var prevCallbackNode = root.callbackNode,
        continuation = null;

    try {
      return continuation = callback(isSync), null !== continuation ? runRootCallback.bind(null, root, continuation) : null;
    } finally {
      null === continuation && prevCallbackNode === root.callbackNode && (root.callbackNode = null, root.callbackExpirationTime = 0);
    }
  }

  function resolveLocksOnRoot(root, expirationTime) {
    var firstBatch = root.firstBatch;
    return null !== firstBatch && firstBatch._defer && firstBatch._expirationTime >= expirationTime ? (scheduleCallback(97, function () {
      firstBatch._onComplete();

      return null;
    }), !0) : !1;
  }

  function flushPendingDiscreteUpdates() {
    if (null !== rootsWithPendingDiscreteUpdates) {
      var roots = rootsWithPendingDiscreteUpdates;
      rootsWithPendingDiscreteUpdates = null;
      roots.forEach(function (expirationTime, root) {
        scheduleSyncCallback(renderRoot.bind(null, root, expirationTime));
      });
      flushSyncCallbackQueue();
    }
  }

  function prepareFreshStack(root, expirationTime) {
    root.finishedWork = null;
    root.finishedExpirationTime = 0;
    var timeoutHandle = root.timeoutHandle;
    -1 !== timeoutHandle && (root.timeoutHandle = -1, cancelTimeout(timeoutHandle));
    if (null !== workInProgress) for (timeoutHandle = workInProgress.return; null !== timeoutHandle;) {
      var interruptedWork = timeoutHandle;

      switch (interruptedWork.tag) {
        case 1:
          var childContextTypes = interruptedWork.type.childContextTypes;
          null !== childContextTypes && void 0 !== childContextTypes && popContext(interruptedWork);
          break;

        case 3:
          popHostContainer(interruptedWork);
          popTopLevelContextObject(interruptedWork);
          break;

        case 5:
          popHostContext(interruptedWork);
          break;

        case 4:
          popHostContainer(interruptedWork);
          break;

        case 13:
          pop(suspenseStackCursor, interruptedWork);
          break;

        case 19:
          pop(suspenseStackCursor, interruptedWork);
          break;

        case 10:
          popProvider(interruptedWork);
      }

      timeoutHandle = timeoutHandle.return;
    }
    workInProgressRoot = root;
    workInProgress = createWorkInProgress(root.current, null, expirationTime);
    renderExpirationTime = expirationTime;
    workInProgressRootExitStatus = RootIncomplete;
    workInProgressRootLatestSuspenseTimeout = workInProgressRootLatestProcessedExpirationTime = 1073741823;
    workInProgressRootCanSuspendUsingConfig = null;
    workInProgressRootHasPendingPing = !1;
  }

  function renderRoot(root$jscomp$0, expirationTime, isSync) {
    if ((executionContext & (RenderContext | CommitContext)) !== NoContext) throw ReactError(Error("Should not already be working."));
    if (root$jscomp$0.firstPendingTime < expirationTime) return null;
    if (isSync && root$jscomp$0.finishedExpirationTime === expirationTime) return commitRoot.bind(null, root$jscomp$0);
    flushPassiveEffects();
    if (root$jscomp$0 !== workInProgressRoot || expirationTime !== renderExpirationTime) prepareFreshStack(root$jscomp$0, expirationTime);else if (workInProgressRootExitStatus === RootSuspendedWithDelay) if (workInProgressRootHasPendingPing) prepareFreshStack(root$jscomp$0, expirationTime);else {
      var lastPendingTime = root$jscomp$0.lastPendingTime;
      if (lastPendingTime < expirationTime) return renderRoot.bind(null, root$jscomp$0, lastPendingTime);
    }

    if (null !== workInProgress) {
      lastPendingTime = executionContext;
      executionContext |= RenderContext;
      var prevDispatcher = ReactCurrentDispatcher.current;
      null === prevDispatcher && (prevDispatcher = ContextOnlyDispatcher);
      ReactCurrentDispatcher.current = ContextOnlyDispatcher;

      if (isSync) {
        if (1073741823 !== expirationTime) {
          var currentTime = requestCurrentTime();
          if (currentTime < expirationTime) return executionContext = lastPendingTime, resetContextDependencies(), ReactCurrentDispatcher.current = prevDispatcher, renderRoot.bind(null, root$jscomp$0, currentTime);
        }
      } else currentEventTime = 0;

      do {
        try {
          if (isSync) for (; null !== workInProgress;) {
            workInProgress = performUnitOfWork(workInProgress);
          } else for (; null !== workInProgress && !Scheduler_shouldYield();) {
            workInProgress = performUnitOfWork(workInProgress);
          }
          break;
        } catch (thrownValue) {
          resetContextDependencies();
          resetHooks();
          currentTime = workInProgress;
          if (null === currentTime || null === currentTime.return) throw prepareFreshStack(root$jscomp$0, expirationTime), executionContext = lastPendingTime, thrownValue;

          a: {
            var root = root$jscomp$0,
                returnFiber = currentTime.return,
                sourceFiber = currentTime,
                value = thrownValue,
                renderExpirationTime$jscomp$0 = renderExpirationTime;
            sourceFiber.effectTag |= 1024;
            sourceFiber.firstEffect = sourceFiber.lastEffect = null;

            if (null !== value && "object" === typeof value && "function" === typeof value.then) {
              var thenable = value,
                  hasInvisibleParentBoundary = 0 !== (suspenseStackCursor.current & InvisibleParentSuspenseContext);
              value = returnFiber;

              do {
                var JSCompiler_temp;
                if (JSCompiler_temp = 13 === value.tag) null !== value.memoizedState ? JSCompiler_temp = !1 : (JSCompiler_temp = value.memoizedProps, JSCompiler_temp = void 0 === JSCompiler_temp.fallback ? !1 : !0 !== JSCompiler_temp.unstable_avoidThisFallback ? !0 : hasInvisibleParentBoundary ? !1 : !0);

                if (JSCompiler_temp) {
                  returnFiber = value.updateQueue;
                  null === returnFiber ? (returnFiber = new Set(), returnFiber.add(thenable), value.updateQueue = returnFiber) : returnFiber.add(thenable);

                  if (0 === (value.mode & 2)) {
                    value.effectTag |= 64;
                    sourceFiber.effectTag &= -1957;
                    1 === sourceFiber.tag && (null === sourceFiber.alternate ? sourceFiber.tag = 17 : (renderExpirationTime$jscomp$0 = createUpdate(1073741823, null), renderExpirationTime$jscomp$0.tag = 2, enqueueUpdate(sourceFiber, renderExpirationTime$jscomp$0)));
                    sourceFiber.expirationTime = 1073741823;
                    break a;
                  }

                  sourceFiber = root;
                  root = renderExpirationTime$jscomp$0;
                  hasInvisibleParentBoundary = sourceFiber.pingCache;
                  null === hasInvisibleParentBoundary ? (hasInvisibleParentBoundary = sourceFiber.pingCache = new PossiblyWeakMap(), returnFiber = new Set(), hasInvisibleParentBoundary.set(thenable, returnFiber)) : (returnFiber = hasInvisibleParentBoundary.get(thenable), void 0 === returnFiber && (returnFiber = new Set(), hasInvisibleParentBoundary.set(thenable, returnFiber)));
                  returnFiber.has(root) || (returnFiber.add(root), sourceFiber = pingSuspendedRoot.bind(null, sourceFiber, thenable, root), thenable.then(sourceFiber, sourceFiber));
                  value.effectTag |= 2048;
                  value.expirationTime = renderExpirationTime$jscomp$0;
                  break a;
                }

                value = value.return;
              } while (null !== value);

              value = Error((getComponentName(sourceFiber.type) || "A React component") + " suspended while rendering, but no fallback UI was specified.\n\nAdd a <Suspense fallback=...> component higher in the tree to provide a loading indicator or placeholder to display." + getStackByFiberInDevAndProd(sourceFiber));
            }

            workInProgressRootExitStatus !== RootCompleted && (workInProgressRootExitStatus = RootErrored);
            value = createCapturedValue(value, sourceFiber);
            sourceFiber = returnFiber;

            do {
              switch (sourceFiber.tag) {
                case 3:
                  sourceFiber.effectTag |= 2048;
                  sourceFiber.expirationTime = renderExpirationTime$jscomp$0;
                  renderExpirationTime$jscomp$0 = createRootErrorUpdate(sourceFiber, value, renderExpirationTime$jscomp$0);
                  enqueueCapturedUpdate(sourceFiber, renderExpirationTime$jscomp$0);
                  break a;

                case 1:
                  if (thenable = value, root = sourceFiber.type, returnFiber = sourceFiber.stateNode, 0 === (sourceFiber.effectTag & 64) && ("function" === typeof root.getDerivedStateFromError || null !== returnFiber && "function" === typeof returnFiber.componentDidCatch && (null === legacyErrorBoundariesThatAlreadyFailed || !legacyErrorBoundariesThatAlreadyFailed.has(returnFiber)))) {
                    sourceFiber.effectTag |= 2048;
                    sourceFiber.expirationTime = renderExpirationTime$jscomp$0;
                    renderExpirationTime$jscomp$0 = createClassErrorUpdate(sourceFiber, thenable, renderExpirationTime$jscomp$0);
                    enqueueCapturedUpdate(sourceFiber, renderExpirationTime$jscomp$0);
                    break a;
                  }

              }

              sourceFiber = sourceFiber.return;
            } while (null !== sourceFiber);
          }

          workInProgress = completeUnitOfWork(currentTime);
        }
      } while (1);

      executionContext = lastPendingTime;
      resetContextDependencies();
      ReactCurrentDispatcher.current = prevDispatcher;
      if (null !== workInProgress) return renderRoot.bind(null, root$jscomp$0, expirationTime);
    }

    root$jscomp$0.finishedWork = root$jscomp$0.current.alternate;
    root$jscomp$0.finishedExpirationTime = expirationTime;
    if (resolveLocksOnRoot(root$jscomp$0, expirationTime)) return null;
    workInProgressRoot = null;

    switch (workInProgressRootExitStatus) {
      case RootIncomplete:
        throw ReactError(Error("Should have a work-in-progress."));

      case RootErrored:
        return lastPendingTime = root$jscomp$0.lastPendingTime, lastPendingTime < expirationTime ? renderRoot.bind(null, root$jscomp$0, lastPendingTime) : isSync ? commitRoot.bind(null, root$jscomp$0) : (prepareFreshStack(root$jscomp$0, expirationTime), scheduleSyncCallback(renderRoot.bind(null, root$jscomp$0, expirationTime)), null);

      case RootSuspended:
        if (1073741823 === workInProgressRootLatestProcessedExpirationTime && !isSync && (isSync = globalMostRecentFallbackTime + FALLBACK_THROTTLE_MS - now(), 10 < isSync)) {
          if (workInProgressRootHasPendingPing) return prepareFreshStack(root$jscomp$0, expirationTime), renderRoot.bind(null, root$jscomp$0, expirationTime);
          lastPendingTime = root$jscomp$0.lastPendingTime;
          if (lastPendingTime < expirationTime) return renderRoot.bind(null, root$jscomp$0, lastPendingTime);
          root$jscomp$0.timeoutHandle = scheduleTimeout(commitRoot.bind(null, root$jscomp$0), isSync);
          return null;
        }

        return commitRoot.bind(null, root$jscomp$0);

      case RootSuspendedWithDelay:
        if (!isSync) {
          if (workInProgressRootHasPendingPing) return prepareFreshStack(root$jscomp$0, expirationTime), renderRoot.bind(null, root$jscomp$0, expirationTime);
          isSync = root$jscomp$0.lastPendingTime;
          if (isSync < expirationTime) return renderRoot.bind(null, root$jscomp$0, isSync);
          1073741823 !== workInProgressRootLatestSuspenseTimeout ? isSync = 10 * (1073741821 - workInProgressRootLatestSuspenseTimeout) - now() : 1073741823 === workInProgressRootLatestProcessedExpirationTime ? isSync = 0 : (isSync = 10 * (1073741821 - workInProgressRootLatestProcessedExpirationTime) - 5e3, lastPendingTime = now(), expirationTime = 10 * (1073741821 - expirationTime) - lastPendingTime, isSync = lastPendingTime - isSync, 0 > isSync && (isSync = 0), isSync = (120 > isSync ? 120 : 480 > isSync ? 480 : 1080 > isSync ? 1080 : 1920 > isSync ? 1920 : 3e3 > isSync ? 3e3 : 4320 > isSync ? 4320 : 1960 * ceil(isSync / 1960)) - isSync, expirationTime < isSync && (isSync = expirationTime));
          if (10 < isSync) return root$jscomp$0.timeoutHandle = scheduleTimeout(commitRoot.bind(null, root$jscomp$0), isSync), null;
        }

        return commitRoot.bind(null, root$jscomp$0);

      case RootCompleted:
        return !isSync && 1073741823 !== workInProgressRootLatestProcessedExpirationTime && null !== workInProgressRootCanSuspendUsingConfig && (lastPendingTime = workInProgressRootLatestProcessedExpirationTime, prevDispatcher = workInProgressRootCanSuspendUsingConfig, expirationTime = prevDispatcher.busyMinDurationMs | 0, 0 >= expirationTime ? expirationTime = 0 : (isSync = prevDispatcher.busyDelayMs | 0, lastPendingTime = now() - (10 * (1073741821 - lastPendingTime) - (prevDispatcher.timeoutMs | 0 || 5e3)), expirationTime = lastPendingTime <= isSync ? 0 : isSync + expirationTime - lastPendingTime), 10 < expirationTime) ? (root$jscomp$0.timeoutHandle = scheduleTimeout(commitRoot.bind(null, root$jscomp$0), expirationTime), null) : commitRoot.bind(null, root$jscomp$0);

      default:
        throw ReactError(Error("Unknown root exit status."));
    }
  }

  function markRenderEventTimeAndConfig(expirationTime, suspenseConfig) {
    expirationTime < workInProgressRootLatestProcessedExpirationTime && 1 < expirationTime && (workInProgressRootLatestProcessedExpirationTime = expirationTime);
    null !== suspenseConfig && expirationTime < workInProgressRootLatestSuspenseTimeout && 1 < expirationTime && (workInProgressRootLatestSuspenseTimeout = expirationTime, workInProgressRootCanSuspendUsingConfig = suspenseConfig);
  }

  function performUnitOfWork(unitOfWork) {
    var next = beginWork$$1(unitOfWork.alternate, unitOfWork, renderExpirationTime);
    unitOfWork.memoizedProps = unitOfWork.pendingProps;
    null === next && (next = completeUnitOfWork(unitOfWork));
    ReactCurrentOwner$2.current = null;
    return next;
  }

  function completeUnitOfWork(unitOfWork) {
    workInProgress = unitOfWork;

    do {
      var current$$1 = workInProgress.alternate;
      unitOfWork = workInProgress.return;

      if (0 === (workInProgress.effectTag & 1024)) {
        a: {
          var current = current$$1;
          current$$1 = workInProgress;
          var renderExpirationTime$jscomp$0 = renderExpirationTime,
              newProps = current$$1.pendingProps;

          switch (current$$1.tag) {
            case 2:
              break;

            case 16:
              break;

            case 15:
            case 0:
              break;

            case 1:
              isContextProvider(current$$1.type) && popContext(current$$1);
              break;

            case 3:
              popHostContainer(current$$1);
              popTopLevelContextObject(current$$1);
              newProps = current$$1.stateNode;
              newProps.pendingContext && (newProps.context = newProps.pendingContext, newProps.pendingContext = null);
              if (null === current || null === current.child) current$$1.effectTag &= -3;
              updateHostContainer(current$$1);
              break;

            case 5:
              popHostContext(current$$1);
              renderExpirationTime$jscomp$0 = requiredContext(rootInstanceStackCursor.current);
              var type = current$$1.type;
              if (null !== current && null != current$$1.stateNode) updateHostComponent$1(current, current$$1, type, newProps, renderExpirationTime$jscomp$0), current.ref !== current$$1.ref && (current$$1.effectTag |= 128);else if (newProps) {
                current = requiredContext(contextStackCursor$1.current);
                var type$jscomp$0 = type;
                var _instance6 = newProps;
                var rootContainerInstance = renderExpirationTime$jscomp$0,
                    internalInstanceHandle = current$$1,
                    tag = allocateTag();
                type$jscomp$0 = getViewConfigForType(type$jscomp$0);
                var updatePayload = diffProperties(null, emptyObject, _instance6, type$jscomp$0.validAttributes);
                ReactNativePrivateInterface.UIManager.createView(tag, type$jscomp$0.uiViewClassName, rootContainerInstance, updatePayload);
                rootContainerInstance = new ReactNativeFiberHostComponent(tag, type$jscomp$0);
                instanceCache.set(tag, internalInstanceHandle);
                instanceProps.set(tag, _instance6);
                _instance6 = rootContainerInstance;
                appendAllChildren(_instance6, current$$1, !1, !1);
                finalizeInitialChildren(_instance6, type, newProps, renderExpirationTime$jscomp$0, current) && (current$$1.effectTag |= 4);
                current$$1.stateNode = _instance6;
                null !== current$$1.ref && (current$$1.effectTag |= 128);
              } else if (null === current$$1.stateNode) throw ReactError(Error("We must have new props for new mounts. This error is likely caused by a bug in React. Please file an issue."));
              break;

            case 6:
              if (current && null != current$$1.stateNode) updateHostText$1(current, current$$1, current.memoizedProps, newProps);else {
                if ("string" !== typeof newProps && null === current$$1.stateNode) throw ReactError(Error("We must have new props for new mounts. This error is likely caused by a bug in React. Please file an issue."));
                type = requiredContext(rootInstanceStackCursor.current);
                renderExpirationTime$jscomp$0 = requiredContext(contextStackCursor$1.current);
                current = current$$1;
                if (!renderExpirationTime$jscomp$0.isInAParentText) throw ReactError(Error("Text strings must be rendered within a <Text> component."));
                renderExpirationTime$jscomp$0 = allocateTag();
                ReactNativePrivateInterface.UIManager.createView(renderExpirationTime$jscomp$0, "RCTRawText", type, {
                  text: newProps
                });
                instanceCache.set(renderExpirationTime$jscomp$0, current$$1);
                current.stateNode = renderExpirationTime$jscomp$0;
              }
              break;

            case 11:
              break;

            case 13:
              pop(suspenseStackCursor, current$$1);
              newProps = current$$1.memoizedState;

              if (0 !== (current$$1.effectTag & 64)) {
                current$$1.expirationTime = renderExpirationTime$jscomp$0;
                break a;
              }

              newProps = null !== newProps;
              renderExpirationTime$jscomp$0 = !1;
              null !== current && (type = current.memoizedState, renderExpirationTime$jscomp$0 = null !== type, newProps || null === type || (type = current.child.sibling, null !== type && (_instance6 = current$$1.firstEffect, null !== _instance6 ? (current$$1.firstEffect = type, type.nextEffect = _instance6) : (current$$1.firstEffect = current$$1.lastEffect = type, type.nextEffect = null), type.effectTag = 8)));
              if (newProps && !renderExpirationTime$jscomp$0 && 0 !== (current$$1.mode & 2)) if (null === current && !0 !== current$$1.memoizedProps.unstable_avoidThisFallback || 0 !== (suspenseStackCursor.current & InvisibleParentSuspenseContext)) workInProgressRootExitStatus === RootIncomplete && (workInProgressRootExitStatus = RootSuspended);else if (workInProgressRootExitStatus === RootIncomplete || workInProgressRootExitStatus === RootSuspended) workInProgressRootExitStatus = RootSuspendedWithDelay;
              if (newProps || renderExpirationTime$jscomp$0) current$$1.effectTag |= 4;
              break;

            case 7:
              break;

            case 8:
              break;

            case 12:
              break;

            case 4:
              popHostContainer(current$$1);
              updateHostContainer(current$$1);
              break;

            case 10:
              popProvider(current$$1);
              break;

            case 9:
              break;

            case 14:
              break;

            case 17:
              isContextProvider(current$$1.type) && popContext(current$$1);
              break;

            case 18:
              break;

            case 19:
              pop(suspenseStackCursor, current$$1);
              newProps = current$$1.memoizedState;
              if (null === newProps) break;
              type = 0 !== (current$$1.effectTag & 64);
              _instance6 = newProps.rendering;
              if (null === _instance6) {
                if (type) cutOffTailIfNeeded(newProps, !1);else {
                  if (workInProgressRootExitStatus !== RootIncomplete || null !== current && 0 !== (current.effectTag & 64)) for (current = current$$1.child; null !== current;) {
                    _instance6 = findFirstSuspended(current);

                    if (null !== _instance6) {
                      current$$1.effectTag |= 64;
                      cutOffTailIfNeeded(newProps, !1);
                      newProps = _instance6.updateQueue;
                      null !== newProps && (current$$1.updateQueue = newProps, current$$1.effectTag |= 4);
                      current$$1.firstEffect = current$$1.lastEffect = null;
                      newProps = renderExpirationTime$jscomp$0;

                      for (current = current$$1.child; null !== current;) {
                        renderExpirationTime$jscomp$0 = current, type = newProps, renderExpirationTime$jscomp$0.effectTag &= 2, renderExpirationTime$jscomp$0.nextEffect = null, renderExpirationTime$jscomp$0.firstEffect = null, renderExpirationTime$jscomp$0.lastEffect = null, _instance6 = renderExpirationTime$jscomp$0.alternate, null === _instance6 ? (renderExpirationTime$jscomp$0.childExpirationTime = 0, renderExpirationTime$jscomp$0.expirationTime = type, renderExpirationTime$jscomp$0.child = null, renderExpirationTime$jscomp$0.memoizedProps = null, renderExpirationTime$jscomp$0.memoizedState = null, renderExpirationTime$jscomp$0.updateQueue = null, renderExpirationTime$jscomp$0.dependencies = null) : (renderExpirationTime$jscomp$0.childExpirationTime = _instance6.childExpirationTime, renderExpirationTime$jscomp$0.expirationTime = _instance6.expirationTime, renderExpirationTime$jscomp$0.child = _instance6.child, renderExpirationTime$jscomp$0.memoizedProps = _instance6.memoizedProps, renderExpirationTime$jscomp$0.memoizedState = _instance6.memoizedState, renderExpirationTime$jscomp$0.updateQueue = _instance6.updateQueue, type = _instance6.dependencies, renderExpirationTime$jscomp$0.dependencies = null === type ? null : {
                          expirationTime: type.expirationTime,
                          firstContext: type.firstContext,
                          responders: type.responders
                        }), current = current.sibling;
                      }

                      push(suspenseStackCursor, suspenseStackCursor.current & SubtreeSuspenseContextMask | ForceSuspenseFallback, current$$1);
                      current$$1 = current$$1.child;
                      break a;
                    }

                    current = current.sibling;
                  }
                }
              } else {
                if (!type) if (current = findFirstSuspended(_instance6), null !== current) {
                  if (current$$1.effectTag |= 64, type = !0, cutOffTailIfNeeded(newProps, !0), null === newProps.tail && "hidden" === newProps.tailMode) {
                    current = current.updateQueue;
                    null !== current && (current$$1.updateQueue = current, current$$1.effectTag |= 4);
                    current$$1 = current$$1.lastEffect = newProps.lastEffect;
                    null !== current$$1 && (current$$1.nextEffect = null);
                    break;
                  }
                } else now() > newProps.tailExpiration && 1 < renderExpirationTime$jscomp$0 && (current$$1.effectTag |= 64, type = !0, cutOffTailIfNeeded(newProps, !1), current$$1.expirationTime = current$$1.childExpirationTime = renderExpirationTime$jscomp$0 - 1);
                newProps.isBackwards ? (_instance6.sibling = current$$1.child, current$$1.child = _instance6) : (current = newProps.last, null !== current ? current.sibling = _instance6 : current$$1.child = _instance6, newProps.last = _instance6);
              }

              if (null !== newProps.tail) {
                0 === newProps.tailExpiration && (newProps.tailExpiration = now() + 500);
                current = newProps.tail;
                newProps.rendering = current;
                newProps.tail = current.sibling;
                newProps.lastEffect = current$$1.lastEffect;
                current.sibling = null;
                newProps = suspenseStackCursor.current;
                newProps = type ? newProps & SubtreeSuspenseContextMask | ForceSuspenseFallback : newProps & SubtreeSuspenseContextMask;
                push(suspenseStackCursor, newProps, current$$1);
                current$$1 = current;
                break a;
              }

              break;

            case 20:
              break;

            default:
              throw ReactError(Error("Unknown unit of work tag. This error is likely caused by a bug in React. Please file an issue."));
          }

          current$$1 = null;
        }

        newProps = workInProgress;

        if (1 === renderExpirationTime || 1 !== newProps.childExpirationTime) {
          current = 0;

          for (renderExpirationTime$jscomp$0 = newProps.child; null !== renderExpirationTime$jscomp$0;) {
            type = renderExpirationTime$jscomp$0.expirationTime, _instance6 = renderExpirationTime$jscomp$0.childExpirationTime, type > current && (current = type), _instance6 > current && (current = _instance6), renderExpirationTime$jscomp$0 = renderExpirationTime$jscomp$0.sibling;
          }

          newProps.childExpirationTime = current;
        }

        if (null !== current$$1) return current$$1;
        null !== unitOfWork && 0 === (unitOfWork.effectTag & 1024) && (null === unitOfWork.firstEffect && (unitOfWork.firstEffect = workInProgress.firstEffect), null !== workInProgress.lastEffect && (null !== unitOfWork.lastEffect && (unitOfWork.lastEffect.nextEffect = workInProgress.firstEffect), unitOfWork.lastEffect = workInProgress.lastEffect), 1 < workInProgress.effectTag && (null !== unitOfWork.lastEffect ? unitOfWork.lastEffect.nextEffect = workInProgress : unitOfWork.firstEffect = workInProgress, unitOfWork.lastEffect = workInProgress));
      } else {
        current$$1 = unwindWork(workInProgress, renderExpirationTime);
        if (null !== current$$1) return current$$1.effectTag &= 1023, current$$1;
        null !== unitOfWork && (unitOfWork.firstEffect = unitOfWork.lastEffect = null, unitOfWork.effectTag |= 1024);
      }

      current$$1 = workInProgress.sibling;
      if (null !== current$$1) return current$$1;
      workInProgress = unitOfWork;
    } while (null !== workInProgress);

    workInProgressRootExitStatus === RootIncomplete && (workInProgressRootExitStatus = RootCompleted);
    return null;
  }

  function commitRoot(root) {
    var renderPriorityLevel = getCurrentPriorityLevel();
    runWithPriority(99, commitRootImpl.bind(null, root, renderPriorityLevel));
    null !== rootWithPendingPassiveEffects && scheduleCallback(97, function () {
      flushPassiveEffects();
      return null;
    });
    return null;
  }

  function commitRootImpl(root, renderPriorityLevel) {
    flushPassiveEffects();
    if ((executionContext & (RenderContext | CommitContext)) !== NoContext) throw ReactError(Error("Should not already be working."));
    var finishedWork = root.finishedWork,
        expirationTime = root.finishedExpirationTime;
    if (null === finishedWork) return null;
    root.finishedWork = null;
    root.finishedExpirationTime = 0;
    if (finishedWork === root.current) throw ReactError(Error("Cannot commit the same tree as before. This error is likely caused by a bug in React. Please file an issue."));
    root.callbackNode = null;
    root.callbackExpirationTime = 0;
    var updateExpirationTimeBeforeCommit = finishedWork.expirationTime,
        childExpirationTimeBeforeCommit = finishedWork.childExpirationTime;
    updateExpirationTimeBeforeCommit = childExpirationTimeBeforeCommit > updateExpirationTimeBeforeCommit ? childExpirationTimeBeforeCommit : updateExpirationTimeBeforeCommit;
    root.firstPendingTime = updateExpirationTimeBeforeCommit;
    updateExpirationTimeBeforeCommit < root.lastPendingTime && (root.lastPendingTime = updateExpirationTimeBeforeCommit);
    root === workInProgressRoot && (workInProgress = workInProgressRoot = null, renderExpirationTime = 0);
    1 < finishedWork.effectTag ? null !== finishedWork.lastEffect ? (finishedWork.lastEffect.nextEffect = finishedWork, updateExpirationTimeBeforeCommit = finishedWork.firstEffect) : updateExpirationTimeBeforeCommit = finishedWork : updateExpirationTimeBeforeCommit = finishedWork.firstEffect;

    if (null !== updateExpirationTimeBeforeCommit) {
      childExpirationTimeBeforeCommit = executionContext;
      executionContext |= CommitContext;
      ReactCurrentOwner$2.current = null;
      nextEffect = updateExpirationTimeBeforeCommit;

      do {
        try {
          for (; null !== nextEffect;) {
            if (0 !== (nextEffect.effectTag & 256)) {
              var current$$1 = nextEffect.alternate,
                  finishedWork$jscomp$0 = nextEffect;

              switch (finishedWork$jscomp$0.tag) {
                case 0:
                case 11:
                case 15:
                  commitHookEffectList(UnmountSnapshot, NoEffect$1, finishedWork$jscomp$0);
                  break;

                case 1:
                  if (finishedWork$jscomp$0.effectTag & 256 && null !== current$$1) {
                    var prevProps = current$$1.memoizedProps,
                        prevState = current$$1.memoizedState,
                        instance = finishedWork$jscomp$0.stateNode,
                        snapshot = instance.getSnapshotBeforeUpdate(finishedWork$jscomp$0.elementType === finishedWork$jscomp$0.type ? prevProps : resolveDefaultProps(finishedWork$jscomp$0.type, prevProps), prevState);
                    instance.__reactInternalSnapshotBeforeUpdate = snapshot;
                  }

                  break;

                case 3:
                case 5:
                case 6:
                case 4:
                case 17:
                  break;

                default:
                  throw ReactError(Error("This unit of work tag should not have side-effects. This error is likely caused by a bug in React. Please file an issue."));
              }
            }

            nextEffect = nextEffect.nextEffect;
          }
        } catch (error) {
          if (null === nextEffect) throw ReactError(Error("Should be working on an effect."));
          captureCommitPhaseError(nextEffect, error);
          nextEffect = nextEffect.nextEffect;
        }
      } while (null !== nextEffect);

      nextEffect = updateExpirationTimeBeforeCommit;

      do {
        try {
          for (current$$1 = renderPriorityLevel; null !== nextEffect;) {
            var effectTag = nextEffect.effectTag;

            if (effectTag & 128) {
              var current$$1$jscomp$0 = nextEffect.alternate;

              if (null !== current$$1$jscomp$0) {
                var currentRef = current$$1$jscomp$0.ref;
                null !== currentRef && ("function" === typeof currentRef ? currentRef(null) : currentRef.current = null);
              }
            }

            switch (effectTag & 14) {
              case 2:
                commitPlacement(nextEffect);
                nextEffect.effectTag &= -3;
                break;

              case 6:
                commitPlacement(nextEffect);
                nextEffect.effectTag &= -3;
                commitWork(nextEffect.alternate, nextEffect);
                break;

              case 4:
                commitWork(nextEffect.alternate, nextEffect);
                break;

              case 8:
                prevProps = nextEffect, unmountHostComponents(prevProps, current$$1), detachFiber(prevProps);
            }

            nextEffect = nextEffect.nextEffect;
          }
        } catch (error) {
          if (null === nextEffect) throw ReactError(Error("Should be working on an effect."));
          captureCommitPhaseError(nextEffect, error);
          nextEffect = nextEffect.nextEffect;
        }
      } while (null !== nextEffect);

      root.current = finishedWork;
      nextEffect = updateExpirationTimeBeforeCommit;

      do {
        try {
          for (effectTag = expirationTime; null !== nextEffect;) {
            var effectTag$jscomp$0 = nextEffect.effectTag;

            if (effectTag$jscomp$0 & 36) {
              var current$$1$jscomp$1 = nextEffect.alternate;
              current$$1$jscomp$0 = nextEffect;
              currentRef = effectTag;

              switch (current$$1$jscomp$0.tag) {
                case 0:
                case 11:
                case 15:
                  commitHookEffectList(UnmountLayout, MountLayout, current$$1$jscomp$0);
                  break;

                case 1:
                  var instance$jscomp$0 = current$$1$jscomp$0.stateNode;
                  if (current$$1$jscomp$0.effectTag & 4) if (null === current$$1$jscomp$1) instance$jscomp$0.componentDidMount();else {
                    var prevProps$jscomp$0 = current$$1$jscomp$0.elementType === current$$1$jscomp$0.type ? current$$1$jscomp$1.memoizedProps : resolveDefaultProps(current$$1$jscomp$0.type, current$$1$jscomp$1.memoizedProps);
                    instance$jscomp$0.componentDidUpdate(prevProps$jscomp$0, current$$1$jscomp$1.memoizedState, instance$jscomp$0.__reactInternalSnapshotBeforeUpdate);
                  }
                  var updateQueue = current$$1$jscomp$0.updateQueue;
                  null !== updateQueue && commitUpdateQueue(current$$1$jscomp$0, updateQueue, instance$jscomp$0, currentRef);
                  break;

                case 3:
                  var _updateQueue = current$$1$jscomp$0.updateQueue;

                  if (null !== _updateQueue) {
                    current$$1 = null;
                    if (null !== current$$1$jscomp$0.child) switch (current$$1$jscomp$0.child.tag) {
                      case 5:
                        current$$1 = current$$1$jscomp$0.child.stateNode;
                        break;

                      case 1:
                        current$$1 = current$$1$jscomp$0.child.stateNode;
                    }
                    commitUpdateQueue(current$$1$jscomp$0, _updateQueue, current$$1, currentRef);
                  }

                  break;

                case 5:
                  break;

                case 6:
                  break;

                case 4:
                  break;

                case 12:
                  break;

                case 13:
                case 19:
                case 17:
                case 20:
                  break;

                default:
                  throw ReactError(Error("This unit of work tag should not have side-effects. This error is likely caused by a bug in React. Please file an issue."));
              }
            }

            if (effectTag$jscomp$0 & 128) {
              var ref = nextEffect.ref;

              if (null !== ref) {
                var instance$jscomp$1 = nextEffect.stateNode;

                switch (nextEffect.tag) {
                  case 5:
                    var instanceToUse = instance$jscomp$1;
                    break;

                  default:
                    instanceToUse = instance$jscomp$1;
                }

                "function" === typeof ref ? ref(instanceToUse) : ref.current = instanceToUse;
              }
            }

            effectTag$jscomp$0 & 512 && (rootDoesHavePassiveEffects = !0);
            nextEffect = nextEffect.nextEffect;
          }
        } catch (error) {
          if (null === nextEffect) throw ReactError(Error("Should be working on an effect."));
          captureCommitPhaseError(nextEffect, error);
          nextEffect = nextEffect.nextEffect;
        }
      } while (null !== nextEffect);

      nextEffect = null;
      requestPaint();
      executionContext = childExpirationTimeBeforeCommit;
    } else root.current = finishedWork;

    if (rootDoesHavePassiveEffects) rootDoesHavePassiveEffects = !1, rootWithPendingPassiveEffects = root, pendingPassiveEffectsExpirationTime = expirationTime, pendingPassiveEffectsRenderPriority = renderPriorityLevel;else for (nextEffect = updateExpirationTimeBeforeCommit; null !== nextEffect;) {
      renderPriorityLevel = nextEffect.nextEffect, nextEffect.nextEffect = null, nextEffect = renderPriorityLevel;
    }
    renderPriorityLevel = root.firstPendingTime;
    0 !== renderPriorityLevel ? (effectTag$jscomp$0 = requestCurrentTime(), effectTag$jscomp$0 = inferPriorityFromExpirationTime(effectTag$jscomp$0, renderPriorityLevel), scheduleCallbackForRoot(root, effectTag$jscomp$0, renderPriorityLevel)) : legacyErrorBoundariesThatAlreadyFailed = null;
    "function" === typeof onCommitFiberRoot && onCommitFiberRoot(finishedWork.stateNode, expirationTime);
    1073741823 === renderPriorityLevel ? root === rootWithNestedUpdates ? nestedUpdateCount++ : (nestedUpdateCount = 0, rootWithNestedUpdates = root) : nestedUpdateCount = 0;
    if (hasUncaughtError) throw hasUncaughtError = !1, root = firstUncaughtError, firstUncaughtError = null, root;
    if ((executionContext & LegacyUnbatchedContext) !== NoContext) return null;
    flushSyncCallbackQueue();
    return null;
  }

  function flushPassiveEffects() {
    if (null === rootWithPendingPassiveEffects) return !1;
    var root = rootWithPendingPassiveEffects,
        expirationTime = pendingPassiveEffectsExpirationTime,
        renderPriorityLevel = pendingPassiveEffectsRenderPriority;
    rootWithPendingPassiveEffects = null;
    pendingPassiveEffectsExpirationTime = 0;
    pendingPassiveEffectsRenderPriority = 90;
    return runWithPriority(97 < renderPriorityLevel ? 97 : renderPriorityLevel, flushPassiveEffectsImpl.bind(null, root, expirationTime));
  }

  function flushPassiveEffectsImpl(root) {
    if ((executionContext & (RenderContext | CommitContext)) !== NoContext) throw ReactError(Error("Cannot flush passive effects while already rendering."));
    var prevExecutionContext = executionContext;
    executionContext |= CommitContext;

    for (root = root.current.firstEffect; null !== root;) {
      try {
        var finishedWork = root;
        if (0 !== (finishedWork.effectTag & 512)) switch (finishedWork.tag) {
          case 0:
          case 11:
          case 15:
            commitHookEffectList(UnmountPassive, NoEffect$1, finishedWork), commitHookEffectList(NoEffect$1, MountPassive, finishedWork);
        }
      } catch (error) {
        if (null === root) throw ReactError(Error("Should be working on an effect."));
        captureCommitPhaseError(root, error);
      }

      finishedWork = root.nextEffect;
      root.nextEffect = null;
      root = finishedWork;
    }

    executionContext = prevExecutionContext;
    flushSyncCallbackQueue();
    return !0;
  }

  function captureCommitPhaseErrorOnRoot(rootFiber, sourceFiber, error) {
    sourceFiber = createCapturedValue(error, sourceFiber);
    sourceFiber = createRootErrorUpdate(rootFiber, sourceFiber, 1073741823);
    enqueueUpdate(rootFiber, sourceFiber);
    rootFiber = markUpdateTimeFromFiberToRoot(rootFiber, 1073741823);
    null !== rootFiber && scheduleCallbackForRoot(rootFiber, 99, 1073741823);
  }

  function captureCommitPhaseError(sourceFiber, error) {
    if (3 === sourceFiber.tag) captureCommitPhaseErrorOnRoot(sourceFiber, sourceFiber, error);else for (var fiber = sourceFiber.return; null !== fiber;) {
      if (3 === fiber.tag) {
        captureCommitPhaseErrorOnRoot(fiber, sourceFiber, error);
        break;
      } else if (1 === fiber.tag) {
        var instance = fiber.stateNode;

        if ("function" === typeof fiber.type.getDerivedStateFromError || "function" === typeof instance.componentDidCatch && (null === legacyErrorBoundariesThatAlreadyFailed || !legacyErrorBoundariesThatAlreadyFailed.has(instance))) {
          sourceFiber = createCapturedValue(error, sourceFiber);
          sourceFiber = createClassErrorUpdate(fiber, sourceFiber, 1073741823);
          enqueueUpdate(fiber, sourceFiber);
          fiber = markUpdateTimeFromFiberToRoot(fiber, 1073741823);
          null !== fiber && scheduleCallbackForRoot(fiber, 99, 1073741823);
          break;
        }
      }

      fiber = fiber.return;
    }
  }

  function pingSuspendedRoot(root, thenable, suspendedTime) {
    var pingCache = root.pingCache;
    null !== pingCache && pingCache.delete(thenable);
    workInProgressRoot === root && renderExpirationTime === suspendedTime ? workInProgressRootExitStatus === RootSuspendedWithDelay || workInProgressRootExitStatus === RootSuspended && 1073741823 === workInProgressRootLatestProcessedExpirationTime && now() - globalMostRecentFallbackTime < FALLBACK_THROTTLE_MS ? prepareFreshStack(root, renderExpirationTime) : workInProgressRootHasPendingPing = !0 : root.lastPendingTime < suspendedTime || (thenable = root.pingTime, 0 !== thenable && thenable < suspendedTime || (root.pingTime = suspendedTime, root.finishedExpirationTime === suspendedTime && (root.finishedExpirationTime = 0, root.finishedWork = null), thenable = requestCurrentTime(), thenable = inferPriorityFromExpirationTime(thenable, suspendedTime), scheduleCallbackForRoot(root, thenable, suspendedTime)));
  }

  function resolveRetryThenable(boundaryFiber, thenable) {
    var retryCache = boundaryFiber.stateNode;
    null !== retryCache && retryCache.delete(thenable);
    retryCache = requestCurrentTime();
    thenable = computeExpirationForFiber(retryCache, boundaryFiber, null);
    retryCache = inferPriorityFromExpirationTime(retryCache, thenable);
    boundaryFiber = markUpdateTimeFromFiberToRoot(boundaryFiber, thenable);
    null !== boundaryFiber && scheduleCallbackForRoot(boundaryFiber, retryCache, thenable);
  }

  var beginWork$$1 = void 0;

  beginWork$$1 = function beginWork$$1(current$$1, workInProgress, renderExpirationTime) {
    var updateExpirationTime = workInProgress.expirationTime;
    if (null !== current$$1) {
      if (current$$1.memoizedProps !== workInProgress.pendingProps || didPerformWorkStackCursor.current) didReceiveUpdate = !0;else {
        if (updateExpirationTime < renderExpirationTime) {
          didReceiveUpdate = !1;

          switch (workInProgress.tag) {
            case 3:
              pushHostRootContext(workInProgress);
              break;

            case 5:
              pushHostContext(workInProgress);
              break;

            case 1:
              isContextProvider(workInProgress.type) && pushContextProvider(workInProgress);
              break;

            case 4:
              pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
              break;

            case 10:
              pushProvider(workInProgress, workInProgress.memoizedProps.value);
              break;

            case 13:
              if (null !== workInProgress.memoizedState) {
                updateExpirationTime = workInProgress.child.childExpirationTime;
                if (0 !== updateExpirationTime && updateExpirationTime >= renderExpirationTime) return updateSuspenseComponent(current$$1, workInProgress, renderExpirationTime);
                push(suspenseStackCursor, suspenseStackCursor.current & SubtreeSuspenseContextMask, workInProgress);
                workInProgress = bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
                return null !== workInProgress ? workInProgress.sibling : null;
              }

              push(suspenseStackCursor, suspenseStackCursor.current & SubtreeSuspenseContextMask, workInProgress);
              break;

            case 19:
              updateExpirationTime = workInProgress.childExpirationTime >= renderExpirationTime;

              if (0 !== (current$$1.effectTag & 64)) {
                if (updateExpirationTime) return updateSuspenseListComponent(current$$1, workInProgress, renderExpirationTime);
                workInProgress.effectTag |= 64;
              }

              var renderState = workInProgress.memoizedState;
              null !== renderState && (renderState.rendering = null, renderState.tail = null);
              push(suspenseStackCursor, suspenseStackCursor.current, workInProgress);
              if (!updateExpirationTime) return null;
          }

          return bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
        }
      }
    } else didReceiveUpdate = !1;
    workInProgress.expirationTime = 0;

    switch (workInProgress.tag) {
      case 2:
        updateExpirationTime = workInProgress.type;
        null !== current$$1 && (current$$1.alternate = null, workInProgress.alternate = null, workInProgress.effectTag |= 2);
        current$$1 = workInProgress.pendingProps;
        renderState = getMaskedContext(workInProgress, contextStackCursor.current);
        prepareToReadContext(workInProgress, renderExpirationTime);
        renderState = renderWithHooks(null, workInProgress, updateExpirationTime, current$$1, renderState, renderExpirationTime);
        workInProgress.effectTag |= 1;

        if ("object" === typeof renderState && null !== renderState && "function" === typeof renderState.render && void 0 === renderState.$$typeof) {
          workInProgress.tag = 1;
          resetHooks();

          if (isContextProvider(updateExpirationTime)) {
            var hasContext = !0;
            pushContextProvider(workInProgress);
          } else hasContext = !1;

          workInProgress.memoizedState = null !== renderState.state && void 0 !== renderState.state ? renderState.state : null;
          var getDerivedStateFromProps = updateExpirationTime.getDerivedStateFromProps;
          "function" === typeof getDerivedStateFromProps && applyDerivedStateFromProps(workInProgress, updateExpirationTime, getDerivedStateFromProps, current$$1);
          renderState.updater = classComponentUpdater;
          workInProgress.stateNode = renderState;
          renderState._reactInternalFiber = workInProgress;
          mountClassInstance(workInProgress, updateExpirationTime, current$$1, renderExpirationTime);
          workInProgress = finishClassComponent(null, workInProgress, updateExpirationTime, !0, hasContext, renderExpirationTime);
        } else workInProgress.tag = 0, reconcileChildren(null, workInProgress, renderState, renderExpirationTime), workInProgress = workInProgress.child;

        return workInProgress;

      case 16:
        renderState = workInProgress.elementType;
        null !== current$$1 && (current$$1.alternate = null, workInProgress.alternate = null, workInProgress.effectTag |= 2);
        current$$1 = workInProgress.pendingProps;
        renderState = readLazyComponentType(renderState);
        workInProgress.type = renderState;
        hasContext = workInProgress.tag = resolveLazyComponentTag(renderState);
        current$$1 = resolveDefaultProps(renderState, current$$1);

        switch (hasContext) {
          case 0:
            workInProgress = updateFunctionComponent(null, workInProgress, renderState, current$$1, renderExpirationTime);
            break;

          case 1:
            workInProgress = updateClassComponent(null, workInProgress, renderState, current$$1, renderExpirationTime);
            break;

          case 11:
            workInProgress = updateForwardRef(null, workInProgress, renderState, current$$1, renderExpirationTime);
            break;

          case 14:
            workInProgress = updateMemoComponent(null, workInProgress, renderState, resolveDefaultProps(renderState.type, current$$1), updateExpirationTime, renderExpirationTime);
            break;

          default:
            throw ReactError(Error("Element type is invalid. Received a promise that resolves to: " + renderState + ". Lazy element type must resolve to a class or function."));
        }

        return workInProgress;

      case 0:
        return updateExpirationTime = workInProgress.type, renderState = workInProgress.pendingProps, renderState = workInProgress.elementType === updateExpirationTime ? renderState : resolveDefaultProps(updateExpirationTime, renderState), updateFunctionComponent(current$$1, workInProgress, updateExpirationTime, renderState, renderExpirationTime);

      case 1:
        return updateExpirationTime = workInProgress.type, renderState = workInProgress.pendingProps, renderState = workInProgress.elementType === updateExpirationTime ? renderState : resolveDefaultProps(updateExpirationTime, renderState), updateClassComponent(current$$1, workInProgress, updateExpirationTime, renderState, renderExpirationTime);

      case 3:
        pushHostRootContext(workInProgress);
        updateExpirationTime = workInProgress.updateQueue;
        if (null === updateExpirationTime) throw ReactError(Error("If the root does not have an updateQueue, we should have already bailed out. This error is likely caused by a bug in React. Please file an issue."));
        renderState = workInProgress.memoizedState;
        renderState = null !== renderState ? renderState.element : null;
        processUpdateQueue(workInProgress, updateExpirationTime, workInProgress.pendingProps, null, renderExpirationTime);
        updateExpirationTime = workInProgress.memoizedState.element;
        updateExpirationTime === renderState ? workInProgress = bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime) : (reconcileChildren(current$$1, workInProgress, updateExpirationTime, renderExpirationTime), workInProgress = workInProgress.child);
        return workInProgress;

      case 5:
        return pushHostContext(workInProgress), null === current$$1 && tryToClaimNextHydratableInstance(workInProgress), updateExpirationTime = workInProgress.pendingProps.children, markRef(current$$1, workInProgress), reconcileChildren(current$$1, workInProgress, updateExpirationTime, renderExpirationTime), workInProgress.child;

      case 6:
        return null === current$$1 && tryToClaimNextHydratableInstance(workInProgress), null;

      case 13:
        return updateSuspenseComponent(current$$1, workInProgress, renderExpirationTime);

      case 4:
        return pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo), updateExpirationTime = workInProgress.pendingProps, null === current$$1 ? workInProgress.child = reconcileChildFibers(workInProgress, null, updateExpirationTime, renderExpirationTime) : reconcileChildren(current$$1, workInProgress, updateExpirationTime, renderExpirationTime), workInProgress.child;

      case 11:
        return updateExpirationTime = workInProgress.type, renderState = workInProgress.pendingProps, renderState = workInProgress.elementType === updateExpirationTime ? renderState : resolveDefaultProps(updateExpirationTime, renderState), updateForwardRef(current$$1, workInProgress, updateExpirationTime, renderState, renderExpirationTime);

      case 7:
        return reconcileChildren(current$$1, workInProgress, workInProgress.pendingProps, renderExpirationTime), workInProgress.child;

      case 8:
        return reconcileChildren(current$$1, workInProgress, workInProgress.pendingProps.children, renderExpirationTime), workInProgress.child;

      case 12:
        return reconcileChildren(current$$1, workInProgress, workInProgress.pendingProps.children, renderExpirationTime), workInProgress.child;

      case 10:
        a: {
          updateExpirationTime = workInProgress.type._context;
          renderState = workInProgress.pendingProps;
          getDerivedStateFromProps = workInProgress.memoizedProps;
          hasContext = renderState.value;
          pushProvider(workInProgress, hasContext);

          if (null !== getDerivedStateFromProps) {
            var oldValue = getDerivedStateFromProps.value;
            hasContext = is(oldValue, hasContext) ? 0 : ("function" === typeof updateExpirationTime._calculateChangedBits ? updateExpirationTime._calculateChangedBits(oldValue, hasContext) : 1073741823) | 0;

            if (0 === hasContext) {
              if (getDerivedStateFromProps.children === renderState.children && !didPerformWorkStackCursor.current) {
                workInProgress = bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
                break a;
              }
            } else for (oldValue = workInProgress.child, null !== oldValue && (oldValue.return = workInProgress); null !== oldValue;) {
              var list = oldValue.dependencies;

              if (null !== list) {
                getDerivedStateFromProps = oldValue.child;

                for (var dependency = list.firstContext; null !== dependency;) {
                  if (dependency.context === updateExpirationTime && 0 !== (dependency.observedBits & hasContext)) {
                    1 === oldValue.tag && (dependency = createUpdate(renderExpirationTime, null), dependency.tag = 2, enqueueUpdate(oldValue, dependency));
                    oldValue.expirationTime < renderExpirationTime && (oldValue.expirationTime = renderExpirationTime);
                    dependency = oldValue.alternate;
                    null !== dependency && dependency.expirationTime < renderExpirationTime && (dependency.expirationTime = renderExpirationTime);
                    scheduleWorkOnParentPath(oldValue.return, renderExpirationTime);
                    list.expirationTime < renderExpirationTime && (list.expirationTime = renderExpirationTime);
                    break;
                  }

                  dependency = dependency.next;
                }
              } else getDerivedStateFromProps = 10 === oldValue.tag ? oldValue.type === workInProgress.type ? null : oldValue.child : oldValue.child;

              if (null !== getDerivedStateFromProps) getDerivedStateFromProps.return = oldValue;else for (getDerivedStateFromProps = oldValue; null !== getDerivedStateFromProps;) {
                if (getDerivedStateFromProps === workInProgress) {
                  getDerivedStateFromProps = null;
                  break;
                }

                oldValue = getDerivedStateFromProps.sibling;

                if (null !== oldValue) {
                  oldValue.return = getDerivedStateFromProps.return;
                  getDerivedStateFromProps = oldValue;
                  break;
                }

                getDerivedStateFromProps = getDerivedStateFromProps.return;
              }
              oldValue = getDerivedStateFromProps;
            }
          }

          reconcileChildren(current$$1, workInProgress, renderState.children, renderExpirationTime);
          workInProgress = workInProgress.child;
        }

        return workInProgress;

      case 9:
        return renderState = workInProgress.type, hasContext = workInProgress.pendingProps, updateExpirationTime = hasContext.children, prepareToReadContext(workInProgress, renderExpirationTime), renderState = readContext(renderState, hasContext.unstable_observedBits), updateExpirationTime = updateExpirationTime(renderState), workInProgress.effectTag |= 1, reconcileChildren(current$$1, workInProgress, updateExpirationTime, renderExpirationTime), workInProgress.child;

      case 14:
        return renderState = workInProgress.type, hasContext = resolveDefaultProps(renderState, workInProgress.pendingProps), hasContext = resolveDefaultProps(renderState.type, hasContext), updateMemoComponent(current$$1, workInProgress, renderState, hasContext, updateExpirationTime, renderExpirationTime);

      case 15:
        return updateSimpleMemoComponent(current$$1, workInProgress, workInProgress.type, workInProgress.pendingProps, updateExpirationTime, renderExpirationTime);

      case 17:
        return updateExpirationTime = workInProgress.type, renderState = workInProgress.pendingProps, renderState = workInProgress.elementType === updateExpirationTime ? renderState : resolveDefaultProps(updateExpirationTime, renderState), null !== current$$1 && (current$$1.alternate = null, workInProgress.alternate = null, workInProgress.effectTag |= 2), workInProgress.tag = 1, isContextProvider(updateExpirationTime) ? (current$$1 = !0, pushContextProvider(workInProgress)) : current$$1 = !1, prepareToReadContext(workInProgress, renderExpirationTime), constructClassInstance(workInProgress, updateExpirationTime, renderState, renderExpirationTime), mountClassInstance(workInProgress, updateExpirationTime, renderState, renderExpirationTime), finishClassComponent(null, workInProgress, updateExpirationTime, !0, current$$1, renderExpirationTime);

      case 19:
        return updateSuspenseListComponent(current$$1, workInProgress, renderExpirationTime);
    }

    throw ReactError(Error("Unknown unit of work tag. This error is likely caused by a bug in React. Please file an issue."));
  };

  var onCommitFiberRoot = null,
      onCommitFiberUnmount = null;

  function injectInternals(internals) {
    if ("undefined" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__) return !1;
    var hook = __REACT_DEVTOOLS_GLOBAL_HOOK__;
    if (hook.isDisabled || !hook.supportsFiber) return !0;

    try {
      var rendererID = hook.inject(internals);

      onCommitFiberRoot = function onCommitFiberRoot(root) {
        try {
          hook.onCommitFiberRoot(rendererID, root, void 0, 64 === (root.current.effectTag & 64));
        } catch (err) {}
      };

      onCommitFiberUnmount = function onCommitFiberUnmount(fiber) {
        try {
          hook.onCommitFiberUnmount(rendererID, fiber);
        } catch (err) {}
      };
    } catch (err) {}

    return !0;
  }

  function FiberNode(tag, pendingProps, key, mode) {
    this.tag = tag;
    this.key = key;
    this.sibling = this.child = this.return = this.stateNode = this.type = this.elementType = null;
    this.index = 0;
    this.ref = null;
    this.pendingProps = pendingProps;
    this.dependencies = this.memoizedState = this.updateQueue = this.memoizedProps = null;
    this.mode = mode;
    this.effectTag = 0;
    this.lastEffect = this.firstEffect = this.nextEffect = null;
    this.childExpirationTime = this.expirationTime = 0;
    this.alternate = null;
  }

  function createFiber(tag, pendingProps, key, mode) {
    return new FiberNode(tag, pendingProps, key, mode);
  }

  function shouldConstruct(Component) {
    Component = Component.prototype;
    return !(!Component || !Component.isReactComponent);
  }

  function resolveLazyComponentTag(Component) {
    if ("function" === typeof Component) return shouldConstruct(Component) ? 1 : 0;

    if (void 0 !== Component && null !== Component) {
      Component = Component.$$typeof;
      if (Component === REACT_FORWARD_REF_TYPE) return 11;
      if (Component === REACT_MEMO_TYPE) return 14;
    }

    return 2;
  }

  function createWorkInProgress(current, pendingProps) {
    var workInProgress = current.alternate;
    null === workInProgress ? (workInProgress = createFiber(current.tag, pendingProps, current.key, current.mode), workInProgress.elementType = current.elementType, workInProgress.type = current.type, workInProgress.stateNode = current.stateNode, workInProgress.alternate = current, current.alternate = workInProgress) : (workInProgress.pendingProps = pendingProps, workInProgress.effectTag = 0, workInProgress.nextEffect = null, workInProgress.firstEffect = null, workInProgress.lastEffect = null);
    workInProgress.childExpirationTime = current.childExpirationTime;
    workInProgress.expirationTime = current.expirationTime;
    workInProgress.child = current.child;
    workInProgress.memoizedProps = current.memoizedProps;
    workInProgress.memoizedState = current.memoizedState;
    workInProgress.updateQueue = current.updateQueue;
    pendingProps = current.dependencies;
    workInProgress.dependencies = null === pendingProps ? null : {
      expirationTime: pendingProps.expirationTime,
      firstContext: pendingProps.firstContext,
      responders: pendingProps.responders
    };
    workInProgress.sibling = current.sibling;
    workInProgress.index = current.index;
    workInProgress.ref = current.ref;
    return workInProgress;
  }

  function createFiberFromTypeAndProps(type, key, pendingProps, owner, mode, expirationTime) {
    var fiberTag = 2;
    owner = type;
    if ("function" === typeof type) shouldConstruct(type) && (fiberTag = 1);else if ("string" === typeof type) fiberTag = 5;else a: switch (type) {
      case REACT_FRAGMENT_TYPE:
        return createFiberFromFragment(pendingProps.children, mode, expirationTime, key);

      case REACT_CONCURRENT_MODE_TYPE:
        fiberTag = 8;
        mode |= 7;
        break;

      case REACT_STRICT_MODE_TYPE:
        fiberTag = 8;
        mode |= 1;
        break;

      case REACT_PROFILER_TYPE:
        return type = createFiber(12, pendingProps, key, mode | 8), type.elementType = REACT_PROFILER_TYPE, type.type = REACT_PROFILER_TYPE, type.expirationTime = expirationTime, type;

      case REACT_SUSPENSE_TYPE:
        return type = createFiber(13, pendingProps, key, mode), type.type = REACT_SUSPENSE_TYPE, type.elementType = REACT_SUSPENSE_TYPE, type.expirationTime = expirationTime, type;

      case REACT_SUSPENSE_LIST_TYPE:
        return type = createFiber(19, pendingProps, key, mode), type.elementType = REACT_SUSPENSE_LIST_TYPE, type.expirationTime = expirationTime, type;

      default:
        if ("object" === typeof type && null !== type) switch (type.$$typeof) {
          case REACT_PROVIDER_TYPE:
            fiberTag = 10;
            break a;

          case REACT_CONTEXT_TYPE:
            fiberTag = 9;
            break a;

          case REACT_FORWARD_REF_TYPE:
            fiberTag = 11;
            break a;

          case REACT_MEMO_TYPE:
            fiberTag = 14;
            break a;

          case REACT_LAZY_TYPE:
            fiberTag = 16;
            owner = null;
            break a;
        }
        throw ReactError(Error("Element type is invalid: expected a string (for built-in components) or a class/function (for composite components) but got: " + (null == type ? type : typeof type) + "."));
    }
    key = createFiber(fiberTag, pendingProps, key, mode);
    key.elementType = type;
    key.type = owner;
    key.expirationTime = expirationTime;
    return key;
  }

  function createFiberFromFragment(elements, mode, expirationTime, key) {
    elements = createFiber(7, elements, key, mode);
    elements.expirationTime = expirationTime;
    return elements;
  }

  function createFiberFromText(content, mode, expirationTime) {
    content = createFiber(6, content, null, mode);
    content.expirationTime = expirationTime;
    return content;
  }

  function createFiberFromPortal(portal, mode, expirationTime) {
    mode = createFiber(4, null !== portal.children ? portal.children : [], portal.key, mode);
    mode.expirationTime = expirationTime;
    mode.stateNode = {
      containerInfo: portal.containerInfo,
      pendingChildren: null,
      implementation: portal.implementation
    };
    return mode;
  }

  function FiberRootNode(containerInfo, tag, hydrate) {
    this.tag = tag;
    this.current = null;
    this.containerInfo = containerInfo;
    this.pingCache = this.pendingChildren = null;
    this.finishedExpirationTime = 0;
    this.finishedWork = null;
    this.timeoutHandle = -1;
    this.pendingContext = this.context = null;
    this.hydrate = hydrate;
    this.callbackNode = this.firstBatch = null;
    this.pingTime = this.lastPendingTime = this.firstPendingTime = this.callbackExpirationTime = 0;
  }

  function findHostInstance(component) {
    var fiber = component._reactInternalFiber;

    if (void 0 === fiber) {
      if ("function" === typeof component.render) throw ReactError(Error("Unable to find node on an unmounted component."));
      throw ReactError(Error("Argument appears to not be a ReactComponent. Keys: " + Object.keys(component)));
    }

    component = findCurrentHostFiber(fiber);
    return null === component ? null : component.stateNode;
  }

  function updateContainer(element, container, parentComponent, callback) {
    var current$$1 = container.current,
        currentTime = requestCurrentTime(),
        suspenseConfig = ReactCurrentBatchConfig.suspense;
    current$$1 = computeExpirationForFiber(currentTime, current$$1, suspenseConfig);
    currentTime = container.current;

    a: if (parentComponent) {
      parentComponent = parentComponent._reactInternalFiber;

      b: {
        if (2 !== isFiberMountedImpl(parentComponent) || 1 !== parentComponent.tag) throw ReactError(Error("Expected subtree parent to be a mounted class component. This error is likely caused by a bug in React. Please file an issue."));
        var parentContext = parentComponent;

        do {
          switch (parentContext.tag) {
            case 3:
              parentContext = parentContext.stateNode.context;
              break b;

            case 1:
              if (isContextProvider(parentContext.type)) {
                parentContext = parentContext.stateNode.__reactInternalMemoizedMergedChildContext;
                break b;
              }

          }

          parentContext = parentContext.return;
        } while (null !== parentContext);

        throw ReactError(Error("Found unexpected detached subtree parent. This error is likely caused by a bug in React. Please file an issue."));
      }

      if (1 === parentComponent.tag) {
        var Component = parentComponent.type;

        if (isContextProvider(Component)) {
          parentComponent = processChildContext(parentComponent, Component, parentContext);
          break a;
        }
      }

      parentComponent = parentContext;
    } else parentComponent = emptyContextObject;

    null === container.context ? container.context = parentComponent : container.pendingContext = parentComponent;
    container = callback;
    suspenseConfig = createUpdate(current$$1, suspenseConfig);
    suspenseConfig.payload = {
      element: element
    };
    container = void 0 === container ? null : container;
    null !== container && (suspenseConfig.callback = container);
    enqueueUpdate(currentTime, suspenseConfig);
    scheduleUpdateOnFiber(currentTime, current$$1);
    return current$$1;
  }

  function _createPortal(children, containerInfo, implementation) {
    var key = 3 < arguments.length && void 0 !== arguments[3] ? arguments[3] : null;
    return {
      $$typeof: REACT_PORTAL_TYPE,
      key: null == key ? null : "" + key,
      children: children,
      containerInfo: containerInfo,
      implementation: implementation
    };
  }

  function _inherits(subClass, superClass) {
    if ("function" !== typeof superClass && null !== superClass) throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
    subClass.prototype = Object.create(superClass && superClass.prototype, {
      constructor: {
        value: subClass,
        enumerable: !1,
        writable: !0,
        configurable: !0
      }
    });
    superClass && (Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass);
  }

  var getInspectorDataForViewTag = void 0;

  getInspectorDataForViewTag = function getInspectorDataForViewTag() {
    throw ReactError(Error("getInspectorDataForViewTag() is not available in production"));
  };

  function findNodeHandle(componentOrHandle) {
    if (null == componentOrHandle) return null;
    if ("number" === typeof componentOrHandle) return componentOrHandle;
    if (componentOrHandle._nativeTag) return componentOrHandle._nativeTag;
    if (componentOrHandle.canonical && componentOrHandle.canonical._nativeTag) return componentOrHandle.canonical._nativeTag;
    componentOrHandle = findHostInstance(componentOrHandle);
    return null == componentOrHandle ? componentOrHandle : componentOrHandle.canonical ? componentOrHandle.canonical._nativeTag : componentOrHandle._nativeTag;
  }

  batchedUpdatesImpl = function batchedUpdatesImpl(fn, a) {
    var prevExecutionContext = executionContext;
    executionContext |= 1;

    try {
      return fn(a);
    } finally {
      executionContext = prevExecutionContext, executionContext === NoContext && flushSyncCallbackQueue();
    }
  };

  flushDiscreteUpdatesImpl = function flushDiscreteUpdatesImpl() {
    (executionContext & (1 | RenderContext | CommitContext)) === NoContext && (flushPendingDiscreteUpdates(), flushPassiveEffects());
  };

  var roots = new Map(),
      ReactNativeRenderer = {
    NativeComponent: function (findNodeHandle, findHostInstance) {
      return function (_React$Component) {
        function ReactNativeComponent() {
          if (!(this instanceof ReactNativeComponent)) throw new TypeError("Cannot call a class as a function");

          var call = _React$Component.apply(this, arguments);

          if (!this) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
          return !call || "object" !== typeof call && "function" !== typeof call ? this : call;
        }

        _inherits(ReactNativeComponent, _React$Component);

        ReactNativeComponent.prototype.blur = function () {
          ReactNativePrivateInterface.TextInputState.blurTextInput(findNodeHandle(this));
        };

        ReactNativeComponent.prototype.focus = function () {
          ReactNativePrivateInterface.TextInputState.focusTextInput(findNodeHandle(this));
        };

        ReactNativeComponent.prototype.measure = function (callback) {
          var maybeInstance = void 0;

          try {
            maybeInstance = findHostInstance(this);
          } catch (error) {}

          null != maybeInstance && (maybeInstance.canonical ? nativeFabricUIManager.measure(maybeInstance.node, mountSafeCallback_NOT_REALLY_SAFE(this, callback)) : ReactNativePrivateInterface.UIManager.measure(findNodeHandle(this), mountSafeCallback_NOT_REALLY_SAFE(this, callback)));
        };

        ReactNativeComponent.prototype.measureInWindow = function (callback) {
          var maybeInstance = void 0;

          try {
            maybeInstance = findHostInstance(this);
          } catch (error) {}

          null != maybeInstance && (maybeInstance.canonical ? nativeFabricUIManager.measureInWindow(maybeInstance.node, mountSafeCallback_NOT_REALLY_SAFE(this, callback)) : ReactNativePrivateInterface.UIManager.measureInWindow(findNodeHandle(this), mountSafeCallback_NOT_REALLY_SAFE(this, callback)));
        };

        ReactNativeComponent.prototype.measureLayout = function (relativeToNativeNode, onSuccess, onFail) {
          var maybeInstance = void 0;

          try {
            maybeInstance = findHostInstance(this);
          } catch (error) {}

          null == maybeInstance || maybeInstance.canonical || (maybeInstance = void 0, "number" === typeof relativeToNativeNode ? maybeInstance = relativeToNativeNode : relativeToNativeNode._nativeTag && (maybeInstance = relativeToNativeNode._nativeTag), null != maybeInstance && ReactNativePrivateInterface.UIManager.measureLayout(findNodeHandle(this), maybeInstance, mountSafeCallback_NOT_REALLY_SAFE(this, onFail), mountSafeCallback_NOT_REALLY_SAFE(this, onSuccess)));
        };

        ReactNativeComponent.prototype.setNativeProps = function (nativeProps) {
          var maybeInstance = void 0;

          try {
            maybeInstance = findHostInstance(this);
          } catch (error) {}

          if (null != maybeInstance && !maybeInstance.canonical) {
            var nativeTag = maybeInstance._nativeTag || maybeInstance.canonical._nativeTag;
            maybeInstance = maybeInstance.viewConfig || maybeInstance.canonical.viewConfig;
            nativeProps = diffProperties(null, emptyObject, nativeProps, maybeInstance.validAttributes);
            null != nativeProps && ReactNativePrivateInterface.UIManager.updateView(nativeTag, maybeInstance.uiViewClassName, nativeProps);
          }
        };

        return ReactNativeComponent;
      }(React.Component);
    }(findNodeHandle, findHostInstance),
    findNodeHandle: findNodeHandle,
    dispatchCommand: function dispatchCommand(handle, command, args) {
      null != handle._nativeTag && ReactNativePrivateInterface.UIManager.dispatchViewManagerCommand(handle._nativeTag, command, args);
    },
    setNativeProps: function setNativeProps(handle, nativeProps) {
      null != handle._nativeTag && (nativeProps = diffProperties(null, emptyObject, nativeProps, handle.viewConfig.validAttributes), null != nativeProps && ReactNativePrivateInterface.UIManager.updateView(handle._nativeTag, handle.viewConfig.uiViewClassName, nativeProps));
    },
    render: function render(element, containerTag, callback) {
      var root = roots.get(containerTag);

      if (!root) {
        root = new FiberRootNode(containerTag, 0, !1);
        var uninitializedFiber = createFiber(3, null, null, 0);
        root.current = uninitializedFiber;
        uninitializedFiber.stateNode = root;
        roots.set(containerTag, root);
      }

      updateContainer(element, root, null, callback);

      a: if (element = root.current, element.child) switch (element.child.tag) {
        case 5:
          element = element.child.stateNode;
          break a;

        default:
          element = element.child.stateNode;
      } else element = null;

      return element;
    },
    unmountComponentAtNode: function unmountComponentAtNode(containerTag) {
      var root = roots.get(containerTag);
      root && updateContainer(null, root, null, function () {
        roots.delete(containerTag);
      });
    },
    unmountComponentAtNodeAndRemoveContainer: function unmountComponentAtNodeAndRemoveContainer(containerTag) {
      ReactNativeRenderer.unmountComponentAtNode(containerTag);
      ReactNativePrivateInterface.UIManager.removeRootView(containerTag);
    },
    createPortal: function createPortal(children, containerTag) {
      return _createPortal(children, containerTag, null, 2 < arguments.length && void 0 !== arguments[2] ? arguments[2] : null);
    },
    unstable_batchedUpdates: batchedUpdates,
    __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED: {
      NativeMethodsMixin: function (findNodeHandle, findHostInstance) {
        return {
          measure: function measure(callback) {
            var maybeInstance = void 0;

            try {
              maybeInstance = findHostInstance(this);
            } catch (error) {}

            null != maybeInstance && (maybeInstance.canonical ? nativeFabricUIManager.measure(maybeInstance.node, mountSafeCallback_NOT_REALLY_SAFE(this, callback)) : ReactNativePrivateInterface.UIManager.measure(findNodeHandle(this), mountSafeCallback_NOT_REALLY_SAFE(this, callback)));
          },
          measureInWindow: function measureInWindow(callback) {
            var maybeInstance = void 0;

            try {
              maybeInstance = findHostInstance(this);
            } catch (error) {}

            null != maybeInstance && (maybeInstance.canonical ? nativeFabricUIManager.measureInWindow(maybeInstance.node, mountSafeCallback_NOT_REALLY_SAFE(this, callback)) : ReactNativePrivateInterface.UIManager.measureInWindow(findNodeHandle(this), mountSafeCallback_NOT_REALLY_SAFE(this, callback)));
          },
          measureLayout: function measureLayout(relativeToNativeNode, onSuccess, onFail) {
            var maybeInstance = void 0;

            try {
              maybeInstance = findHostInstance(this);
            } catch (error) {}

            null == maybeInstance || maybeInstance.canonical || (maybeInstance = void 0, "number" === typeof relativeToNativeNode ? maybeInstance = relativeToNativeNode : relativeToNativeNode._nativeTag && (maybeInstance = relativeToNativeNode._nativeTag), null != maybeInstance && ReactNativePrivateInterface.UIManager.measureLayout(findNodeHandle(this), maybeInstance, mountSafeCallback_NOT_REALLY_SAFE(this, onFail), mountSafeCallback_NOT_REALLY_SAFE(this, onSuccess)));
          },
          setNativeProps: function setNativeProps(nativeProps) {
            var maybeInstance = void 0;

            try {
              maybeInstance = findHostInstance(this);
            } catch (error) {}

            if (null != maybeInstance && !maybeInstance.canonical) {
              var nativeTag = maybeInstance._nativeTag || maybeInstance.canonical._nativeTag;
              maybeInstance = maybeInstance.viewConfig || maybeInstance.canonical.viewConfig;
              nativeProps = diffProperties(null, emptyObject, nativeProps, maybeInstance.validAttributes);
              null != nativeProps && ReactNativePrivateInterface.UIManager.updateView(nativeTag, maybeInstance.uiViewClassName, nativeProps);
            }
          },
          focus: function focus() {
            ReactNativePrivateInterface.TextInputState.focusTextInput(findNodeHandle(this));
          },
          blur: function blur() {
            ReactNativePrivateInterface.TextInputState.blurTextInput(findNodeHandle(this));
          }
        };
      }(findNodeHandle, findHostInstance),
      computeComponentStackForErrorReporting: function computeComponentStackForErrorReporting(reactTag) {
        return (reactTag = getInstanceFromTag(reactTag)) ? getStackByFiberInDevAndProd(reactTag) : "";
      }
    }
  };

  (function (devToolsConfig) {
    var _findFiberByHostInstance = devToolsConfig.findFiberByHostInstance;
    return injectInternals(_extends({}, devToolsConfig, {
      overrideHookState: null,
      overrideProps: null,
      setSuspenseHandler: null,
      scheduleUpdate: null,
      currentDispatcherRef: ReactSharedInternals.ReactCurrentDispatcher,
      findHostInstanceByFiber: function findHostInstanceByFiber(fiber) {
        fiber = findCurrentHostFiber(fiber);
        return null === fiber ? null : fiber.stateNode;
      },
      findFiberByHostInstance: function findFiberByHostInstance(instance) {
        return _findFiberByHostInstance ? _findFiberByHostInstance(instance) : null;
      },
      findHostInstancesForRefresh: null,
      scheduleRefresh: null,
      scheduleRoot: null,
      setRefreshHandler: null,
      getCurrentFiber: null
    }));
  })({
    findFiberByHostInstance: getInstanceFromTag,
    getInspectorDataForViewTag: getInspectorDataForViewTag,
    bundleType: 0,
    version: "16.8.6",
    rendererPackageName: "react-native-renderer"
  });

  var ReactNativeRenderer$2 = {
    default: ReactNativeRenderer
  },
      ReactNativeRenderer$3 = ReactNativeRenderer$2 && ReactNativeRenderer || ReactNativeRenderer$2;
  module.exports = ReactNativeRenderer$3.default || ReactNativeRenderer$3;
},204,[13,90,192,54,198],"node_modules/react-native/Libraries/Renderer/implementations/ReactNativeRenderer-prod.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var ReactNativeViewViewConfigAndroid = {
    uiViewClassName: 'RCTView',
    bubblingEventTypes: {
      topSelect: {
        phasedRegistrationNames: {
          bubbled: 'onSelect',
          captured: 'onSelectCapture'
        }
      }
    },
    directEventTypes: {
      topClick: {
        registrationName: 'onClick'
      },
      topContentSizeChange: {
        registrationName: 'onContentSizeChange'
      },
      topLoadingError: {
        registrationName: 'onLoadingError'
      },
      topLoadingFinish: {
        registrationName: 'onLoadingFinish'
      },
      topLoadingStart: {
        registrationName: 'onLoadingStart'
      },
      topMessage: {
        registrationName: 'onMessage'
      },
      topMomentumScrollBegin: {
        registrationName: 'onMomentumScrollBegin'
      },
      topMomentumScrollEnd: {
        registrationName: 'onMomentumScrollEnd'
      },
      topScroll: {
        registrationName: 'onScroll'
      },
      topScrollBeginDrag: {
        registrationName: 'onScrollBeginDrag'
      },
      topScrollEndDrag: {
        registrationName: 'onScrollEndDrag'
      },
      topSelectionChange: {
        registrationName: 'onSelectionChange'
      }
    },
    validAttributes: {
      hasTVPreferredFocus: true,
      focusable: true,
      nativeBackgroundAndroid: true,
      nativeForegroundAndroid: true,
      nextFocusDown: true,
      nextFocusForward: true,
      nextFocusLeft: true,
      nextFocusRight: true,
      nextFocusUp: true
    }
  };
  module.exports = ReactNativeViewViewConfigAndroid;
},205,[],"node_modules/react-native/Libraries/Components/View/ReactNativeViewViewConfigAndroid.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _defineProperty2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/defineProperty"));

  var _verifyComponentAttributeEquivalence = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "./verifyComponentAttributeEquivalence"));

  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

  var ReactNativeViewConfigRegistry = _$$_REQUIRE(_dependencyMap[3], "../Renderer/shims/ReactNativeViewConfigRegistry");

  var ReactNativeViewViewConfig = _$$_REQUIRE(_dependencyMap[4], "../Components/View/ReactNativeViewViewConfig");

  function registerGeneratedViewConfig(componentName, viewConfig) {
    var mergedViewConfig = {
      uiViewClassName: componentName,
      Commands: {},
      bubblingEventTypes: _objectSpread({}, ReactNativeViewViewConfig.bubblingEventTypes, {}, viewConfig.bubblingEventTypes || {}),
      directEventTypes: _objectSpread({}, ReactNativeViewViewConfig.directEventTypes, {}, viewConfig.directEventTypes || {}),
      validAttributes: _objectSpread({}, ReactNativeViewViewConfig.validAttributes, {}, viewConfig.validAttributes || {})
    };
    ReactNativeViewConfigRegistry.register(componentName, function () {
      (0, _verifyComponentAttributeEquivalence.default)(componentName, mergedViewConfig);
      return mergedViewConfig;
    });
  }

  module.exports = registerGeneratedViewConfig;
},206,[1,46,207,194,208],"node_modules/react-native/Libraries/Utilities/registerGeneratedViewConfig.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.lefthandObjectDiff = lefthandObjectDiff;
  exports.getConfigWithoutViewProps = getConfigWithoutViewProps;
  exports.stringifyViewConfig = stringifyViewConfig;
  exports.default = void 0;

  var _ReactNativeViewViewConfig = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../Components/View/ReactNativeViewViewConfig"));

  var getNativeComponentAttributes = _$$_REQUIRE(_dependencyMap[2], "../ReactNative/getNativeComponentAttributes");

  var IGNORED_KEYS = ['transform', 'hitSlop'];

  function verifyComponentAttributeEquivalence(componentName, config) {
    if (__DEV__ && !global.RN$Bridgeless) {
      var nativeAttributes = getNativeComponentAttributes(componentName);
      ['validAttributes', 'bubblingEventTypes', 'directEventTypes'].forEach(function (prop) {
        var diffKeys = Object.keys(lefthandObjectDiff(nativeAttributes[prop], config[prop]));

        if (diffKeys.length) {
          console.error(componentName + " generated view config for " + prop + " does not match native, missing: " + diffKeys.join(' '));
        }
      });
    }
  }

  function lefthandObjectDiff(leftObj, rightObj) {
    var differentKeys = {};

    function compare(leftItem, rightItem, key) {
      if (typeof leftItem !== typeof rightItem && leftItem != null) {
        differentKeys[key] = rightItem;
        return;
      }

      if (typeof leftItem === 'object') {
        var objDiff = lefthandObjectDiff(leftItem, rightItem);

        if (Object.keys(objDiff).length > 1) {
          differentKeys[key] = objDiff;
        }

        return;
      }

      if (leftItem !== rightItem) {
        differentKeys[key] = rightItem;
        return;
      }
    }

    for (var key in leftObj) {
      if (IGNORED_KEYS.includes(key)) {
        continue;
      }

      if (!rightObj) {
        differentKeys[key] = {};
      } else if (leftObj.hasOwnProperty(key)) {
        compare(leftObj[key], rightObj[key], key);
      }
    }

    return differentKeys;
  }

  function getConfigWithoutViewProps(viewConfig, propName) {
    if (!viewConfig[propName]) {
      return {};
    }

    return Object.keys(viewConfig[propName]).filter(function (prop) {
      return !_ReactNativeViewViewConfig.default[propName][prop];
    }).reduce(function (obj, prop) {
      obj[prop] = viewConfig[propName][prop];
      return obj;
    }, {});
  }

  function stringifyViewConfig(viewConfig) {
    return JSON.stringify(viewConfig, function (key, val) {
      if (typeof val === 'function') {
        return "\u0192 " + val.name;
      }

      return val;
    }, 2);
  }

  var _default = verifyComponentAttributeEquivalence;
  exports.default = _default;
},207,[1,208,211],"node_modules/react-native/Libraries/Utilities/verifyComponentAttributeEquivalence.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _defineProperty2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/defineProperty"));

  var _ReactNativeViewViewConfigAndroid = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "./ReactNativeViewViewConfigAndroid"));

  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

  var ReactNativeViewConfig = {
    uiViewClassName: 'RCTView',
    baseModuleName: null,
    Manager: 'ViewManager',
    Commands: {},
    Constants: {},
    bubblingEventTypes: _objectSpread({}, _ReactNativeViewViewConfigAndroid.default.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'
        }
      },
      topPress: {
        phasedRegistrationNames: {
          bubbled: 'onPress',
          captured: 'onPressCapture'
        }
      },
      topSubmitEditing: {
        phasedRegistrationNames: {
          bubbled: 'onSubmitEditing',
          captured: 'onSubmitEditingCapture'
        }
      },
      topTouchCancel: {
        phasedRegistrationNames: {
          bubbled: 'onTouchCancel',
          captured: 'onTouchCancelCapture'
        }
      },
      topTouchEnd: {
        phasedRegistrationNames: {
          bubbled: 'onTouchEnd',
          captured: 'onTouchEndCapture'
        }
      },
      topTouchMove: {
        phasedRegistrationNames: {
          bubbled: 'onTouchMove',
          captured: 'onTouchMoveCapture'
        }
      },
      topTouchStart: {
        phasedRegistrationNames: {
          bubbled: 'onTouchStart',
          captured: 'onTouchStartCapture'
        }
      }
    }),
    directEventTypes: _objectSpread({}, _ReactNativeViewViewConfigAndroid.default.directEventTypes, {
      topAccessibilityAction: {
        registrationName: 'onAccessibilityAction'
      },
      topAccessibilityEscape: {
        registrationName: 'onAccessibilityEscape'
      },
      topAccessibilityTap: {
        registrationName: 'onAccessibilityTap'
      },
      topLayout: {
        registrationName: 'onLayout'
      },
      topMagicTap: {
        registrationName: 'onMagicTap'
      },
      onGestureHandlerEvent: {
        registrationName: 'onGestureHandlerEvent'
      },
      onGestureHandlerStateChange: {
        registrationName: 'onGestureHandlerStateChange'
      }
    }),
    validAttributes: _objectSpread({}, _ReactNativeViewViewConfigAndroid.default.validAttributes, {
      accessibilityActions: true,
      accessibilityElementsHidden: true,
      accessibilityHint: true,
      accessibilityIgnoresInvertColors: true,
      accessibilityLabel: true,
      accessibilityLiveRegion: true,
      accessibilityRole: true,
      accessibilityStates: true,
      accessibilityState: true,
      accessibilityViewIsModal: true,
      accessible: true,
      alignContent: true,
      alignItems: true,
      alignSelf: true,
      aspectRatio: true,
      backfaceVisibility: true,
      backgroundColor: {
        process: _$$_REQUIRE(_dependencyMap[3], "../../StyleSheet/processColor")
      },
      borderBottomColor: {
        process: _$$_REQUIRE(_dependencyMap[3], "../../StyleSheet/processColor")
      },
      borderBottomEndRadius: true,
      borderBottomLeftRadius: true,
      borderBottomRightRadius: true,
      borderBottomStartRadius: true,
      borderBottomWidth: true,
      borderColor: {
        process: _$$_REQUIRE(_dependencyMap[3], "../../StyleSheet/processColor")
      },
      borderEndColor: {
        process: _$$_REQUIRE(_dependencyMap[3], "../../StyleSheet/processColor")
      },
      borderEndWidth: true,
      borderLeftColor: {
        process: _$$_REQUIRE(_dependencyMap[3], "../../StyleSheet/processColor")
      },
      borderLeftWidth: true,
      borderRadius: true,
      borderRightColor: {
        process: _$$_REQUIRE(_dependencyMap[3], "../../StyleSheet/processColor")
      },
      borderRightWidth: true,
      borderStartColor: {
        process: _$$_REQUIRE(_dependencyMap[3], "../../StyleSheet/processColor")
      },
      borderStartWidth: true,
      borderStyle: true,
      borderTopColor: {
        process: _$$_REQUIRE(_dependencyMap[3], "../../StyleSheet/processColor")
      },
      borderTopEndRadius: true,
      borderTopLeftRadius: true,
      borderTopRightRadius: true,
      borderTopStartRadius: true,
      borderTopWidth: true,
      borderWidth: true,
      bottom: true,
      clickable: true,
      collapsable: true,
      direction: true,
      display: true,
      elevation: true,
      end: true,
      flex: true,
      flexBasis: true,
      flexDirection: true,
      flexGrow: true,
      flexShrink: true,
      flexWrap: true,
      height: true,
      hitSlop: {
        diff: _$$_REQUIRE(_dependencyMap[4], "../../Utilities/differ/insetsDiffer")
      },
      importantForAccessibility: true,
      justifyContent: true,
      left: true,
      margin: true,
      marginBottom: true,
      marginEnd: true,
      marginHorizontal: true,
      marginLeft: true,
      marginRight: true,
      marginStart: true,
      marginTop: true,
      marginVertical: true,
      maxHeight: true,
      maxWidth: true,
      minHeight: true,
      minWidth: true,
      nativeID: true,
      needsOffscreenAlphaCompositing: true,
      onAccessibilityAction: true,
      onAccessibilityEscape: true,
      onAccessibilityTap: true,
      onLayout: true,
      onMagicTap: true,
      opacity: true,
      overflow: true,
      padding: true,
      paddingBottom: true,
      paddingEnd: true,
      paddingHorizontal: true,
      paddingLeft: true,
      paddingRight: true,
      paddingStart: true,
      paddingTop: true,
      paddingVertical: true,
      pointerEvents: true,
      position: true,
      removeClippedSubviews: true,
      renderToHardwareTextureAndroid: true,
      right: true,
      rotation: true,
      scaleX: true,
      scaleY: true,
      shadowColor: {
        process: _$$_REQUIRE(_dependencyMap[3], "../../StyleSheet/processColor")
      },
      shadowOffset: {
        diff: _$$_REQUIRE(_dependencyMap[5], "../../Utilities/differ/sizesDiffer")
      },
      shadowOpacity: true,
      shadowRadius: true,
      shouldRasterizeIOS: true,
      start: true,
      style: {
        alignContent: true,
        alignItems: true,
        alignSelf: true,
        aspectRatio: true,
        backfaceVisibility: true,
        backgroundColor: {
          process: _$$_REQUIRE(_dependencyMap[3], "../../StyleSheet/processColor")
        },
        borderBottomColor: {
          process: _$$_REQUIRE(_dependencyMap[3], "../../StyleSheet/processColor")
        },
        borderBottomEndRadius: true,
        borderBottomLeftRadius: true,
        borderBottomRightRadius: true,
        borderBottomStartRadius: true,
        borderBottomWidth: true,
        borderColor: {
          process: _$$_REQUIRE(_dependencyMap[3], "../../StyleSheet/processColor")
        },
        borderEndColor: {
          process: _$$_REQUIRE(_dependencyMap[3], "../../StyleSheet/processColor")
        },
        borderEndWidth: true,
        borderLeftColor: {
          process: _$$_REQUIRE(_dependencyMap[3], "../../StyleSheet/processColor")
        },
        borderLeftWidth: true,
        borderRadius: true,
        borderRightColor: {
          process: _$$_REQUIRE(_dependencyMap[3], "../../StyleSheet/processColor")
        },
        borderRightWidth: true,
        borderStartColor: {
          process: _$$_REQUIRE(_dependencyMap[3], "../../StyleSheet/processColor")
        },
        borderStartWidth: true,
        borderStyle: true,
        borderTopColor: {
          process: _$$_REQUIRE(_dependencyMap[3], "../../StyleSheet/processColor")
        },
        borderTopEndRadius: true,
        borderTopLeftRadius: true,
        borderTopRightRadius: true,
        borderTopStartRadius: true,
        borderTopWidth: true,
        borderWidth: true,
        bottom: true,
        color: {
          process: _$$_REQUIRE(_dependencyMap[3], "../../StyleSheet/processColor")
        },
        decomposedMatrix: true,
        direction: true,
        display: true,
        elevation: true,
        end: true,
        flex: true,
        flexBasis: true,
        flexDirection: true,
        flexGrow: true,
        flexShrink: true,
        flexWrap: true,
        fontFamily: true,
        fontSize: true,
        fontStyle: true,
        fontVariant: true,
        fontWeight: true,
        height: true,
        includeFontPadding: true,
        justifyContent: true,
        left: true,
        letterSpacing: true,
        lineHeight: true,
        margin: true,
        marginBottom: true,
        marginEnd: true,
        marginHorizontal: true,
        marginLeft: true,
        marginRight: true,
        marginStart: true,
        marginTop: true,
        marginVertical: true,
        maxHeight: true,
        maxWidth: true,
        minHeight: true,
        minWidth: true,
        opacity: true,
        overflow: true,
        overlayColor: {
          process: _$$_REQUIRE(_dependencyMap[3], "../../StyleSheet/processColor")
        },
        padding: true,
        paddingBottom: true,
        paddingEnd: true,
        paddingHorizontal: true,
        paddingLeft: true,
        paddingRight: true,
        paddingStart: true,
        paddingTop: true,
        paddingVertical: true,
        position: true,
        resizeMode: true,
        right: true,
        rotation: true,
        scaleX: true,
        scaleY: true,
        shadowColor: {
          process: _$$_REQUIRE(_dependencyMap[3], "../../StyleSheet/processColor")
        },
        shadowOffset: {
          diff: _$$_REQUIRE(_dependencyMap[5], "../../Utilities/differ/sizesDiffer")
        },
        shadowOpacity: true,
        shadowRadius: true,
        start: true,
        textAlign: true,
        textAlignVertical: true,
        textDecorationColor: {
          process: _$$_REQUIRE(_dependencyMap[3], "../../StyleSheet/processColor")
        },
        textDecorationLine: true,
        textDecorationStyle: true,
        textShadowColor: {
          process: _$$_REQUIRE(_dependencyMap[3], "../../StyleSheet/processColor")
        },
        textShadowOffset: true,
        textShadowRadius: true,
        textTransform: true,
        tintColor: {
          process: _$$_REQUIRE(_dependencyMap[3], "../../StyleSheet/processColor")
        },
        top: true,
        transform: {
          diff: _$$_REQUIRE(_dependencyMap[6], "../../Utilities/differ/matricesDiffer")
        },
        transformMatrix: true,
        translateX: true,
        translateY: true,
        width: true,
        writingDirection: true,
        zIndex: true
      },
      testID: true,
      top: true,
      transform: {
        diff: _$$_REQUIRE(_dependencyMap[6], "../../Utilities/differ/matricesDiffer")
      },
      translateX: true,
      translateY: true,
      width: true,
      zIndex: true
    })
  };
  module.exports = ReactNativeViewConfig;
},208,[1,46,205,80,209,83,210],"node_modules/react-native/Libraries/Components/View/ReactNativeViewViewConfig.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var dummyInsets = {
    top: undefined,
    left: undefined,
    right: undefined,
    bottom: undefined
  };

  var insetsDiffer = function insetsDiffer(one, two) {
    one = one || dummyInsets;
    two = two || dummyInsets;
    return one !== two && (one.top !== two.top || one.left !== two.left || one.right !== two.right || one.bottom !== two.bottom);
  };

  module.exports = insetsDiffer;
},209,[],"node_modules/react-native/Libraries/Utilities/differ/insetsDiffer.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var matricesDiffer = function matricesDiffer(one, two) {
    if (one === two) {
      return false;
    }

    return !one || !two || one[12] !== two[12] || one[13] !== two[13] || one[14] !== two[14] || one[5] !== two[5] || one[10] !== two[10] || one[1] !== two[1] || one[2] !== two[2] || one[3] !== two[3] || one[4] !== two[4] || one[6] !== two[6] || one[7] !== two[7] || one[8] !== two[8] || one[9] !== two[9] || one[11] !== two[11] || one[15] !== two[15];
  };

  module.exports = matricesDiffer;
},210,[],"node_modules/react-native/Libraries/Utilities/differ/matricesDiffer.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");

  var _defineProperty = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/defineProperty");

  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

  var ReactNativeStyleAttributes = _$$_REQUIRE(_dependencyMap[2], "../Components/View/ReactNativeStyleAttributes");

  var UIManager = _$$_REQUIRE(_dependencyMap[3], "./UIManager");

  var insetsDiffer = _$$_REQUIRE(_dependencyMap[4], "../Utilities/differ/insetsDiffer");

  var invariant = _$$_REQUIRE(_dependencyMap[5], "invariant");

  var matricesDiffer = _$$_REQUIRE(_dependencyMap[6], "../Utilities/differ/matricesDiffer");

  var pointsDiffer = _$$_REQUIRE(_dependencyMap[7], "../Utilities/differ/pointsDiffer");

  var processColor = _$$_REQUIRE(_dependencyMap[8], "../StyleSheet/processColor");

  var processColorArray = _$$_REQUIRE(_dependencyMap[9], "../StyleSheet/processColorArray");

  var resolveAssetSource = _$$_REQUIRE(_dependencyMap[10], "../Image/resolveAssetSource");

  var sizesDiffer = _$$_REQUIRE(_dependencyMap[11], "../Utilities/differ/sizesDiffer");

  var warning = _$$_REQUIRE(_dependencyMap[12], "fbjs/lib/warning");

  function getNativeComponentAttributes(uiViewClassName) {
    var viewConfig = UIManager.getViewManagerConfig(uiViewClassName);
    invariant(viewConfig != null && viewConfig.NativeProps != null, 'requireNativeComponent: "%s" was not found in the UIManager.', uiViewClassName);
    var baseModuleName = viewConfig.baseModuleName,
        bubblingEventTypes = viewConfig.bubblingEventTypes,
        directEventTypes = viewConfig.directEventTypes;
    var nativeProps = viewConfig.NativeProps;

    while (baseModuleName) {
      var baseModule = UIManager.getViewManagerConfig(baseModuleName);

      if (!baseModule) {
        warning(false, 'Base module "%s" does not exist', baseModuleName);
        baseModuleName = null;
      } else {
        bubblingEventTypes = _objectSpread({}, baseModule.bubblingEventTypes, {}, bubblingEventTypes);
        directEventTypes = _objectSpread({}, baseModule.directEventTypes, {}, directEventTypes);
        nativeProps = _objectSpread({}, baseModule.NativeProps, {}, nativeProps);
        baseModuleName = baseModule.baseModuleName;
      }
    }

    var validAttributes = {};

    for (var key in nativeProps) {
      var typeName = nativeProps[key];
      var diff = getDifferForType(typeName);
      var process = getProcessorForType(typeName);
      validAttributes[key] = diff == null && process == null ? true : {
        diff: diff,
        process: process
      };
    }

    validAttributes.style = ReactNativeStyleAttributes;

    _extends(viewConfig, {
      uiViewClassName: uiViewClassName,
      validAttributes: validAttributes,
      bubblingEventTypes: bubblingEventTypes,
      directEventTypes: directEventTypes
    });

    if (!hasAttachedDefaultEventTypes) {
      attachDefaultEventTypes(viewConfig);
      hasAttachedDefaultEventTypes = true;
    }

    return viewConfig;
  }

  var hasAttachedDefaultEventTypes = false;

  function attachDefaultEventTypes(viewConfig) {
    var constants = UIManager.getConstants();

    if (constants.ViewManagerNames || constants.LazyViewManagersEnabled) {
      viewConfig = merge(viewConfig, UIManager.getDefaultEventTypes());
    } else {
      viewConfig.bubblingEventTypes = merge(viewConfig.bubblingEventTypes, constants.genericBubblingEventTypes);
      viewConfig.directEventTypes = merge(viewConfig.directEventTypes, constants.genericDirectEventTypes);
    }
  }

  function merge(destination, source) {
    if (!source) {
      return destination;
    }

    if (!destination) {
      return source;
    }

    for (var key in source) {
      if (!source.hasOwnProperty(key)) {
        continue;
      }

      var sourceValue = source[key];

      if (destination.hasOwnProperty(key)) {
        var destinationValue = destination[key];

        if (typeof sourceValue === 'object' && typeof destinationValue === 'object') {
          sourceValue = merge(destinationValue, sourceValue);
        }
      }

      destination[key] = sourceValue;
    }

    return destination;
  }

  function getDifferForType(typeName) {
    switch (typeName) {
      case 'CATransform3D':
        return matricesDiffer;

      case 'CGPoint':
        return pointsDiffer;

      case 'CGSize':
        return sizesDiffer;

      case 'UIEdgeInsets':
        return insetsDiffer;
    }

    return null;
  }

  function getProcessorForType(typeName) {
    switch (typeName) {
      case 'CGColor':
      case 'UIColor':
        return processColor;

      case 'CGColorArray':
      case 'UIColorArray':
        return processColorArray;

      case 'CGImage':
      case 'UIImage':
      case 'RCTImageSource':
        return resolveAssetSource;

      case 'Color':
        return processColor;

      case 'ColorArray':
        return processColorArray;
    }

    return null;
  }

  module.exports = getNativeComponentAttributes;
},211,[13,46,64,43,209,3,210,212,80,213,214,83,5],"node_modules/react-native/Libraries/ReactNative/getNativeComponentAttributes.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var dummyPoint = {
    x: undefined,
    y: undefined
  };

  var pointsDiffer = function pointsDiffer(one, two) {
    one = one || dummyPoint;
    two = two || dummyPoint;
    return one !== two && (one.x !== two.x || one.y !== two.y);
  };

  module.exports = pointsDiffer;
},212,[],"node_modules/react-native/Libraries/Utilities/differ/pointsDiffer.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var processColor = _$$_REQUIRE(_dependencyMap[0], "./processColor");

  function processColorArray(colors) {
    return colors == null ? null : colors.map(processColor);
  }

  module.exports = processColorArray;
},213,[80],"node_modules/react-native/Libraries/StyleSheet/processColorArray.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var AssetRegistry = _$$_REQUIRE(_dependencyMap[0], "./AssetRegistry");

  var AssetSourceResolver = _$$_REQUIRE(_dependencyMap[1], "./AssetSourceResolver");

  var _customSourceTransformer, _serverURL, _scriptURL;

  var _sourceCodeScriptURL;

  function getSourceCodeScriptURL() {
    if (_sourceCodeScriptURL) {
      return _sourceCodeScriptURL;
    }

    var sourceCode = global.nativeExtensions && global.nativeExtensions.SourceCode;

    if (!sourceCode) {
      sourceCode = _$$_REQUIRE(_dependencyMap[2], "../NativeModules/specs/NativeSourceCode").default;
    }

    _sourceCodeScriptURL = sourceCode.getConstants().scriptURL;
    return _sourceCodeScriptURL;
  }

  function getDevServerURL() {
    if (_serverURL === undefined) {
      var sourceCodeScriptURL = getSourceCodeScriptURL();
      var match = sourceCodeScriptURL && sourceCodeScriptURL.match(/^https?:\/\/.*?\//);

      if (match) {
        _serverURL = match[0];
      } else {
        _serverURL = null;
      }
    }

    return _serverURL;
  }

  function _coerceLocalScriptURL(scriptURL) {
    if (scriptURL) {
      if (scriptURL.startsWith('assets://')) {
        return null;
      }

      scriptURL = scriptURL.substring(0, scriptURL.lastIndexOf('/') + 1);

      if (!scriptURL.includes('://')) {
        scriptURL = 'file://' + scriptURL;
      }
    }

    return scriptURL;
  }

  function getScriptURL() {
    if (_scriptURL === undefined) {
      _scriptURL = _coerceLocalScriptURL(getSourceCodeScriptURL());
    }

    return _scriptURL;
  }

  function setCustomSourceTransformer(transformer) {
    _customSourceTransformer = transformer;
  }

  function resolveAssetSource(source) {
    if (typeof source === 'object') {
      return source;
    }

    var asset = AssetRegistry.getAssetByID(source);

    if (!asset) {
      return null;
    }

    var resolver = new AssetSourceResolver(getDevServerURL(), getScriptURL(), asset);

    if (_customSourceTransformer) {
      return _customSourceTransformer(resolver);
    }

    return resolver.defaultAsset();
  }

  module.exports = resolveAssetSource;
  module.exports.pickScale = AssetSourceResolver.pickScale;
  module.exports.setCustomSourceTransformer = setCustomSourceTransformer;
},214,[215,216,105],"node_modules/react-native/Libraries/Image/resolveAssetSource.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var assets = [];

  function registerAsset(asset) {
    return assets.push(asset);
  }

  function getAssetByID(assetId) {
    return assets[assetId - 1];
  }

  module.exports = {
    registerAsset: registerAsset,
    getAssetByID: getAssetByID
  };
},215,[],"node_modules/react-native/Libraries/Image/AssetRegistry.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");

  var PixelRatio = _$$_REQUIRE(_dependencyMap[2], "../Utilities/PixelRatio");

  var Platform = _$$_REQUIRE(_dependencyMap[3], "../Utilities/Platform");

  var assetPathUtils = _$$_REQUIRE(_dependencyMap[4], "./assetPathUtils");

  var invariant = _$$_REQUIRE(_dependencyMap[5], "invariant");

  function getScaledAssetPath(asset) {
    var scale = AssetSourceResolver.pickScale(asset.scales, PixelRatio.get());
    var scaleSuffix = scale === 1 ? '' : '@' + scale + 'x';
    var assetDir = assetPathUtils.getBasePath(asset);
    return assetDir + '/' + asset.name + scaleSuffix + '.' + asset.type;
  }

  function getAssetPathInDrawableFolder(asset) {
    var scale = AssetSourceResolver.pickScale(asset.scales, PixelRatio.get());
    var drawbleFolder = assetPathUtils.getAndroidResourceFolderName(asset, scale);
    var fileName = assetPathUtils.getAndroidResourceIdentifier(asset);
    return drawbleFolder + '/' + fileName + '.' + asset.type;
  }

  var AssetSourceResolver = function () {
    function AssetSourceResolver(serverUrl, jsbundleUrl, asset) {
      _classCallCheck(this, AssetSourceResolver);

      this.serverUrl = serverUrl;
      this.jsbundleUrl = jsbundleUrl;
      this.asset = asset;
    }

    _createClass(AssetSourceResolver, [{
      key: "isLoadedFromServer",
      value: function isLoadedFromServer() {
        return !!this.serverUrl;
      }
    }, {
      key: "isLoadedFromFileSystem",
      value: function isLoadedFromFileSystem() {
        return !!(this.jsbundleUrl && this.jsbundleUrl.startsWith('file://'));
      }
    }, {
      key: "defaultAsset",
      value: function defaultAsset() {
        if (this.isLoadedFromServer()) {
          return this.assetServerURL();
        }

        if ("android" === 'android') {
          return this.isLoadedFromFileSystem() ? this.drawableFolderInBundle() : this.resourceIdentifierWithoutScale();
        } else {
          return this.scaledAssetURLNearBundle();
        }
      }
    }, {
      key: "assetServerURL",
      value: function assetServerURL() {
        invariant(!!this.serverUrl, 'need server to load from');
        return this.fromSource(this.serverUrl + getScaledAssetPath(this.asset) + '?platform=' + "android" + '&hash=' + this.asset.hash);
      }
    }, {
      key: "scaledAssetPath",
      value: function scaledAssetPath() {
        return this.fromSource(getScaledAssetPath(this.asset));
      }
    }, {
      key: "scaledAssetURLNearBundle",
      value: function scaledAssetURLNearBundle() {
        var path = this.jsbundleUrl || 'file://';
        return this.fromSource(path + getScaledAssetPath(this.asset));
      }
    }, {
      key: "resourceIdentifierWithoutScale",
      value: function resourceIdentifierWithoutScale() {
        invariant("android" === 'android', 'resource identifiers work on Android');
        return this.fromSource(assetPathUtils.getAndroidResourceIdentifier(this.asset));
      }
    }, {
      key: "drawableFolderInBundle",
      value: function drawableFolderInBundle() {
        var path = this.jsbundleUrl || 'file://';
        return this.fromSource(path + getAssetPathInDrawableFolder(this.asset));
      }
    }, {
      key: "fromSource",
      value: function fromSource(source) {
        return {
          __packager_asset: true,
          width: this.asset.width,
          height: this.asset.height,
          uri: source,
          scale: AssetSourceResolver.pickScale(this.asset.scales, PixelRatio.get())
        };
      }
    }], [{
      key: "pickScale",
      value: function pickScale(scales, deviceScale) {
        for (var i = 0; i < scales.length; i++) {
          if (scales[i] >= deviceScale) {
            return scales[i];
          }
        }

        return scales[scales.length - 1] || 1;
      }
    }]);

    return AssetSourceResolver;
  }();

  module.exports = AssetSourceResolver;
},216,[24,25,61,48,217,3],"node_modules/react-native/Libraries/Image/AssetSourceResolver.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var androidScaleSuffix = {
    '0.75': 'ldpi',
    '1': 'mdpi',
    '1.5': 'hdpi',
    '2': 'xhdpi',
    '3': 'xxhdpi',
    '4': 'xxxhdpi'
  };

  function getAndroidAssetSuffix(scale) {
    if (scale.toString() in androidScaleSuffix) {
      return androidScaleSuffix[scale.toString()];
    }

    throw new Error('no such scale ' + scale.toString());
  }

  var drawableFileTypes = new Set(['gif', 'jpeg', 'jpg', 'png', 'svg', 'webp', 'xml']);

  function getAndroidResourceFolderName(asset, scale) {
    if (!drawableFileTypes.has(asset.type)) {
      return 'raw';
    }

    var suffix = getAndroidAssetSuffix(scale);

    if (!suffix) {
      throw new Error("Don't know which android drawable suffix to use for scale: " + scale + '\nAsset: ' + JSON.stringify(asset, null, '\t') + '\nPossible scales are:' + JSON.stringify(androidScaleSuffix, null, '\t'));
    }

    var androidFolder = 'drawable-' + suffix;
    return androidFolder;
  }

  function getAndroidResourceIdentifier(asset) {
    var folderPath = getBasePath(asset);
    return (folderPath + '/' + asset.name).toLowerCase().replace(/\//g, '_').replace(/([^a-z0-9_])/g, '').replace(/^assets_/, '');
  }

  function getBasePath(asset) {
    var basePath = asset.httpServerLocation;

    if (basePath[0] === '/') {
      basePath = basePath.substr(1);
    }

    return basePath;
  }

  module.exports = {
    getAndroidAssetSuffix: getAndroidAssetSuffix,
    getAndroidResourceFolderName: getAndroidResourceFolderName,
    getAndroidResourceIdentifier: getAndroidResourceIdentifier,
    getBasePath: getBasePath
  };
},217,[],"node_modules/react-native/Libraries/Image/assetPathUtils.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var createReactNativeComponentClass = _$$_REQUIRE(_dependencyMap[0], "../Renderer/shims/createReactNativeComponentClass");

  var getNativeComponentAttributes = _$$_REQUIRE(_dependencyMap[1], "./getNativeComponentAttributes");

  var requireNativeComponent = function requireNativeComponent(uiViewClassName) {
    return createReactNativeComponentClass(uiViewClassName, function () {
      return getNativeComponentAttributes(uiViewClassName);
    });
  };

  module.exports = requireNativeComponent;
},218,[219,211],"node_modules/react-native/Libraries/ReactNative/requireNativeComponent.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _ReactNativePrivateInterface = _$$_REQUIRE(_dependencyMap[0], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface");

  var register = _ReactNativePrivateInterface.ReactNativeViewConfigRegistry.register;

  var createReactNativeComponentClass = function createReactNativeComponentClass(name, callback) {
    return register(name, callback);
  };

  module.exports = createReactNativeComponentClass;
},219,[192],"node_modules/react-native/Libraries/Renderer/shims/createReactNativeComponentClass.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _extends2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/extends"));

  var _ProgressBarAndroidNativeComponent = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "./ProgressBarAndroidNativeComponent"));

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native/Libraries/Components/ProgressBarAndroid/ProgressBarAndroid.android.js";

  var React = _$$_REQUIRE(_dependencyMap[3], "react");

  var ProgressBarAndroid = function ProgressBarAndroid(props, forwardedRef) {
    return React.createElement(_ProgressBarAndroidNativeComponent.default, (0, _extends2.default)({}, props, {
      ref: forwardedRef,
      __source: {
        fileName: _jsxFileName,
        lineNumber: 86
      }
    }));
  };

  var ProgressBarAndroidToExport = React.forwardRef(ProgressBarAndroid);
  ProgressBarAndroidToExport.defaultProps = {
    styleAttr: 'Normal',
    indeterminate: true,
    animating: true
  };
  module.exports = ProgressBarAndroidToExport;
},220,[1,13,221,54],"node_modules/react-native/Libraries/Components/ProgressBarAndroid/ProgressBarAndroid.android.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _codegenNativeComponent = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../../Utilities/codegenNativeComponent"));

  var _default = (0, _codegenNativeComponent.default)('AndroidProgressBar');

  exports.default = _default;
},221,[1,222],"node_modules/react-native/Libraries/Components/ProgressBarAndroid/ProgressBarAndroidNativeComponent.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _requireNativeComponent = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../../Libraries/ReactNative/requireNativeComponent"));

  var _reactNative = _$$_REQUIRE(_dependencyMap[2], "react-native");

  function codegenNativeComponent(componentName, options) {
    var componentNameInUse = options && options.paperComponentName ? options.paperComponentName : componentName;

    if (options != null && options.paperComponentNameDeprecated != null) {
      if (_reactNative.UIManager.getViewManagerConfig(componentName)) {
        componentNameInUse = componentName;
      } else if (options.paperComponentNameDeprecated != null && _reactNative.UIManager.getViewManagerConfig(options.paperComponentNameDeprecated)) {
        componentNameInUse = options.paperComponentNameDeprecated;
      } else {
        throw new Error("Failed to find native component for either " + componentName + " or " + (options.paperComponentNameDeprecated || '(unknown)'));
      }
    }

    return (0, _requireNativeComponent.default)(componentNameInUse);
  }

  var _default = codegenNativeComponent;
  exports.default = _default;
},222,[1,218,2],"node_modules/react-native/Libraries/Utilities/codegenNativeComponent.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _codegenNativeComponent = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../../Utilities/codegenNativeComponent"));

  var _default = (0, _codegenNativeComponent.default)('ActivityIndicatorView', {
    paperComponentName: 'RCTActivityIndicatorView'
  });

  exports.default = _default;
},223,[1,222],"node_modules/react-native/Libraries/Components/ActivityIndicator/ActivityIndicatorViewNativeComponent.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");

  var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");

  var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");

  var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native/Libraries/ART/ReactNativeART.js";

  var Color = _$$_REQUIRE(_dependencyMap[5], "art/core/color");

  var Path = _$$_REQUIRE(_dependencyMap[6], "./ARTSerializablePath");

  var Transform = _$$_REQUIRE(_dependencyMap[7], "art/core/transform");

  var React = _$$_REQUIRE(_dependencyMap[8], "react");

  var PropTypes = _$$_REQUIRE(_dependencyMap[9], "prop-types");

  var ReactNativeViewAttributes = _$$_REQUIRE(_dependencyMap[10], "../Components/View/ReactNativeViewAttributes");

  var createReactNativeComponentClass = _$$_REQUIRE(_dependencyMap[11], "../Renderer/shims/createReactNativeComponentClass");

  var merge = _$$_REQUIRE(_dependencyMap[12], "../vendor/core/merge");

  var invariant = _$$_REQUIRE(_dependencyMap[13], "invariant");

  function arrayDiffer(a, b) {
    if (a == null || b == null) {
      return true;
    }

    if (a.length !== b.length) {
      return true;
    }

    for (var i = 0; i < a.length; i++) {
      if (a[i] !== b[i]) {
        return true;
      }
    }

    return false;
  }

  function fontAndLinesDiffer(a, b) {
    if (a === b) {
      return false;
    }

    if (a.font !== b.font) {
      if (a.font === null) {
        return true;
      }

      if (b.font === null) {
        return true;
      }

      if (a.font.fontFamily !== b.font.fontFamily || a.font.fontSize !== b.font.fontSize || a.font.fontWeight !== b.font.fontWeight || a.font.fontStyle !== b.font.fontStyle) {
        return true;
      }
    }

    return arrayDiffer(a.lines, b.lines);
  }

  var SurfaceViewAttributes = merge(ReactNativeViewAttributes.UIView, {});
  var NodeAttributes = {
    transform: {
      diff: arrayDiffer
    },
    opacity: true
  };
  var GroupAttributes = merge(NodeAttributes, {
    clipping: {
      diff: arrayDiffer
    }
  });
  var RenderableAttributes = merge(NodeAttributes, {
    fill: {
      diff: arrayDiffer
    },
    stroke: {
      diff: arrayDiffer
    },
    strokeWidth: true,
    strokeCap: true,
    strokeJoin: true,
    strokeDash: {
      diff: arrayDiffer
    }
  });
  var ShapeAttributes = merge(RenderableAttributes, {
    d: {
      diff: arrayDiffer
    }
  });
  var TextAttributes = merge(RenderableAttributes, {
    alignment: true,
    frame: {
      diff: fontAndLinesDiffer
    },
    path: {
      diff: arrayDiffer
    }
  });
  var NativeSurfaceView = createReactNativeComponentClass('ARTSurfaceView', function () {
    return {
      validAttributes: SurfaceViewAttributes,
      uiViewClassName: 'ARTSurfaceView'
    };
  });
  var NativeGroup = createReactNativeComponentClass('ARTGroup', function () {
    return {
      validAttributes: GroupAttributes,
      uiViewClassName: 'ARTGroup'
    };
  });
  var NativeShape = createReactNativeComponentClass('ARTShape', function () {
    return {
      validAttributes: ShapeAttributes,
      uiViewClassName: 'ARTShape'
    };
  });
  var NativeText = createReactNativeComponentClass('ARTText', function () {
    return {
      validAttributes: TextAttributes,
      uiViewClassName: 'ARTText'
    };
  });

  function childrenAsString(children) {
    if (!children) {
      return '';
    }

    if (typeof children === 'string') {
      return children;
    }

    if (children.length) {
      return children.join('\n');
    }

    return '';
  }

  var Surface = function (_React$Component) {
    _inherits(Surface, _React$Component);

    function Surface() {
      _classCallCheck(this, Surface);

      return _possibleConstructorReturn(this, _getPrototypeOf(Surface).apply(this, arguments));
    }

    _createClass(Surface, [{
      key: "getChildContext",
      value: function getChildContext() {
        return {
          isInSurface: true
        };
      }
    }, {
      key: "render",
      value: function render() {
        var height = extractNumber(this.props.height, 0);
        var width = extractNumber(this.props.width, 0);
        return React.createElement(NativeSurfaceView, {
          style: [this.props.style, {
            height: height,
            width: width
          }],
          __source: {
            fileName: _jsxFileName,
            lineNumber: 157
          }
        }, this.props.children);
      }
    }]);

    return Surface;
  }(React.Component);

  Surface.childContextTypes = {
    isInSurface: PropTypes.bool
  };

  function extractNumber(value, defaultValue) {
    if (value == null) {
      return defaultValue;
    }

    return +value;
  }

  var pooledTransform = new Transform();

  function extractTransform(props) {
    var scaleX = props.scaleX != null ? props.scaleX : props.scale != null ? props.scale : 1;
    var scaleY = props.scaleY != null ? props.scaleY : props.scale != null ? props.scale : 1;
    pooledTransform.transformTo(1, 0, 0, 1, 0, 0).move(props.x || 0, props.y || 0).rotate(props.rotation || 0, props.originX, props.originY).scale(scaleX, scaleY, props.originX, props.originY);

    if (props.transform != null) {
      pooledTransform.transform(props.transform);
    }

    return [pooledTransform.xx, pooledTransform.yx, pooledTransform.xy, pooledTransform.yy, pooledTransform.x, pooledTransform.y];
  }

  function extractOpacity(props) {
    if (props.visible === false) {
      return 0;
    }

    if (props.opacity == null) {
      return 1;
    }

    return +props.opacity;
  }

  var Group = function (_React$Component2) {
    _inherits(Group, _React$Component2);

    function Group() {
      _classCallCheck(this, Group);

      return _possibleConstructorReturn(this, _getPrototypeOf(Group).apply(this, arguments));
    }

    _createClass(Group, [{
      key: "render",
      value: function render() {
        var props = this.props;
        invariant(this.context.isInSurface, 'ART: <Group /> must be a child of a <Surface />');
        return React.createElement(NativeGroup, {
          opacity: extractOpacity(props),
          transform: extractTransform(props),
          __source: {
            fileName: _jsxFileName,
            lineNumber: 232
          }
        }, this.props.children);
      }
    }]);

    return Group;
  }(React.Component);

  Group.contextTypes = {
    isInSurface: PropTypes.bool.isRequired
  };

  var ClippingRectangle = function (_React$Component3) {
    _inherits(ClippingRectangle, _React$Component3);

    function ClippingRectangle() {
      _classCallCheck(this, ClippingRectangle);

      return _possibleConstructorReturn(this, _getPrototypeOf(ClippingRectangle).apply(this, arguments));
    }

    _createClass(ClippingRectangle, [{
      key: "render",
      value: function render() {
        var props = this.props;
        var x = extractNumber(props.x, 0);
        var y = extractNumber(props.y, 0);
        var w = extractNumber(props.width, 0);
        var h = extractNumber(props.height, 0);
        var clipping = [x, y, w, h];
        var propsExcludingXAndY = merge(props);
        delete propsExcludingXAndY.x;
        delete propsExcludingXAndY.y;
        return React.createElement(NativeGroup, {
          clipping: clipping,
          opacity: extractOpacity(props),
          transform: extractTransform(propsExcludingXAndY),
          __source: {
            fileName: _jsxFileName,
            lineNumber: 254
          }
        }, this.props.children);
      }
    }]);

    return ClippingRectangle;
  }(React.Component);

  var SOLID_COLOR = 0;
  var LINEAR_GRADIENT = 1;
  var RADIAL_GRADIENT = 2;
  var PATTERN = 3;

  function insertColorIntoArray(color, targetArray, atIndex) {
    var c = new Color(color);
    targetArray[atIndex + 0] = c.red / 255;
    targetArray[atIndex + 1] = c.green / 255;
    targetArray[atIndex + 2] = c.blue / 255;
    targetArray[atIndex + 3] = c.alpha;
  }

  function insertColorsIntoArray(stops, targetArray, atIndex) {
    var i = 0;

    if ('length' in stops) {
      while (i < stops.length) {
        insertColorIntoArray(stops[i], targetArray, atIndex + i * 4);
        i++;
      }
    } else {
      for (var offset in stops) {
        insertColorIntoArray(stops[offset], targetArray, atIndex + i * 4);
        i++;
      }
    }

    return atIndex + i * 4;
  }

  function insertOffsetsIntoArray(stops, targetArray, atIndex, multi, reverse) {
    var offsetNumber;
    var i = 0;

    if ('length' in stops) {
      while (i < stops.length) {
        offsetNumber = i / (stops.length - 1) * multi;
        targetArray[atIndex + i] = reverse ? 1 - offsetNumber : offsetNumber;
        i++;
      }
    } else {
      for (var offsetString in stops) {
        offsetNumber = +offsetString * multi;
        targetArray[atIndex + i] = reverse ? 1 - offsetNumber : offsetNumber;
        i++;
      }
    }

    return atIndex + i;
  }

  function insertColorStopsIntoArray(stops, targetArray, atIndex) {
    var lastIndex = insertColorsIntoArray(stops, targetArray, atIndex);
    insertOffsetsIntoArray(stops, targetArray, lastIndex, 1, false);
  }

  function insertDoubleColorStopsIntoArray(stops, targetArray, atIndex) {
    var lastIndex = insertColorsIntoArray(stops, targetArray, atIndex);
    lastIndex = insertColorsIntoArray(stops, targetArray, lastIndex);
    lastIndex = insertOffsetsIntoArray(stops, targetArray, lastIndex, 0.5, false);
    insertOffsetsIntoArray(stops, targetArray, lastIndex, 0.5, true);
  }

  function applyBoundingBoxToBrushData(brushData, props) {
    var type = brushData[0];
    var width = +props.width;
    var height = +props.height;

    if (type === LINEAR_GRADIENT) {
      brushData[1] *= width;
      brushData[2] *= height;
      brushData[3] *= width;
      brushData[4] *= height;
    } else if (type === RADIAL_GRADIENT) {
      brushData[1] *= width;
      brushData[2] *= height;
      brushData[3] *= width;
      brushData[4] *= height;
      brushData[5] *= width;
      brushData[6] *= height;
    } else if (type === PATTERN) {}
  }

  function extractBrush(colorOrBrush, props) {
    if (colorOrBrush == null) {
      return null;
    }

    if (colorOrBrush._brush) {
      if (colorOrBrush._bb) {
        applyBoundingBoxToBrushData(colorOrBrush._brush, props);
        colorOrBrush._bb = false;
      }

      return colorOrBrush._brush;
    }

    var c = new Color(colorOrBrush);
    return [SOLID_COLOR, c.red / 255, c.green / 255, c.blue / 255, c.alpha];
  }

  function extractColor(color) {
    if (color == null) {
      return null;
    }

    var c = new Color(color);
    return [c.red / 255, c.green / 255, c.blue / 255, c.alpha];
  }

  function extractStrokeCap(strokeCap) {
    switch (strokeCap) {
      case 'butt':
        return 0;

      case 'square':
        return 2;

      default:
        return 1;
    }
  }

  function extractStrokeJoin(strokeJoin) {
    switch (strokeJoin) {
      case 'miter':
        return 0;

      case 'bevel':
        return 2;

      default:
        return 1;
    }
  }

  var Shape = function (_React$Component4) {
    _inherits(Shape, _React$Component4);

    function Shape() {
      _classCallCheck(this, Shape);

      return _possibleConstructorReturn(this, _getPrototypeOf(Shape).apply(this, arguments));
    }

    _createClass(Shape, [{
      key: "render",
      value: function render() {
        var props = this.props;
        var path = props.d || childrenAsString(props.children);
        var d = (path instanceof Path ? path : new Path(path)).toJSON();
        return React.createElement(NativeShape, {
          fill: extractBrush(props.fill, props),
          opacity: extractOpacity(props),
          stroke: extractColor(props.stroke),
          strokeCap: extractStrokeCap(props.strokeCap),
          strokeDash: props.strokeDash || null,
          strokeJoin: extractStrokeJoin(props.strokeJoin),
          strokeWidth: extractNumber(props.strokeWidth, 1),
          transform: extractTransform(props),
          d: d,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 420
          }
        });
      }
    }]);

    return Shape;
  }(React.Component);

  var cachedFontObjectsFromString = {};
  var fontFamilyPrefix = /^[\s"']*/;
  var fontFamilySuffix = /[\s"']*$/;

  function extractSingleFontFamily(fontFamilyString) {
    return fontFamilyString.split(',')[0].replace(fontFamilyPrefix, '').replace(fontFamilySuffix, '');
  }

  function parseFontString(font) {
    if (cachedFontObjectsFromString.hasOwnProperty(font)) {
      return cachedFontObjectsFromString[font];
    }

    var regexp = /^\s*((?:(?:normal|bold|italic)\s+)*)(?:(\d+(?:\.\d+)?)[ptexm\%]*(?:\s*\/.*?)?\s+)?\s*\"?([^\"]*)/i;
    var match = regexp.exec(font);

    if (!match) {
      return null;
    }

    var fontFamily = extractSingleFontFamily(match[3]);
    var fontSize = +match[2] || 12;
    var isBold = /bold/.exec(match[1]);
    var isItalic = /italic/.exec(match[1]);
    cachedFontObjectsFromString[font] = {
      fontFamily: fontFamily,
      fontSize: fontSize,
      fontWeight: isBold ? 'bold' : 'normal',
      fontStyle: isItalic ? 'italic' : 'normal'
    };
    return cachedFontObjectsFromString[font];
  }

  function extractFont(font) {
    if (font == null) {
      return null;
    }

    if (typeof font === 'string') {
      return parseFontString(font);
    }

    var fontFamily = extractSingleFontFamily(font.fontFamily);
    var fontSize = +font.fontSize || 12;
    var fontWeight = font.fontWeight != null ? font.fontWeight.toString() : '400';
    return {
      fontFamily: fontFamily,
      fontSize: fontSize,
      fontWeight: fontWeight,
      fontStyle: font.fontStyle
    };
  }

  var newLine = /\n/g;

  function extractFontAndLines(font, text) {
    return {
      font: extractFont(font),
      lines: text.split(newLine)
    };
  }

  function extractAlignment(alignment) {
    switch (alignment) {
      case 'right':
        return 1;

      case 'center':
        return 2;

      default:
        return 0;
    }
  }

  var Text = function (_React$Component5) {
    _inherits(Text, _React$Component5);

    function Text() {
      _classCallCheck(this, Text);

      return _possibleConstructorReturn(this, _getPrototypeOf(Text).apply(this, arguments));
    }

    _createClass(Text, [{
      key: "render",
      value: function render() {
        var props = this.props;
        var path = props.path;
        var textPath = path ? (path instanceof Path ? path : new Path(path)).toJSON() : null;
        var textFrame = extractFontAndLines(props.font, childrenAsString(props.children));
        return React.createElement(NativeText, {
          fill: extractBrush(props.fill, props),
          opacity: extractOpacity(props),
          stroke: extractColor(props.stroke),
          strokeCap: extractStrokeCap(props.strokeCap),
          strokeDash: props.strokeDash || null,
          strokeJoin: extractStrokeJoin(props.strokeJoin),
          strokeWidth: extractNumber(props.strokeWidth, 1),
          transform: extractTransform(props),
          alignment: extractAlignment(props.alignment),
          frame: textFrame,
          path: textPath,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 522
          }
        });
      }
    }]);

    return Text;
  }(React.Component);

  function LinearGradient(stops, x1, y1, x2, y2) {
    var type = LINEAR_GRADIENT;

    if (arguments.length < 5) {
      var angle = (x1 == null ? 270 : x1) * Math.PI / 180;
      var x = Math.cos(angle);
      var y = -Math.sin(angle);
      var l = (Math.abs(x) + Math.abs(y)) / 2;
      x *= l;
      y *= l;
      x1 = 0.5 - x;
      x2 = 0.5 + x;
      y1 = 0.5 - y;
      y2 = 0.5 + y;
      this._bb = true;
    } else {
      this._bb = false;
    }

    var brushData = [type, +x1, +y1, +x2, +y2];
    insertColorStopsIntoArray(stops, brushData, 5);
    this._brush = brushData;
  }

  function RadialGradient(stops, fx, fy, rx, ry, cx, cy) {
    if (ry == null) {
      ry = rx;
    }

    if (cx == null) {
      cx = fx;
    }

    if (cy == null) {
      cy = fy;
    }

    if (fx == null) {
      fx = fy = rx = ry = cx = cy = 0.5;
      this._bb = true;
    } else {
      this._bb = false;
    }

    var brushData = [RADIAL_GRADIENT, +fx, +fy, +rx * 2, +ry * 2, +cx, +cy];
    insertDoubleColorStopsIntoArray(stops, brushData, 7);
    this._brush = brushData;
  }

  function Pattern(url, width, height, left, top) {
    this._brush = [PATTERN, url, +left || 0, +top || 0, +width, +height];
  }

  var ReactART = {
    LinearGradient: LinearGradient,
    RadialGradient: RadialGradient,
    Pattern: Pattern,
    Transform: Transform,
    Path: Path,
    Surface: Surface,
    Group: Group,
    ClippingRectangle: ClippingRectangle,
    Shape: Shape,
    Text: Text
  };
  module.exports = ReactART;
},224,[24,25,32,34,37,225,226,229,54,69,230,219,231,3],"node_modules/react-native/Libraries/ART/ReactNativeART.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var colors = {
    maroon: '#800000',
    red: '#ff0000',
    orange: '#ffA500',
    yellow: '#ffff00',
    olive: '#808000',
    purple: '#800080',
    fuchsia: "#ff00ff",
    white: '#ffffff',
    lime: '#00ff00',
    green: '#008000',
    navy: '#000080',
    blue: '#0000ff',
    aqua: '#00ffff',
    teal: '#008080',
    black: '#000000',
    silver: '#c0c0c0',
    gray: '#808080'
  };

  var map = function map(array, fn) {
    var results = [];

    for (var i = 0, l = array.length; i < l; i++) {
      results[i] = fn(array[i], i);
    }

    return results;
  };

  var Color = function Color(color, type) {
    if (color.isColor) {
      this.red = color.red;
      this.green = color.green;
      this.blue = color.blue;
      this.alpha = color.alpha;
    } else {
      var namedColor = colors[color];

      if (namedColor) {
        color = namedColor;
        type = 'hex';
      }

      switch (typeof color) {
        case 'string':
          if (!type) type = (type = color.match(/^rgb|^hsb|^hsl/)) ? type[0] : 'hex';
          break;

        case 'object':
          type = type || 'rgb';
          color = color.toString();
          break;

        case 'number':
          type = 'hex';
          color = color.toString(16);
          break;
      }

      color = Color['parse' + type.toUpperCase()](color);
      this.red = color[0];
      this.green = color[1];
      this.blue = color[2];
      this.alpha = color[3];
    }

    this.isColor = true;
  };

  var limit = function limit(number, min, max) {
    return Math.min(max, Math.max(min, number));
  };

  var listMatch = /([-.\d]+\%?)\s*,\s*([-.\d]+\%?)\s*,\s*([-.\d]+\%?)\s*,?\s*([-.\d]*\%?)/;
  var hexMatch = /^#?([a-f0-9]{1,2})([a-f0-9]{1,2})([a-f0-9]{1,2})([a-f0-9]{0,2})$/i;

  Color.parseRGB = function (color) {
    return map(color.match(listMatch).slice(1), function (bit, i) {
      if (bit) bit = parseFloat(bit) * (bit[bit.length - 1] == '%' ? 2.55 : 1);
      return i < 3 ? Math.round((bit %= 256) < 0 ? bit + 256 : bit) : limit(bit === '' ? 1 : Number(bit), 0, 1);
    });
  };

  Color.parseHEX = function (color) {
    if (color.length == 1) color = color + color + color;
    return map(color.match(hexMatch).slice(1), function (bit, i) {
      if (i == 3) return bit ? parseInt(bit, 16) / 255 : 1;
      return parseInt(bit.length == 1 ? bit + bit : bit, 16);
    });
  };

  Color.parseHSB = function (color) {
    var hsb = map(color.match(listMatch).slice(1), function (bit, i) {
      if (bit) bit = parseFloat(bit);
      if (i === 0) return Math.round((bit %= 360) < 0 ? bit + 360 : bit);else if (i < 3) return limit(Math.round(bit), 0, 100);else return limit(bit === '' ? 1 : Number(bit), 0, 1);
    });
    var a = hsb[3];
    var br = Math.round(hsb[2] / 100 * 255);
    if (hsb[1] == 0) return [br, br, br, a];
    var hue = hsb[0];
    var f = hue % 60;
    var p = Math.round(hsb[2] * (100 - hsb[1]) / 10000 * 255);
    var q = Math.round(hsb[2] * (6000 - hsb[1] * f) / 600000 * 255);
    var t = Math.round(hsb[2] * (6000 - hsb[1] * (60 - f)) / 600000 * 255);

    switch (Math.floor(hue / 60)) {
      case 0:
        return [br, t, p, a];

      case 1:
        return [q, br, p, a];

      case 2:
        return [p, br, t, a];

      case 3:
        return [p, q, br, a];

      case 4:
        return [t, p, br, a];

      default:
        return [br, p, q, a];
    }
  };

  Color.parseHSL = function (color) {
    var hsb = map(color.match(listMatch).slice(1), function (bit, i) {
      if (bit) bit = parseFloat(bit);
      if (i === 0) return Math.round((bit %= 360) < 0 ? bit + 360 : bit);else if (i < 3) return limit(Math.round(bit), 0, 100);else return limit(bit === '' ? 1 : Number(bit), 0, 1);
    });
    var h = hsb[0] / 60;
    var s = hsb[1] / 100;
    var l = hsb[2] / 100;
    var a = hsb[3];
    var c = (1 - Math.abs(2 * l - 1)) * s;
    var x = c * (1 - Math.abs(h % 2 - 1));
    var m = l - c / 2;
    var p = Math.round((c + m) * 255);
    var q = Math.round((x + m) * 255);
    var t = Math.round(m * 255);

    switch (Math.floor(h)) {
      case 0:
        return [p, q, t, a];

      case 1:
        return [q, p, t, a];

      case 2:
        return [t, p, q, a];

      case 3:
        return [t, q, p, a];

      case 4:
        return [q, t, p, a];

      default:
        return [p, t, q, a];
    }
  };

  var toString = function toString(type, array) {
    if (array[3] != 1) type += 'a';else array.pop();
    return type + '(' + array.join(', ') + ')';
  };

  Color.prototype = {
    toHSB: function toHSB(array) {
      var red = this.red,
          green = this.green,
          blue = this.blue,
          alpha = this.alpha;
      var max = Math.max(red, green, blue),
          min = Math.min(red, green, blue),
          delta = max - min;
      var hue = 0,
          saturation = delta != 0 ? delta / max : 0,
          brightness = max / 255;

      if (saturation) {
        var rr = (max - red) / delta,
            gr = (max - green) / delta,
            br = (max - blue) / delta;
        hue = red == max ? br - gr : green == max ? 2 + rr - br : 4 + gr - rr;
        if ((hue /= 6) < 0) hue++;
      }

      var hsb = [Math.round(hue * 360), Math.round(saturation * 100), Math.round(brightness * 100), alpha];
      return array ? hsb : toString('hsb', hsb);
    },
    toHSL: function toHSL(array) {
      var red = this.red,
          green = this.green,
          blue = this.blue,
          alpha = this.alpha;
      var max = Math.max(red, green, blue),
          min = Math.min(red, green, blue),
          delta = max - min;
      var hue = 0,
          saturation = delta != 0 ? delta / (255 - Math.abs(max + min - 255)) : 0,
          lightness = (max + min) / 512;

      if (saturation) {
        var rr = (max - red) / delta,
            gr = (max - green) / delta,
            br = (max - blue) / delta;
        hue = red == max ? br - gr : green == max ? 2 + rr - br : 4 + gr - rr;
        if ((hue /= 6) < 0) hue++;
      }

      var hsl = [Math.round(hue * 360), Math.round(saturation * 100), Math.round(lightness * 100), alpha];
      return array ? hsl : toString('hsl', hsl);
    },
    toHEX: function toHEX(array) {
      var a = this.alpha;
      var alpha = (a = Math.round(a * 255).toString(16)).length == 1 ? a + a : a;
      var hex = map([this.red, this.green, this.blue], function (bit) {
        bit = bit.toString(16);
        return bit.length == 1 ? '0' + bit : bit;
      });
      return array ? hex.concat(alpha) : '#' + hex.join('') + (alpha == 'ff' ? '' : alpha);
    },
    toRGB: function toRGB(array) {
      var rgb = [this.red, this.green, this.blue, this.alpha];
      return array ? rgb : toString('rgb', rgb);
    }
  };
  Color.prototype.toString = Color.prototype.toRGB;

  Color.hex = function (hex) {
    return new Color(hex, 'hex');
  };

  if (this.hex == null) this.hex = Color.hex;

  Color.hsb = function (h, s, b, a) {
    return new Color([h || 0, s || 0, b || 0, a == null ? 1 : a], 'hsb');
  };

  if (this.hsb == null) this.hsb = Color.hsb;

  Color.hsl = function (h, s, l, a) {
    return new Color([h || 0, s || 0, l || 0, a == null ? 1 : a], 'hsl');
  };

  if (this.hsl == null) this.hsl = Color.hsl;

  Color.rgb = function (r, g, b, a) {
    return new Color([r || 0, g || 0, b || 0, a == null ? 1 : a], 'rgb');
  };

  if (this.rgb == null) this.rgb = Color.rgb;

  Color.detach = function (color) {
    color = new Color(color);
    return [Color.rgb(color.red, color.green, color.blue).toString(), color.alpha];
  };

  module.exports = Color;
},225,[],"node_modules/art/core/color.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var Class = _$$_REQUIRE(_dependencyMap[0], "art/core/class.js");

  var Path = _$$_REQUIRE(_dependencyMap[1], "art/core/path.js");

  var MOVE_TO = 0;
  var CLOSE = 1;
  var LINE_TO = 2;
  var CURVE_TO = 3;
  var ARC = 4;
  var SerializablePath = Class(Path, {
    initialize: function initialize(path) {
      this.reset();

      if (path instanceof SerializablePath) {
        this.path = path.path.slice(0);
      } else if (path) {
        if (path.applyToPath) {
          path.applyToPath(this);
        } else {
          this.push(path);
        }
      }
    },
    onReset: function onReset() {
      this.path = [];
    },
    onMove: function onMove(sx, sy, x, y) {
      this.path.push(MOVE_TO, x, y);
    },
    onLine: function onLine(sx, sy, x, y) {
      this.path.push(LINE_TO, x, y);
    },
    onBezierCurve: function onBezierCurve(sx, sy, p1x, p1y, p2x, p2y, x, y) {
      this.path.push(CURVE_TO, p1x, p1y, p2x, p2y, x, y);
    },
    _arcToBezier: Path.prototype.onArc,
    onArc: function onArc(sx, sy, ex, ey, cx, cy, rx, ry, sa, ea, ccw, rotation) {
      if (rx !== ry || rotation) {
        return this._arcToBezier(sx, sy, ex, ey, cx, cy, rx, ry, sa, ea, ccw, rotation);
      }

      this.path.push(ARC, cx, cy, rx, sa, ea, ccw ? 0 : 1);
    },
    onClose: function onClose() {
      this.path.push(CLOSE);
    },
    toJSON: function toJSON() {
      return this.path;
    }
  });
  module.exports = SerializablePath;
},226,[227,228],"node_modules/react-native/Libraries/ART/ARTSerializablePath.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  module.exports = function (mixins) {
    var proto = {};

    for (var i = 0, l = arguments.length; i < l; i++) {
      var mixin = arguments[i];
      if (typeof mixin == 'function') mixin = mixin.prototype;

      for (var key in mixin) {
        proto[key] = mixin[key];
      }
    }

    if (!proto.initialize) proto.initialize = function () {};

    proto.constructor = function (a, b, c, d, e, f, g, h) {
      return new proto.initialize(a, b, c, d, e, f, g, h);
    };

    proto.constructor.prototype = proto.initialize.prototype = proto;
    return proto.constructor;
  };
},227,[],"node_modules/art/core/class.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var Class = _$$_REQUIRE(_dependencyMap[0], "./class");

  module.exports = Class({
    initialize: function initialize(path) {
      this.reset().push(path);
    },
    push: function push() {
      var p = Array.prototype.join.call(arguments, ' ').match(/[a-df-z]|[\-+]?(?:[\d\.]e[\-+]?|[^\s\-+,a-z])+/ig);
      if (!p) return this;
      var last,
          cmd = p[0],
          i = 1;

      while (cmd) {
        switch (cmd) {
          case 'm':
            this.move(p[i++], p[i++]);
            break;

          case 'l':
            this.line(p[i++], p[i++]);
            break;

          case 'c':
            this.curve(p[i++], p[i++], p[i++], p[i++], p[i++], p[i++]);
            break;

          case 's':
            this.curve(p[i++], p[i++], null, null, p[i++], p[i++]);
            break;

          case 'q':
            this.curve(p[i++], p[i++], p[i++], p[i++]);
            break;

          case 't':
            this.curve(p[i++], p[i++]);
            break;

          case 'a':
            this.arc(p[i + 5], p[i + 6], p[i], p[i + 1], p[i + 3], !+p[i + 4], p[i + 2]);
            i += 7;
            break;

          case 'h':
            this.line(p[i++], 0);
            break;

          case 'v':
            this.line(0, p[i++]);
            break;

          case 'M':
            this.moveTo(p[i++], p[i++]);
            break;

          case 'L':
            this.lineTo(p[i++], p[i++]);
            break;

          case 'C':
            this.curveTo(p[i++], p[i++], p[i++], p[i++], p[i++], p[i++]);
            break;

          case 'S':
            this.curveTo(p[i++], p[i++], null, null, p[i++], p[i++]);
            break;

          case 'Q':
            this.curveTo(p[i++], p[i++], p[i++], p[i++]);
            break;

          case 'T':
            this.curveTo(p[i++], p[i++]);
            break;

          case 'A':
            this.arcTo(p[i + 5], p[i + 6], p[i], p[i + 1], p[i + 3], !+p[i + 4], p[i + 2]);
            i += 7;
            break;

          case 'H':
            this.lineTo(p[i++], this.penY);
            break;

          case 'V':
            this.lineTo(this.penX, p[i++]);
            break;

          case 'Z':
          case 'z':
            this.close();
            break;

          default:
            cmd = last;
            i--;
            continue;
        }

        last = cmd;
        if (last == 'm') last = 'l';else if (last == 'M') last = 'L';
        cmd = p[i++];
      }

      return this;
    },
    reset: function reset() {
      this.penX = this.penY = 0;
      this.penDownX = this.penDownY = null;
      this._pivotX = this._pivotY = 0;
      this.onReset();
      return this;
    },
    move: function move(x, y) {
      this.onMove(this.penX, this.penY, this._pivotX = this.penX += +x, this._pivotY = this.penY += +y);
      return this;
    },
    moveTo: function moveTo(x, y) {
      this.onMove(this.penX, this.penY, this._pivotX = this.penX = +x, this._pivotY = this.penY = +y);
      return this;
    },
    line: function line(x, y) {
      return this.lineTo(this.penX + +x, this.penY + +y);
    },
    lineTo: function lineTo(x, y) {
      if (this.penDownX == null) {
        this.penDownX = this.penX;
        this.penDownY = this.penY;
      }

      this.onLine(this.penX, this.penY, this._pivotX = this.penX = +x, this._pivotY = this.penY = +y);
      return this;
    },
    curve: function curve(c1x, c1y, c2x, c2y, ex, ey) {
      var x = this.penX,
          y = this.penY;
      return this.curveTo(x + +c1x, y + +c1y, c2x == null ? null : x + +c2x, c2y == null ? null : y + +c2y, ex == null ? null : x + +ex, ey == null ? null : y + +ey);
    },
    curveTo: function curveTo(c1x, c1y, c2x, c2y, ex, ey) {
      var x = this.penX,
          y = this.penY;

      if (c2x == null) {
        c2x = +c1x;
        c2y = +c1y;
        c1x = x * 2 - (this._pivotX || 0);
        c1y = y * 2 - (this._pivotY || 0);
      }

      if (ex == null) {
        this._pivotX = +c1x;
        this._pivotY = +c1y;
        ex = +c2x;
        ey = +c2y;
        c2x = (ex + +c1x * 2) / 3;
        c2y = (ey + +c1y * 2) / 3;
        c1x = (x + +c1x * 2) / 3;
        c1y = (y + +c1y * 2) / 3;
      } else {
        this._pivotX = +c2x;
        this._pivotY = +c2y;
      }

      if (this.penDownX == null) {
        this.penDownX = x;
        this.penDownY = y;
      }

      this.onBezierCurve(x, y, +c1x, +c1y, +c2x, +c2y, this.penX = +ex, this.penY = +ey);
      return this;
    },
    arc: function arc(x, y, rx, ry, outer, counterClockwise, rotation) {
      return this.arcTo(this.penX + +x, this.penY + +y, rx, ry, outer, counterClockwise, rotation);
    },
    arcTo: function arcTo(x, y, rx, ry, outer, counterClockwise, rotation) {
      ry = Math.abs(+ry || +rx || +y - this.penY);
      rx = Math.abs(+rx || +x - this.penX);
      if (!rx || !ry || x == this.penX && y == this.penY) return this.lineTo(x, y);
      var tX = this.penX,
          tY = this.penY,
          clockwise = !+counterClockwise,
          large = !!+outer;
      var rad = rotation ? rotation * Math.PI / 180 : 0,
          cos = Math.cos(rad),
          sin = Math.sin(rad);
      x -= tX;
      y -= tY;
      var cx = cos * x / 2 + sin * y / 2,
          cy = -sin * x / 2 + cos * y / 2,
          rxry = rx * rx * ry * ry,
          rycx = ry * ry * cx * cx,
          rxcy = rx * rx * cy * cy,
          a = rxry - rxcy - rycx;

      if (a < 0) {
        a = Math.sqrt(1 - a / rxry);
        rx *= a;
        ry *= a;
        cx = x / 2;
        cy = y / 2;
      } else {
        a = Math.sqrt(a / (rxcy + rycx));
        if (large == clockwise) a = -a;
        var cxd = -a * cy * rx / ry,
            cyd = a * cx * ry / rx;
        cx = cos * cxd - sin * cyd + x / 2;
        cy = sin * cxd + cos * cyd + y / 2;
      }

      var xx = cos / rx,
          yx = sin / rx,
          xy = -sin / ry,
          yy = cos / ry;
      var sa = Math.atan2(xy * -cx + yy * -cy, xx * -cx + yx * -cy),
          ea = Math.atan2(xy * (x - cx) + yy * (y - cy), xx * (x - cx) + yx * (y - cy));
      cx += tX;
      cy += tY;
      x += tX;
      y += tY;

      if (this.penDownX == null) {
        this.penDownX = this.penX;
        this.penDownY = this.penY;
      }

      this.onArc(tX, tY, this._pivotX = this.penX = x, this._pivotY = this.penY = y, cx, cy, rx, ry, sa, ea, !clockwise, rotation);
      return this;
    },
    counterArc: function counterArc(x, y, rx, ry, outer) {
      return this.arc(x, y, rx, ry, outer, true);
    },
    counterArcTo: function counterArcTo(x, y, rx, ry, outer) {
      return this.arcTo(x, y, rx, ry, outer, true);
    },
    close: function close() {
      if (this.penDownX != null) {
        this.onClose(this.penX, this.penY, this.penX = this.penDownX, this.penY = this.penDownY);
        this.penDownX = null;
      }

      return this;
    },
    onReset: function onReset() {},
    onMove: function onMove(sx, sy, ex, ey) {},
    onLine: function onLine(sx, sy, ex, ey) {
      this.onBezierCurve(sx, sy, sx, sy, ex, ey, ex, ey);
    },
    onBezierCurve: function onBezierCurve(sx, sy, c1x, c1y, c2x, c2y, ex, ey) {
      var gx = ex - sx,
          gy = ey - sy,
          g = gx * gx + gy * gy,
          v1,
          v2,
          cx,
          cy,
          u;
      cx = c1x - sx;
      cy = c1y - sy;
      u = cx * gx + cy * gy;

      if (u > g) {
        cx -= gx;
        cy -= gy;
      } else if (u > 0 && g != 0) {
        cx -= u / g * gx;
        cy -= u / g * gy;
      }

      v1 = cx * cx + cy * cy;
      cx = c2x - sx;
      cy = c2y - sy;
      u = cx * gx + cy * gy;

      if (u > g) {
        cx -= gx;
        cy -= gy;
      } else if (u > 0 && g != 0) {
        cx -= u / g * gx;
        cy -= u / g * gy;
      }

      v2 = cx * cx + cy * cy;

      if (v1 < 0.01 && v2 < 0.01) {
        this.onLine(sx, sy, ex, ey);
        return;
      }

      if (isNaN(v1) || isNaN(v2)) {
        throw new Error('Bad input');
      }

      var s1x = (c1x + c2x) * 0.5,
          s1y = (c1y + c2y) * 0.5,
          l1x = (c1x + sx) * 0.5,
          l1y = (c1y + sy) * 0.5,
          l2x = (l1x + s1x) * 0.5,
          l2y = (l1y + s1y) * 0.5,
          r2x = (ex + c2x) * 0.5,
          r2y = (ey + c2y) * 0.5,
          r1x = (r2x + s1x) * 0.5,
          r1y = (r2y + s1y) * 0.5,
          l2r1x = (l2x + r1x) * 0.5,
          l2r1y = (l2y + r1y) * 0.5;
      this.onBezierCurve(sx, sy, l1x, l1y, l2x, l2y, l2r1x, l2r1y);
      this.onBezierCurve(l2r1x, l2r1y, r1x, r1y, r2x, r2y, ex, ey);
    },
    onArc: function onArc(sx, sy, ex, ey, cx, cy, rx, ry, sa, ea, ccw, rotation) {
      var rad = rotation ? rotation * Math.PI / 180 : 0,
          cos = Math.cos(rad),
          sin = Math.sin(rad),
          xx = cos * rx,
          yx = -sin * ry,
          xy = sin * rx,
          yy = cos * ry;
      var arc = ea - sa;
      if (arc < 0 && !ccw) arc += Math.PI * 2;else if (arc > 0 && ccw) arc -= Math.PI * 2;
      var n = Math.ceil(Math.abs(arc / (Math.PI / 2))),
          step = arc / n,
          k = 4 / 3 * Math.tan(step / 4);
      var x = Math.cos(sa),
          y = Math.sin(sa);

      for (var i = 0; i < n; i++) {
        var cp1x = x - k * y,
            cp1y = y + k * x;
        sa += step;
        x = Math.cos(sa);
        y = Math.sin(sa);
        var cp2x = x + k * y,
            cp2y = y - k * x;
        this.onBezierCurve(sx, sy, cx + xx * cp1x + yx * cp1y, cy + xy * cp1x + yy * cp1y, cx + xx * cp2x + yx * cp2y, cy + xy * cp2x + yy * cp2y, sx = cx + xx * x + yx * y, sy = cy + xy * x + yy * y);
      }
    },
    onClose: function onClose(sx, sy, ex, ey) {
      this.onLine(sx, sy, ex, ey);
    }
  });
},228,[227],"node_modules/art/core/path.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var Class = _$$_REQUIRE(_dependencyMap[0], "./class");

  function Transform(xx, yx, xy, yy, x, y) {
    if (xx && typeof xx == 'object') {
      yx = xx.yx;
      yy = xx.yy;
      y = xx.y;
      xy = xx.xy;
      x = xx.x;
      xx = xx.xx;
    }

    this.xx = xx == null ? 1 : xx;
    this.yx = yx || 0;
    this.xy = xy || 0;
    this.yy = yy == null ? 1 : yy;
    this.x = (x == null ? this.x : x) || 0;
    this.y = (y == null ? this.y : y) || 0;

    this._transform();

    return this;
  }

  ;
  module.exports = Class({
    initialize: Transform,
    _transform: function _transform() {},
    xx: 1,
    yx: 0,
    x: 0,
    xy: 0,
    yy: 1,
    y: 0,
    transform: function transform(xx, yx, xy, yy, x, y) {
      var m = this;

      if (xx && typeof xx == 'object') {
        yx = xx.yx;
        yy = xx.yy;
        y = xx.y;
        xy = xx.xy;
        x = xx.x;
        xx = xx.xx;
      }

      if (!x) x = 0;
      if (!y) y = 0;
      return this.transformTo(m.xx * xx + m.xy * yx, m.yx * xx + m.yy * yx, m.xx * xy + m.xy * yy, m.yx * xy + m.yy * yy, m.xx * x + m.xy * y + m.x, m.yx * x + m.yy * y + m.y);
    },
    transformTo: Transform,
    translate: function translate(x, y) {
      return this.transform(1, 0, 0, 1, x, y);
    },
    move: function move(x, y) {
      this.x += x || 0;
      this.y += y || 0;

      this._transform();

      return this;
    },
    scale: function scale(x, y) {
      if (y == null) y = x;
      return this.transform(x, 0, 0, y, 0, 0);
    },
    rotate: function rotate(deg, x, y) {
      if (x == null || y == null) {
        x = (this.left || 0) + (this.width || 0) / 2;
        y = (this.top || 0) + (this.height || 0) / 2;
      }

      var rad = deg * Math.PI / 180,
          sin = Math.sin(rad),
          cos = Math.cos(rad);
      this.transform(1, 0, 0, 1, x, y);
      var m = this;
      return this.transformTo(cos * m.xx - sin * m.yx, sin * m.xx + cos * m.yx, cos * m.xy - sin * m.yy, sin * m.xy + cos * m.yy, m.x, m.y).transform(1, 0, 0, 1, -x, -y);
    },
    moveTo: function moveTo(x, y) {
      var m = this;
      return this.transformTo(m.xx, m.yx, m.xy, m.yy, x, y);
    },
    rotateTo: function rotateTo(deg, x, y) {
      var m = this;
      var flip = m.yx / m.xx > m.yy / m.xy ? -1 : 1;
      if (m.xx < 0 ? m.xy >= 0 : m.xy < 0) flip = -flip;
      return this.rotate(deg - Math.atan2(flip * m.yx, flip * m.xx) * 180 / Math.PI, x, y);
    },
    scaleTo: function scaleTo(x, y) {
      var m = this;
      var h = Math.sqrt(m.xx * m.xx + m.yx * m.yx);
      m.xx /= h;
      m.yx /= h;
      h = Math.sqrt(m.yy * m.yy + m.xy * m.xy);
      m.yy /= h;
      m.xy /= h;
      return this.scale(x, y);
    },
    resizeTo: function resizeTo(width, height) {
      var w = this.width,
          h = this.height;
      if (!w || !h) return this;
      return this.scaleTo(width / w, height / h);
    },
    inversePoint: function inversePoint(x, y) {
      var a = this.xx,
          b = this.yx,
          c = this.xy,
          d = this.yy,
          e = this.x,
          f = this.y;
      var det = b * c - a * d;
      if (det == 0) return null;
      return {
        x: (d * (e - x) + c * (y - f)) / det,
        y: (a * (f - y) + b * (x - e)) / det
      };
    },
    point: function point(x, y) {
      var m = this;
      return {
        x: m.xx * x + m.xy * y + m.x,
        y: m.yx * x + m.yy * y + m.y
      };
    }
  });
},229,[227],"node_modules/art/core/transform.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");

  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

  var ReactNativeStyleAttributes = _$$_REQUIRE(_dependencyMap[1], "./ReactNativeStyleAttributes");

  var UIView = {
    pointerEvents: true,
    accessible: true,
    accessibilityActions: true,
    accessibilityLabel: true,
    accessibilityLiveRegion: true,
    accessibilityRole: true,
    accessibilityStates: true,
    accessibilityState: true,
    accessibilityHint: true,
    importantForAccessibility: true,
    nativeID: true,
    testID: true,
    renderToHardwareTextureAndroid: true,
    shouldRasterizeIOS: true,
    onLayout: true,
    onAccessibilityAction: true,
    onAccessibilityTap: true,
    onMagicTap: true,
    onAccessibilityEscape: true,
    collapsable: true,
    needsOffscreenAlphaCompositing: true,
    style: ReactNativeStyleAttributes
  };

  var RCTView = _objectSpread({}, UIView, {
    removeClippedSubviews: true
  });

  var ReactNativeViewAttributes = {
    UIView: UIView,
    RCTView: RCTView
  };
  module.exports = ReactNativeViewAttributes;
},230,[46,64],"node_modules/react-native/Libraries/Components/View/ReactNativeViewAttributes.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  "use strict";

  var mergeInto = _$$_REQUIRE(_dependencyMap[0], "./mergeInto");

  var merge = function merge(one, two) {
    var result = {};
    mergeInto(result, one);
    mergeInto(result, two);
    return result;
  };

  module.exports = merge;
},231,[232],"node_modules/react-native/Libraries/vendor/core/merge.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  "use strict";

  var mergeHelpers = _$$_REQUIRE(_dependencyMap[0], "./mergeHelpers");

  var checkMergeObjectArg = mergeHelpers.checkMergeObjectArg;
  var checkMergeIntoObjectArg = mergeHelpers.checkMergeIntoObjectArg;

  function mergeInto(one, two) {
    checkMergeIntoObjectArg(one);

    if (two != null) {
      checkMergeObjectArg(two);

      for (var key in two) {
        if (!Object.prototype.hasOwnProperty.call(two, key)) {
          continue;
        }

        one[key] = two[key];
      }
    }
  }

  module.exports = mergeInto;
},232,[233],"node_modules/react-native/Libraries/vendor/core/mergeInto.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var invariant = _$$_REQUIRE(_dependencyMap[0], "invariant");

  var MAX_MERGE_DEPTH = 36;

  var isTerminal = function isTerminal(o) {
    return typeof o !== 'object' || o instanceof Date || o === null;
  };

  var mergeHelpers = {
    MAX_MERGE_DEPTH: MAX_MERGE_DEPTH,
    isTerminal: isTerminal,
    normalizeMergeArg: function normalizeMergeArg(arg) {
      return arg === undefined || arg === null ? {} : arg;
    },
    checkMergeArrayArgs: function checkMergeArrayArgs(one, two) {
      invariant(Array.isArray(one) && Array.isArray(two), 'Tried to merge arrays, instead got %s and %s.', one, two);
    },
    checkMergeObjectArgs: function checkMergeObjectArgs(one, two) {
      mergeHelpers.checkMergeObjectArg(one);
      mergeHelpers.checkMergeObjectArg(two);
    },
    checkMergeObjectArg: function checkMergeObjectArg(arg) {
      invariant(!isTerminal(arg) && !Array.isArray(arg), 'Tried to merge an object, instead got %s.', arg);
    },
    checkMergeIntoObjectArg: function checkMergeIntoObjectArg(arg) {
      invariant((!isTerminal(arg) || typeof arg === 'function') && !Array.isArray(arg), 'Tried to merge into an object, instead got %s.', arg);
    },
    checkMergeLevel: function checkMergeLevel(level) {
      invariant(level < MAX_MERGE_DEPTH, 'Maximum deep merge depth exceeded. You may be attempting to merge ' + 'circular structures in an unsupported way.');
    },
    checkArrayStrategy: function checkArrayStrategy(strategy) {
      invariant(strategy === undefined || strategy in mergeHelpers.ArrayStrategies, 'You must provide an array strategy to deep merge functions to ' + 'instruct the deep merge how to resolve merging two arrays.');
    },
    ArrayStrategies: {
      Clobber: 'Clobber',
      Concat: 'Concat',
      IndexByIndex: 'IndexByIndex'
    }
  };
  module.exports = mergeHelpers;
},233,[3],"node_modules/react-native/Libraries/vendor/core/mergeHelpers.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass");

  var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn");

  var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf");

  var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native/Libraries/Components/Button.js";

  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

  var Platform = _$$_REQUIRE(_dependencyMap[6], "../Utilities/Platform");

  var React = _$$_REQUIRE(_dependencyMap[7], "react");

  var StyleSheet = _$$_REQUIRE(_dependencyMap[8], "../StyleSheet/StyleSheet");

  var Text = _$$_REQUIRE(_dependencyMap[9], "../Text/Text");

  var TouchableNativeFeedback = _$$_REQUIRE(_dependencyMap[10], "./Touchable/TouchableNativeFeedback");

  var TouchableOpacity = _$$_REQUIRE(_dependencyMap[11], "./Touchable/TouchableOpacity");

  var View = _$$_REQUIRE(_dependencyMap[12], "./View/View");

  var invariant = _$$_REQUIRE(_dependencyMap[13], "invariant");

  var Button = function (_React$Component) {
    _inherits(Button, _React$Component);

    function Button() {
      _classCallCheck(this, Button);

      return _possibleConstructorReturn(this, _getPrototypeOf(Button).apply(this, arguments));
    }

    _createClass(Button, [{
      key: "render",
      value: function render() {
        var _this$props = this.props,
            accessibilityLabel = _this$props.accessibilityLabel,
            color = _this$props.color,
            onPress = _this$props.onPress,
            touchSoundDisabled = _this$props.touchSoundDisabled,
            title = _this$props.title,
            hasTVPreferredFocus = _this$props.hasTVPreferredFocus,
            nextFocusDown = _this$props.nextFocusDown,
            nextFocusForward = _this$props.nextFocusForward,
            nextFocusLeft = _this$props.nextFocusLeft,
            nextFocusRight = _this$props.nextFocusRight,
            nextFocusUp = _this$props.nextFocusUp,
            disabled = _this$props.disabled,
            testID = _this$props.testID;
        var buttonStyles = [styles.button];
        var textStyles = [styles.text];

        if (color) {
          if ("android" === 'ios') {
            textStyles.push({
              color: color
            });
          } else {
            buttonStyles.push({
              backgroundColor: color
            });
          }
        }

        var accessibilityStates = [];

        if (disabled) {
          buttonStyles.push(styles.buttonDisabled);
          textStyles.push(styles.textDisabled);
          accessibilityStates.push('disabled');
        }

        invariant(typeof title === 'string', 'The title prop of a Button must be a string');
        var formattedTitle = "android" === 'android' ? title.toUpperCase() : title;
        var Touchable = "android" === 'android' ? TouchableNativeFeedback : TouchableOpacity;
        return React.createElement(Touchable, {
          accessibilityLabel: accessibilityLabel,
          accessibilityRole: "button",
          accessibilityStates: accessibilityStates,
          hasTVPreferredFocus: hasTVPreferredFocus,
          nextFocusDown: nextFocusDown,
          nextFocusForward: nextFocusForward,
          nextFocusLeft: nextFocusLeft,
          nextFocusRight: nextFocusRight,
          nextFocusUp: nextFocusUp,
          testID: testID,
          disabled: disabled,
          onPress: onPress,
          touchSoundDisabled: touchSoundDisabled,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 171
          }
        }, React.createElement(View, {
          style: buttonStyles,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 185
          }
        }, React.createElement(Text, {
          style: textStyles,
          disabled: disabled,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 186
          }
        }, formattedTitle)));
      }
    }]);

    return Button;
  }(React.Component);

  var styles = StyleSheet.create({
    button: {
      elevation: 4,
      backgroundColor: '#2196F3',
      borderRadius: 2
    },
    text: _objectSpread({
      textAlign: 'center',
      padding: 8
    }, {
      color: 'white',
      fontWeight: '500'
    }),
    buttonDisabled: {
      elevation: 0,
      backgroundColor: '#dfdfdf'
    },
    textDisabled: {
      color: '#a1a1a1'
    }
  });
  module.exports = Button;
},234,[46,24,25,32,34,37,48,54,60,235,250,260,86,3],"node_modules/react-native/Libraries/Components/Button.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass");

  var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn");

  var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf");

  var _assertThisInitialized = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/assertThisInitialized");

  var _inherits = _$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits");

  var _defineProperty = _$$_REQUIRE(_dependencyMap[7], "@babel/runtime/helpers/defineProperty");

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native/Libraries/Text/Text.js";

  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

  var DeprecatedTextPropTypes = _$$_REQUIRE(_dependencyMap[8], "../DeprecatedPropTypes/DeprecatedTextPropTypes");

  var React = _$$_REQUIRE(_dependencyMap[9], "react");

  var ReactNativeViewAttributes = _$$_REQUIRE(_dependencyMap[10], "../Components/View/ReactNativeViewAttributes");

  var TextAncestor = _$$_REQUIRE(_dependencyMap[11], "./TextAncestor");

  var Touchable = _$$_REQUIRE(_dependencyMap[12], "../Components/Touchable/Touchable");

  var UIManager = _$$_REQUIRE(_dependencyMap[13], "../ReactNative/UIManager");

  var createReactNativeComponentClass = _$$_REQUIRE(_dependencyMap[14], "../Renderer/shims/createReactNativeComponentClass");

  var nullthrows = _$$_REQUIRE(_dependencyMap[15], "nullthrows");

  var processColor = _$$_REQUIRE(_dependencyMap[16], "../StyleSheet/processColor");

  var PRESS_RECT_OFFSET = {
    top: 20,
    left: 20,
    right: 20,
    bottom: 30
  };
  var viewConfig = {
    validAttributes: _objectSpread({}, ReactNativeViewAttributes.UIView, {
      isHighlighted: true,
      numberOfLines: true,
      ellipsizeMode: true,
      allowFontScaling: true,
      maxFontSizeMultiplier: true,
      disabled: true,
      selectable: true,
      selectionColor: true,
      adjustsFontSizeToFit: true,
      minimumFontScale: true,
      textBreakStrategy: true,
      onTextLayout: true,
      onInlineViewLayout: true,
      dataDetectorType: true
    }),
    directEventTypes: {
      topTextLayout: {
        registrationName: 'onTextLayout'
      },
      topInlineViewLayout: {
        registrationName: 'onInlineViewLayout'
      }
    },
    uiViewClassName: 'RCTText'
  };

  var TouchableText = function (_React$Component) {
    _inherits(TouchableText, _React$Component);

    function TouchableText() {
      var _getPrototypeOf2;

      var _this;

      _classCallCheck(this, TouchableText);

      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
        args[_key] = arguments[_key];
      }

      _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(TouchableText)).call.apply(_getPrototypeOf2, [this].concat(args)));
      _this.state = _objectSpread({}, Touchable.Mixin.touchableGetInitialState(), {
        isHighlighted: false,
        createResponderHandlers: _this._createResponseHandlers.bind(_assertThisInitialized(_this)),
        responseHandlers: null
      });
      return _this;
    }

    _createClass(TouchableText, [{
      key: "render",
      value: function render() {
        var props = this.props;

        if (isTouchable(props)) {
          props = _objectSpread({}, props, {}, this.state.responseHandlers, {
            isHighlighted: this.state.isHighlighted
          });
        }

        if (props.selectionColor != null) {
          props = _objectSpread({}, props, {
            selectionColor: processColor(props.selectionColor)
          });
        }

        if (__DEV__) {
          if (Touchable.TOUCH_TARGET_DEBUG && props.onPress != null) {
            props = _objectSpread({}, props, {
              style: [props.style, {
                color: 'magenta'
              }]
            });
          }
        }

        return React.createElement(TextAncestor.Consumer, {
          __source: {
            fileName: _jsxFileName,
            lineNumber: 153
          }
        }, function (hasTextAncestor) {
          return hasTextAncestor ? React.createElement(RCTVirtualText, _extends({}, props, {
            ref: props.forwardedRef,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 156
            }
          })) : React.createElement(TextAncestor.Provider, {
            value: true,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 158
            }
          }, React.createElement(RCTText, _extends({}, props, {
            ref: props.forwardedRef,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 159
            }
          })));
        });
      }
    }, {
      key: "_createResponseHandlers",
      value: function _createResponseHandlers() {
        var _this2 = this;

        return {
          onStartShouldSetResponder: function onStartShouldSetResponder() {
            var onStartShouldSetResponder = _this2.props.onStartShouldSetResponder;
            var shouldSetResponder = (onStartShouldSetResponder == null ? false : onStartShouldSetResponder()) || isTouchable(_this2.props);

            if (shouldSetResponder) {
              _this2._attachTouchHandlers();
            }

            return shouldSetResponder;
          },
          onResponderGrant: function onResponderGrant(event, dispatchID) {
            nullthrows(_this2.touchableHandleResponderGrant)(event, dispatchID);

            if (_this2.props.onResponderGrant != null) {
              _this2.props.onResponderGrant.call(_this2, event, dispatchID);
            }
          },
          onResponderMove: function onResponderMove(event) {
            nullthrows(_this2.touchableHandleResponderMove)(event);

            if (_this2.props.onResponderMove != null) {
              _this2.props.onResponderMove.call(_this2, event);
            }
          },
          onResponderRelease: function onResponderRelease(event) {
            nullthrows(_this2.touchableHandleResponderRelease)(event);

            if (_this2.props.onResponderRelease != null) {
              _this2.props.onResponderRelease.call(_this2, event);
            }
          },
          onResponderTerminate: function onResponderTerminate(event) {
            nullthrows(_this2.touchableHandleResponderTerminate)(event);

            if (_this2.props.onResponderTerminate != null) {
              _this2.props.onResponderTerminate.call(_this2, event);
            }
          },
          onResponderTerminationRequest: function onResponderTerminationRequest() {
            var onResponderTerminationRequest = _this2.props.onResponderTerminationRequest;

            if (!nullthrows(_this2.touchableHandleResponderTerminationRequest)()) {
              return false;
            }

            if (onResponderTerminationRequest == null) {
              return true;
            }

            return onResponderTerminationRequest();
          }
        };
      }
    }, {
      key: "_attachTouchHandlers",
      value: function _attachTouchHandlers() {
        var _this3 = this;

        if (this.touchableGetPressRectOffset != null) {
          return;
        }

        for (var key in Touchable.Mixin) {
          if (typeof Touchable.Mixin[key] === 'function') {
            this[key] = Touchable.Mixin[key].bind(this);
          }
        }

        this.touchableHandleActivePressIn = function () {
          if (!_this3.props.suppressHighlighting && isTouchable(_this3.props)) {
            _this3.setState({
              isHighlighted: true
            });
          }
        };

        this.touchableHandleActivePressOut = function () {
          if (!_this3.props.suppressHighlighting && isTouchable(_this3.props)) {
            _this3.setState({
              isHighlighted: false
            });
          }
        };

        this.touchableHandlePress = function (event) {
          if (_this3.props.onPress != null) {
            _this3.props.onPress(event);
          }
        };

        this.touchableHandleLongPress = function (event) {
          if (_this3.props.onLongPress != null) {
            _this3.props.onLongPress(event);
          }
        };

        this.touchableGetPressRectOffset = function () {
          return _this3.props.pressRetentionOffset == null ? PRESS_RECT_OFFSET : _this3.props.pressRetentionOffset;
        };
      }
    }], [{
      key: "getDerivedStateFromProps",
      value: function getDerivedStateFromProps(nextProps, prevState) {
        return prevState.responseHandlers == null && isTouchable(nextProps) ? {
          responseHandlers: prevState.createResponderHandlers()
        } : null;
      }
    }]);

    return TouchableText;
  }(React.Component);

  TouchableText.defaultProps = {
    accessible: true,
    allowFontScaling: true,
    ellipsizeMode: 'tail'
  };
  TouchableText.viewConfig = viewConfig;

  var isTouchable = function isTouchable(props) {
    return props.onPress != null || props.onLongPress != null || props.onStartShouldSetResponder != null;
  };

  var RCTText = createReactNativeComponentClass(viewConfig.uiViewClassName, function () {
    return viewConfig;
  });
  var RCTVirtualText = UIManager.getViewManagerConfig('RCTVirtualText') == null ? RCTText : createReactNativeComponentClass('RCTVirtualText', function () {
    return {
      validAttributes: _objectSpread({}, ReactNativeViewAttributes.UIView, {
        isHighlighted: true,
        maxFontSizeMultiplier: true
      }),
      uiViewClassName: 'RCTVirtualText'
    };
  });

  var Text = function Text(props, forwardedRef) {
    return React.createElement(TouchableText, _extends({}, props, {
      forwardedRef: forwardedRef,
      __source: {
        fileName: _jsxFileName,
        lineNumber: 283
      }
    }));
  };

  var TextToExport = React.forwardRef(Text);
  TextToExport.displayName = 'Text';
  TextToExport.propTypes = DeprecatedTextPropTypes;
  module.exports = TextToExport;
},235,[13,24,25,32,34,33,37,46,236,54,230,240,241,43,219,249,80],"node_modules/react-native/Libraries/Text/Text.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var DeprecatedColorPropType = _$$_REQUIRE(_dependencyMap[0], "./DeprecatedColorPropType");

  var DeprecatedEdgeInsetsPropType = _$$_REQUIRE(_dependencyMap[1], "./DeprecatedEdgeInsetsPropType");

  var DeprecatedStyleSheetPropType = _$$_REQUIRE(_dependencyMap[2], "./DeprecatedStyleSheetPropType");

  var PropTypes = _$$_REQUIRE(_dependencyMap[3], "prop-types");

  var DeprecatedTextStylePropTypes = _$$_REQUIRE(_dependencyMap[4], "./DeprecatedTextStylePropTypes");

  var stylePropType = DeprecatedStyleSheetPropType(DeprecatedTextStylePropTypes);
  var DataDetectorTypes = ['phoneNumber', 'link', 'email', 'none', 'all'];
  module.exports = {
    ellipsizeMode: PropTypes.oneOf(['head', 'middle', 'tail', 'clip']),
    numberOfLines: PropTypes.number,
    textBreakStrategy: PropTypes.oneOf(['simple', 'highQuality', 'balanced']),
    onLayout: PropTypes.func,
    onPress: PropTypes.func,
    onLongPress: PropTypes.func,
    pressRetentionOffset: DeprecatedEdgeInsetsPropType,
    selectable: PropTypes.bool,
    selectionColor: DeprecatedColorPropType,
    suppressHighlighting: PropTypes.bool,
    style: stylePropType,
    testID: PropTypes.string,
    nativeID: PropTypes.string,
    allowFontScaling: PropTypes.bool,
    maxFontSizeMultiplier: PropTypes.number,
    accessible: PropTypes.bool,
    adjustsFontSizeToFit: PropTypes.bool,
    minimumFontScale: PropTypes.number,
    disabled: PropTypes.bool,
    dataDetectorType: PropTypes.oneOf(DataDetectorTypes)
  };
},236,[66,237,238,69,78],"node_modules/react-native/Libraries/DeprecatedPropTypes/DeprecatedTextPropTypes.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var PropTypes = _$$_REQUIRE(_dependencyMap[0], "prop-types");

  var DeprecatedEdgeInsetsPropType = PropTypes.shape({
    top: PropTypes.number,
    left: PropTypes.number,
    bottom: PropTypes.number,
    right: PropTypes.number
  });
  module.exports = DeprecatedEdgeInsetsPropType;
},237,[69],"node_modules/react-native/Libraries/DeprecatedPropTypes/DeprecatedEdgeInsetsPropType.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var deprecatedCreateStrictShapeTypeChecker = _$$_REQUIRE(_dependencyMap[0], "./deprecatedCreateStrictShapeTypeChecker");

  var flattenStyle = _$$_REQUIRE(_dependencyMap[1], "../StyleSheet/flattenStyle");

  function DeprecatedStyleSheetPropType(shape) {
    var shapePropType = deprecatedCreateStrictShapeTypeChecker(shape);
    return function (props, propName, componentName, location) {
      var newProps = props;

      if (props[propName]) {
        newProps = {};
        newProps[propName] = flattenStyle(props[propName]);
      }

      for (var _len = arguments.length, rest = new Array(_len > 4 ? _len - 4 : 0), _key = 4; _key < _len; _key++) {
        rest[_key - 4] = arguments[_key];
      }

      return shapePropType.apply(void 0, [newProps, propName, componentName, location].concat(rest));
    };
  }

  module.exports = DeprecatedStyleSheetPropType;
},238,[239,85],"node_modules/react-native/Libraries/DeprecatedPropTypes/DeprecatedStyleSheetPropType.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var invariant = _$$_REQUIRE(_dependencyMap[0], "invariant");

  var merge = _$$_REQUIRE(_dependencyMap[1], "../vendor/core/merge");

  function deprecatedCreateStrictShapeTypeChecker(shapeTypes) {
    function checkType(isRequired, props, propName, componentName, location) {
      if (!props[propName]) {
        if (isRequired) {
          invariant(false, "Required object `" + propName + "` was not specified in " + ("`" + componentName + "`."));
        }

        return;
      }

      var propValue = props[propName];
      var propType = typeof propValue;
      var locationName = location || '(unknown)';

      if (propType !== 'object') {
        invariant(false, "Invalid " + locationName + " `" + propName + "` of type `" + propType + "` " + ("supplied to `" + componentName + "`, expected `object`."));
      }

      var allKeys = merge(props[propName], shapeTypes);

      for (var _len = arguments.length, rest = new Array(_len > 5 ? _len - 5 : 0), _key = 5; _key < _len; _key++) {
        rest[_key - 5] = arguments[_key];
      }

      for (var _key2 in allKeys) {
        var checker = shapeTypes[_key2];

        if (!checker) {
          invariant(false, "Invalid props." + propName + " key `" + _key2 + "` supplied to `" + componentName + "`." + '\nBad object: ' + JSON.stringify(props[propName], null, '  ') + '\nValid keys: ' + JSON.stringify(Object.keys(shapeTypes), null, '  '));
        }

        var error = checker.apply(void 0, [propValue, _key2, componentName, location].concat(rest));

        if (error) {
          invariant(false, error.message + '\nBad object: ' + JSON.stringify(props[propName], null, '  '));
        }
      }
    }

    function chainedCheckType(props, propName, componentName, location) {
      for (var _len2 = arguments.length, rest = new Array(_len2 > 4 ? _len2 - 4 : 0), _key3 = 4; _key3 < _len2; _key3++) {
        rest[_key3 - 4] = arguments[_key3];
      }

      return checkType.apply(void 0, [false, props, propName, componentName, location].concat(rest));
    }

    chainedCheckType.isRequired = checkType.bind(null, true);
    return chainedCheckType;
  }

  module.exports = deprecatedCreateStrictShapeTypeChecker;
},239,[3,231],"node_modules/react-native/Libraries/DeprecatedPropTypes/deprecatedCreateStrictShapeTypeChecker.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var React = _$$_REQUIRE(_dependencyMap[0], "react");

  module.exports = React.createContext(false);
},240,[54],"node_modules/react-native/Libraries/Text/TextAncestor.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _objectWithoutProperties = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/objectWithoutProperties");

  var _defineProperty = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/defineProperty");

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native/Libraries/Components/Touchable/Touchable.js";

  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

  var BoundingDimensions = _$$_REQUIRE(_dependencyMap[2], "./BoundingDimensions");

  var Platform = _$$_REQUIRE(_dependencyMap[3], "../../Utilities/Platform");

  var Position = _$$_REQUIRE(_dependencyMap[4], "./Position");

  var React = _$$_REQUIRE(_dependencyMap[5], "react");

  var ReactNative = _$$_REQUIRE(_dependencyMap[6], "../../Renderer/shims/ReactNative");

  var StyleSheet = _$$_REQUIRE(_dependencyMap[7], "../../StyleSheet/StyleSheet");

  var TVEventHandler = _$$_REQUIRE(_dependencyMap[8], "../AppleTV/TVEventHandler");

  var UIManager = _$$_REQUIRE(_dependencyMap[9], "../../ReactNative/UIManager");

  var View = _$$_REQUIRE(_dependencyMap[10], "../View/View");

  var keyMirror = _$$_REQUIRE(_dependencyMap[11], "fbjs/lib/keyMirror");

  var normalizeColor = _$$_REQUIRE(_dependencyMap[12], "../../Color/normalizeColor");

  var extractSingleTouch = function extractSingleTouch(nativeEvent) {
    var touches = nativeEvent.touches;
    var changedTouches = nativeEvent.changedTouches;
    var hasTouches = touches && touches.length > 0;
    var hasChangedTouches = changedTouches && changedTouches.length > 0;
    return !hasTouches && hasChangedTouches ? changedTouches[0] : hasTouches ? touches[0] : nativeEvent;
  };

  var States = keyMirror({
    NOT_RESPONDER: null,
    RESPONDER_INACTIVE_PRESS_IN: null,
    RESPONDER_INACTIVE_PRESS_OUT: null,
    RESPONDER_ACTIVE_PRESS_IN: null,
    RESPONDER_ACTIVE_PRESS_OUT: null,
    RESPONDER_ACTIVE_LONG_PRESS_IN: null,
    RESPONDER_ACTIVE_LONG_PRESS_OUT: null,
    ERROR: null
  });
  var 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
  };

  var IsActive = _objectSpread({}, baseStatesConditions, {
    RESPONDER_ACTIVE_PRESS_OUT: true,
    RESPONDER_ACTIVE_PRESS_IN: true
  });

  var IsPressingIn = _objectSpread({}, baseStatesConditions, {
    RESPONDER_INACTIVE_PRESS_IN: true,
    RESPONDER_ACTIVE_PRESS_IN: true,
    RESPONDER_ACTIVE_LONG_PRESS_IN: true
  });

  var IsLongPressingIn = _objectSpread({}, baseStatesConditions, {
    RESPONDER_ACTIVE_LONG_PRESS_IN: true
  });

  var 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
  });
  var 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
    }
  };
  var HIGHLIGHT_DELAY_MS = 130;
  var PRESS_EXPAND_PX = 20;
  var LONG_PRESS_THRESHOLD = 500;
  var LONG_PRESS_DELAY_MS = LONG_PRESS_THRESHOLD - HIGHLIGHT_DELAY_MS;
  var LONG_PRESS_ALLOWED_MOVEMENT = 10;
  var TouchableMixin = {
    componentDidMount: function componentDidMount() {
      if (!Platform.isTV) {
        return;
      }

      this._tvEventHandler = new TVEventHandler();

      this._tvEventHandler.enable(this, function (cmp, evt) {
        var 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') {
            cmp.touchableHandlePress && !cmp.props.disabled && cmp.touchableHandlePress(evt);
          }
        }
      });
    },
    componentWillUnmount: function componentWillUnmount() {
      if (this._tvEventHandler) {
        this._tvEventHandler.disable();

        delete this._tvEventHandler;
      }

      this.touchableDelayTimeout && clearTimeout(this.touchableDelayTimeout);
      this.longPressDelayTimeout && clearTimeout(this.longPressDelayTimeout);
      this.pressOutDelayTimeout && clearTimeout(this.pressOutDelayTimeout);
    },
    touchableGetInitialState: function touchableGetInitialState() {
      return {
        touchable: {
          touchState: undefined,
          responderID: null
        }
      };
    },
    touchableHandleResponderTerminationRequest: function touchableHandleResponderTerminationRequest() {
      return !this.props.rejectResponderTermination;
    },
    touchableHandleStartShouldSetResponder: function touchableHandleStartShouldSetResponder() {
      return !this.props.disabled;
    },
    touchableLongPressCancelsPress: function touchableLongPressCancelsPress() {
      return true;
    },
    touchableHandleResponderGrant: function touchableHandleResponderGrant(e) {
      var dispatchID = e.currentTarget;
      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);

      var 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);
      }

      var 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);
    },
    touchableHandleResponderRelease: function touchableHandleResponderRelease(e) {
      this.pressInLocation = null;

      this._receiveSignal(Signals.RESPONDER_RELEASE, e);
    },
    touchableHandleResponderTerminate: function touchableHandleResponderTerminate(e) {
      this.pressInLocation = null;

      this._receiveSignal(Signals.RESPONDER_TERMINATED, e);
    },
    touchableHandleResponderMove: function touchableHandleResponderMove(e) {
      if (!this.state.touchable.positionOnActivate) {
        return;
      }

      var positionOnActivate = this.state.touchable.positionOnActivate;
      var dimensionsOnActivate = this.state.touchable.dimensionsOnActivate;
      var pressRectOffset = this.touchableGetPressRectOffset ? this.touchableGetPressRectOffset() : {
        left: PRESS_EXPAND_PX,
        right: PRESS_EXPAND_PX,
        top: PRESS_EXPAND_PX,
        bottom: PRESS_EXPAND_PX
      };
      var pressExpandLeft = pressRectOffset.left;
      var pressExpandTop = pressRectOffset.top;
      var pressExpandRight = pressRectOffset.right;
      var pressExpandBottom = pressRectOffset.bottom;
      var hitSlop = this.touchableGetHitSlop ? this.touchableGetHitSlop() : null;

      if (hitSlop) {
        pressExpandLeft += hitSlop.left || 0;
        pressExpandTop += hitSlop.top || 0;
        pressExpandRight += hitSlop.right || 0;
        pressExpandBottom += hitSlop.bottom || 0;
      }

      var touch = extractSingleTouch(e.nativeEvent);
      var pageX = touch && touch.pageX;
      var pageY = touch && touch.pageY;

      if (this.pressInLocation) {
        var movedDistance = this._getDistanceBetweenPoints(pageX, pageY, this.pressInLocation.pageX, this.pressInLocation.pageY);

        if (movedDistance > LONG_PRESS_ALLOWED_MOVEMENT) {
          this._cancelLongPressDelayTimeout();
        }
      }

      var isTouchWithinActive = pageX > positionOnActivate.left - pressExpandLeft && pageY > positionOnActivate.top - pressExpandTop && pageX < positionOnActivate.left + dimensionsOnActivate.width + pressExpandRight && pageY < positionOnActivate.top + dimensionsOnActivate.height + pressExpandBottom;

      if (isTouchWithinActive) {
        var prevState = this.state.touchable.touchState;

        this._receiveSignal(Signals.ENTER_PRESS_RECT, e);

        var curState = this.state.touchable.touchState;

        if (curState === States.RESPONDER_INACTIVE_PRESS_IN && prevState !== States.RESPONDER_INACTIVE_PRESS_IN) {
          this._cancelLongPressDelayTimeout();
        }
      } else {
        this._cancelLongPressDelayTimeout();

        this._receiveSignal(Signals.LEAVE_PRESS_RECT, e);
      }
    },
    touchableHandleFocus: function touchableHandleFocus(e) {
      this.props.onFocus && this.props.onFocus(e);
    },
    touchableHandleBlur: function touchableHandleBlur(e) {
      this.props.onBlur && this.props.onBlur(e);
    },
    _remeasureMetricsOnActivation: function _remeasureMetricsOnActivation() {
      var tag = this.state.touchable.responderID;

      if (tag == null) {
        return;
      }

      UIManager.measure(tag, this._handleQueryLayout);
    },
    _handleQueryLayout: function _handleQueryLayout(l, t, w, h, globalX, globalY) {
      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 _handleDelay(e) {
      this.touchableDelayTimeout = null;

      this._receiveSignal(Signals.DELAY, e);
    },
    _handleLongDelay: function _handleLongDelay(e) {
      this.longPressDelayTimeout = null;
      var curState = this.state.touchable.touchState;

      if (curState !== States.RESPONDER_ACTIVE_PRESS_IN && curState !== States.RESPONDER_ACTIVE_LONG_PRESS_IN) {
        console.error('Attempted to transition from state `' + curState + '` to `' + States.RESPONDER_ACTIVE_LONG_PRESS_IN + '`, which is not supported. This is ' + 'most likely due to `Touchable.longPressDelayTimeout` not being cancelled.');
      } else {
        this._receiveSignal(Signals.LONG_PRESS_DETECTED, e);
      }
    },
    _receiveSignal: function _receiveSignal(signal, e) {
      var responderID = this.state.touchable.responderID;
      var curState = this.state.touchable.touchState;
      var 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 `' + responderID + '`');
      }

      if (nextState === States.ERROR) {
        throw new Error('Touchable cannot transition from `' + curState + '` to `' + signal + '` for responder `' + responderID + '`');
      }

      if (curState !== nextState) {
        this._performSideEffectsForTransition(curState, nextState, signal, e);

        this.state.touchable.touchState = nextState;
      }
    },
    _cancelLongPressDelayTimeout: function _cancelLongPressDelayTimeout() {
      this.longPressDelayTimeout && clearTimeout(this.longPressDelayTimeout);
      this.longPressDelayTimeout = null;
    },
    _isHighlight: function _isHighlight(state) {
      return state === States.RESPONDER_ACTIVE_PRESS_IN || state === States.RESPONDER_ACTIVE_LONG_PRESS_IN;
    },
    _savePressInLocation: function _savePressInLocation(e) {
      var touch = extractSingleTouch(e.nativeEvent);
      var pageX = touch && touch.pageX;
      var pageY = touch && touch.pageY;
      var locationX = touch && touch.locationX;
      var locationY = touch && touch.locationY;
      this.pressInLocation = {
        pageX: pageX,
        pageY: pageY,
        locationX: locationX,
        locationY: locationY
      };
    },
    _getDistanceBetweenPoints: function _getDistanceBetweenPoints(aX, aY, bX, bY) {
      var deltaX = aX - bX;
      var deltaY = aY - bY;
      return Math.sqrt(deltaX * deltaX + deltaY * deltaY);
    },
    _performSideEffectsForTransition: function _performSideEffectsForTransition(curState, nextState, signal, e) {
      var curIsHighlight = this._isHighlight(curState);

      var newIsHighlight = this._isHighlight(nextState);

      var isFinalSignal = signal === Signals.RESPONDER_TERMINATED || signal === Signals.RESPONDER_RELEASE;

      if (isFinalSignal) {
        this._cancelLongPressDelayTimeout();
      }

      var isInitialTransition = curState === States.NOT_RESPONDER && nextState === States.RESPONDER_INACTIVE_PRESS_IN;
      var 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) {
        var hasLongPressHandler = !!this.props.onLongPress;
        var pressIsLongButStillCallOnPress = IsLongPressingIn[curState] && (!hasLongPressHandler || !this.touchableLongPressCancelsPress());
        var shouldInvokePress = !IsLongPressingIn[curState] || pressIsLongButStillCallOnPress;

        if (shouldInvokePress && this.touchableHandlePress) {
          if (!newIsHighlight && !curIsHighlight) {
            this._startHighlight(e);

            this._endHighlight(e);
          }

          if ("android" === 'android' && !this.props.touchSoundDisabled) {
            this._playTouchSound();
          }

          this.touchableHandlePress(e);
        }
      }

      this.touchableDelayTimeout && clearTimeout(this.touchableDelayTimeout);
      this.touchableDelayTimeout = null;
    },
    _playTouchSound: function _playTouchSound() {
      UIManager.playTouchSound();
    },
    _startHighlight: function _startHighlight(e) {
      this._savePressInLocation(e);

      this.touchableHandleActivePressIn && this.touchableHandleActivePressIn(e);
    },
    _endHighlight: function _endHighlight(e) {
      var _this = this;

      if (this.touchableHandleActivePressOut) {
        if (this.touchableGetPressOutDelayMS && this.touchableGetPressOutDelayMS()) {
          this.pressOutDelayTimeout = setTimeout(function () {
            _this.touchableHandleActivePressOut(e);
          }, this.touchableGetPressOutDelayMS());
        } else {
          this.touchableHandleActivePressOut(e);
        }
      }
    },
    withoutDefaultFocusAndBlur: {}
  };

  var touchableHandleFocus = TouchableMixin.touchableHandleFocus,
      touchableHandleBlur = TouchableMixin.touchableHandleBlur,
      TouchableMixinWithoutDefaultFocusAndBlur = _objectWithoutProperties(TouchableMixin, ["touchableHandleFocus", "touchableHandleBlur"]);

  TouchableMixin.withoutDefaultFocusAndBlur = TouchableMixinWithoutDefaultFocusAndBlur;
  var Touchable = {
    Mixin: TouchableMixin,
    TOUCH_TARGET_DEBUG: false,
    renderDebugView: function renderDebugView(_ref) {
      var color = _ref.color,
          hitSlop = _ref.hitSlop;

      if (!Touchable.TOUCH_TARGET_DEBUG) {
        return null;
      }

      if (!__DEV__) {
        throw Error('Touchable.TOUCH_TARGET_DEBUG should not be enabled in prod!');
      }

      var debugHitSlopStyle = {};
      hitSlop = hitSlop || {
        top: 0,
        bottom: 0,
        left: 0,
        right: 0
      };

      for (var key in hitSlop) {
        debugHitSlopStyle[key] = -hitSlop[key];
      }

      var normalizedColor = normalizeColor(color);

      if (typeof normalizedColor !== 'number') {
        return null;
      }

      var hexColor = '#' + ('00000000' + normalizedColor.toString(16)).substr(-8);
      return React.createElement(View, {
        pointerEvents: "none",
        style: [styles.debug, _objectSpread({
          borderColor: hexColor.slice(0, -2) + '55',
          backgroundColor: hexColor.slice(0, -2) + '0F'
        }, debugHitSlopStyle)],
        __source: {
          fileName: _jsxFileName,
          lineNumber: 961
        }
      });
    }
  };
  var styles = StyleSheet.create({
    debug: {
      position: 'absolute',
      borderWidth: 1,
      borderStyle: 'dashed'
    }
  });
  module.exports = Touchable;
},241,[52,46,242,48,244,54,88,60,245,43,86,247,67],"node_modules/react-native/Libraries/Components/Touchable/Touchable.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var PooledClass = _$$_REQUIRE(_dependencyMap[0], "./PooledClass");

  var twoArgumentPooler = PooledClass.twoArgumentPooler;

  function BoundingDimensions(width, height) {
    this.width = width;
    this.height = height;
  }

  BoundingDimensions.prototype.destructor = function () {
    this.width = null;
    this.height = null;
  };

  BoundingDimensions.getPooledFromElement = function (element) {
    return BoundingDimensions.getPooled(element.offsetWidth, element.offsetHeight);
  };

  PooledClass.addPoolingTo(BoundingDimensions, twoArgumentPooler);
  module.exports = BoundingDimensions;
},242,[243],"node_modules/react-native/Libraries/Components/Touchable/BoundingDimensions.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var invariant = _$$_REQUIRE(_dependencyMap[0], "invariant");

  var oneArgumentPooler = function oneArgumentPooler(copyFieldsFrom) {
    var Klass = this;

    if (Klass.instancePool.length) {
      var _instance = Klass.instancePool.pop();

      Klass.call(_instance, copyFieldsFrom);
      return _instance;
    } else {
      return new Klass(copyFieldsFrom);
    }
  };

  var twoArgumentPooler = function twoArgumentPooler(a1, a2) {
    var Klass = this;

    if (Klass.instancePool.length) {
      var _instance2 = Klass.instancePool.pop();

      Klass.call(_instance2, a1, a2);
      return _instance2;
    } else {
      return new Klass(a1, a2);
    }
  };

  var threeArgumentPooler = function threeArgumentPooler(a1, a2, a3) {
    var Klass = this;

    if (Klass.instancePool.length) {
      var _instance3 = Klass.instancePool.pop();

      Klass.call(_instance3, a1, a2, a3);
      return _instance3;
    } else {
      return new Klass(a1, a2, a3);
    }
  };

  var fourArgumentPooler = function fourArgumentPooler(a1, a2, a3, a4) {
    var Klass = this;

    if (Klass.instancePool.length) {
      var _instance4 = Klass.instancePool.pop();

      Klass.call(_instance4, a1, a2, a3, a4);
      return _instance4;
    } else {
      return new Klass(a1, a2, a3, a4);
    }
  };

  var standardReleaser = function standardReleaser(instance) {
    var 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);
    }
  };

  var DEFAULT_POOL_SIZE = 10;
  var DEFAULT_POOLER = oneArgumentPooler;

  var addPoolingTo = function addPoolingTo(CopyConstructor, pooler) {
    var NewKlass = CopyConstructor;
    NewKlass.instancePool = [];
    NewKlass.getPooled = pooler || DEFAULT_POOLER;

    if (!NewKlass.poolSize) {
      NewKlass.poolSize = DEFAULT_POOL_SIZE;
    }

    NewKlass.release = standardReleaser;
    return NewKlass;
  };

  var PooledClass = {
    addPoolingTo: addPoolingTo,
    oneArgumentPooler: oneArgumentPooler,
    twoArgumentPooler: twoArgumentPooler,
    threeArgumentPooler: threeArgumentPooler,
    fourArgumentPooler: fourArgumentPooler
  };
  module.exports = PooledClass;
},243,[3],"node_modules/react-native/Libraries/Components/Touchable/PooledClass.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var PooledClass = _$$_REQUIRE(_dependencyMap[0], "./PooledClass");

  var twoArgumentPooler = PooledClass.twoArgumentPooler;

  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;
},244,[243],"node_modules/react-native/Libraries/Components/Touchable/Position.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _NativeTVNavigationEventEmitter = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./NativeTVNavigationEventEmitter"));

  var Platform = _$$_REQUIRE(_dependencyMap[2], "../../Utilities/Platform");

  var NativeEventEmitter = _$$_REQUIRE(_dependencyMap[3], "../../EventEmitter/NativeEventEmitter");

  function TVEventHandler() {
    this.__nativeTVNavigationEventListener = null;
    this.__nativeTVNavigationEventEmitter = null;
  }

  TVEventHandler.prototype.enable = function (component, callback) {
    if ("android" === 'ios' && !_NativeTVNavigationEventEmitter.default) {
      return;
    }

    this.__nativeTVNavigationEventEmitter = new NativeEventEmitter(_NativeTVNavigationEventEmitter.default);
    this.__nativeTVNavigationEventListener = this.__nativeTVNavigationEventEmitter.addListener('onHWKeyEvent', function (data) {
      if (callback) {
        callback(component, data);
      }
    });
  };

  TVEventHandler.prototype.disable = function () {
    if (this.__nativeTVNavigationEventListener) {
      this.__nativeTVNavigationEventListener.remove();

      delete this.__nativeTVNavigationEventListener;
    }

    if (this.__nativeTVNavigationEventEmitter) {
      delete this.__nativeTVNavigationEventEmitter;
    }
  };

  module.exports = TVEventHandler;
},245,[1,246,48,134],"node_modules/react-native/Libraries/Components/AppleTV/TVEventHandler.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireWildcard");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[1], "../../TurboModule/TurboModuleRegistry"));

  var _default = TurboModuleRegistry.get('TVNavigationEventEmitter');

  exports.default = _default;
},246,[9,11],"node_modules/react-native/Libraries/Components/AppleTV/NativeTVNavigationEventEmitter.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var invariant = _$$_REQUIRE(_dependencyMap[0], "./invariant");

  var keyMirror = function keyMirror(obj) {
    var ret = {};
    var key;
    !(obj instanceof Object && !Array.isArray(obj)) ? process.env.NODE_ENV !== "production" ? invariant(false, 'keyMirror(...): Argument must be an object.') : invariant(false) : void 0;

    for (key in obj) {
      if (!obj.hasOwnProperty(key)) {
        continue;
      }

      ret[key] = key;
    }

    return ret;
  };

  module.exports = keyMirror;
},247,[248],"node_modules/fbjs/lib/keyMirror.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var validateFormat = process.env.NODE_ENV !== "production" ? function (format) {} : function (format) {
    if (format === undefined) {
      throw new Error('invariant(...): Second argument must be a string.');
    }
  };

  function invariant(condition, format) {
    for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
      args[_key - 2] = arguments[_key];
    }

    validateFormat(format);

    if (!condition) {
      var error;

      if (format === undefined) {
        error = new Error('Minified exception occurred; use the non-minified dev environment ' + 'for the full error message and additional helpful warnings.');
      } else {
        var argIndex = 0;
        error = new Error(format.replace(/%s/g, function () {
          return String(args[argIndex++]);
        }));
        error.name = 'Invariant Violation';
      }

      error.framesToPop = 1;
      throw error;
    }
  }

  module.exports = invariant;
},248,[],"node_modules/fbjs/lib/invariant.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  function nullthrows(x, message) {
    if (x != null) {
      return x;
    }

    var error = new Error(message !== undefined ? message : 'Got unexpected ' + x);
    error.framesToPop = 1;
    throw error;
  }

  module.exports = nullthrows;
  module.exports.default = nullthrows;
  Object.defineProperty(module.exports, '__esModule', {
    value: true
  });
},249,[],"node_modules/nullthrows/nullthrows.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");

  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

  var Platform = _$$_REQUIRE(_dependencyMap[1], "../../Utilities/Platform");

  var React = _$$_REQUIRE(_dependencyMap[2], "react");

  var PropTypes = _$$_REQUIRE(_dependencyMap[3], "prop-types");

  var ReactNative = _$$_REQUIRE(_dependencyMap[4], "../../Renderer/shims/ReactNative");

  var Touchable = _$$_REQUIRE(_dependencyMap[5], "./Touchable");

  var TouchableWithoutFeedback = _$$_REQUIRE(_dependencyMap[6], "./TouchableWithoutFeedback");

  var UIManager = _$$_REQUIRE(_dependencyMap[7], "../../ReactNative/UIManager");

  var View = _$$_REQUIRE(_dependencyMap[8], "../View/View");

  var createReactClass = _$$_REQUIRE(_dependencyMap[9], "create-react-class");

  var ensurePositiveDelayProps = _$$_REQUIRE(_dependencyMap[10], "./ensurePositiveDelayProps");

  var processColor = _$$_REQUIRE(_dependencyMap[11], "../../StyleSheet/processColor");

  var rippleBackgroundPropType = PropTypes.shape({
    type: PropTypes.oneOf(['RippleAndroid']),
    color: PropTypes.number,
    borderless: PropTypes.bool
  });
  var themeAttributeBackgroundPropType = PropTypes.shape({
    type: PropTypes.oneOf(['ThemeAttrAndroid']),
    attribute: PropTypes.string.isRequired
  });
  var backgroundPropType = PropTypes.oneOfType([rippleBackgroundPropType, themeAttributeBackgroundPropType]);
  var PRESS_RETENTION_OFFSET = {
    top: 20,
    left: 20,
    right: 20,
    bottom: 30
  };
  var TouchableNativeFeedback = createReactClass({
    displayName: 'TouchableNativeFeedback',
    propTypes: _objectSpread({}, TouchableWithoutFeedback.propTypes, {
      background: backgroundPropType,
      hasTVPreferredFocus: PropTypes.bool,
      nextFocusDown: PropTypes.number,
      nextFocusForward: PropTypes.number,
      nextFocusLeft: PropTypes.number,
      nextFocusRight: PropTypes.number,
      nextFocusUp: PropTypes.number,
      useForeground: PropTypes.bool
    }),
    statics: {
      SelectableBackground: function SelectableBackground() {
        return {
          type: 'ThemeAttrAndroid',
          attribute: 'selectableItemBackground'
        };
      },
      SelectableBackgroundBorderless: function SelectableBackgroundBorderless() {
        return {
          type: 'ThemeAttrAndroid',
          attribute: 'selectableItemBackgroundBorderless'
        };
      },
      Ripple: function Ripple(color, borderless) {
        return {
          type: 'RippleAndroid',
          color: processColor(color),
          borderless: borderless
        };
      },
      canUseNativeForeground: function canUseNativeForeground() {
        return "android" === 'android' && Platform.Version >= 23;
      }
    },
    mixins: [Touchable.Mixin],
    getDefaultProps: function getDefaultProps() {
      return {
        background: this.SelectableBackground()
      };
    },
    getInitialState: function getInitialState() {
      return this.touchableGetInitialState();
    },
    componentDidMount: function componentDidMount() {
      ensurePositiveDelayProps(this.props);
    },
    UNSAFE_componentWillReceiveProps: function UNSAFE_componentWillReceiveProps(nextProps) {
      ensurePositiveDelayProps(nextProps);
    },
    touchableHandleActivePressIn: function touchableHandleActivePressIn(e) {
      this.props.onPressIn && this.props.onPressIn(e);

      this._dispatchPressedStateChange(true);

      if (this.pressInLocation) {
        this._dispatchHotspotUpdate(this.pressInLocation.locationX, this.pressInLocation.locationY);
      }
    },
    touchableHandleActivePressOut: function touchableHandleActivePressOut(e) {
      this.props.onPressOut && this.props.onPressOut(e);

      this._dispatchPressedStateChange(false);
    },
    touchableHandlePress: function touchableHandlePress(e) {
      this.props.onPress && this.props.onPress(e);
    },
    touchableHandleLongPress: function touchableHandleLongPress(e) {
      this.props.onLongPress && this.props.onLongPress(e);
    },
    touchableGetPressRectOffset: function touchableGetPressRectOffset() {
      return this.props.pressRetentionOffset || PRESS_RETENTION_OFFSET;
    },
    touchableGetHitSlop: function touchableGetHitSlop() {
      return this.props.hitSlop;
    },
    touchableGetHighlightDelayMS: function touchableGetHighlightDelayMS() {
      return this.props.delayPressIn;
    },
    touchableGetLongPressDelayMS: function touchableGetLongPressDelayMS() {
      return this.props.delayLongPress;
    },
    touchableGetPressOutDelayMS: function touchableGetPressOutDelayMS() {
      return this.props.delayPressOut;
    },
    _handleResponderMove: function _handleResponderMove(e) {
      this.touchableHandleResponderMove(e);

      this._dispatchHotspotUpdate(e.nativeEvent.locationX, e.nativeEvent.locationY);
    },
    _dispatchHotspotUpdate: function _dispatchHotspotUpdate(destX, destY) {
      UIManager.dispatchViewManagerCommand(ReactNative.findNodeHandle(this), UIManager.getViewManagerConfig('RCTView').Commands.hotspotUpdate, [destX || 0, destY || 0]);
    },
    _dispatchPressedStateChange: function _dispatchPressedStateChange(pressed) {
      UIManager.dispatchViewManagerCommand(ReactNative.findNodeHandle(this), UIManager.getViewManagerConfig('RCTView').Commands.setPressed, [pressed]);
    },
    render: function render() {
      var _objectSpread2;

      var child = React.Children.only(this.props.children);
      var children = child.props.children;

      if (Touchable.TOUCH_TARGET_DEBUG && child.type === View) {
        if (!Array.isArray(children)) {
          children = [children];
        }

        children.push(Touchable.renderDebugView({
          color: 'brown',
          hitSlop: this.props.hitSlop
        }));
      }

      if (this.props.useForeground && !TouchableNativeFeedback.canUseNativeForeground()) {
        console.warn('Requested foreground ripple, but it is not available on this version of Android. ' + 'Consider calling TouchableNativeFeedback.canUseNativeForeground() and using a different ' + 'Touchable if the result is false.');
      }

      var drawableProp = this.props.useForeground && TouchableNativeFeedback.canUseNativeForeground() ? 'nativeForegroundAndroid' : 'nativeBackgroundAndroid';

      var childProps = _objectSpread({}, child.props, (_objectSpread2 = {}, _defineProperty(_objectSpread2, drawableProp, this.props.background), _defineProperty(_objectSpread2, "accessible", this.props.accessible !== false), _defineProperty(_objectSpread2, "accessibilityLabel", this.props.accessibilityLabel), _defineProperty(_objectSpread2, "accessibilityRole", this.props.accessibilityRole), _defineProperty(_objectSpread2, "accessibilityStates", this.props.accessibilityStates), _defineProperty(_objectSpread2, "accessibilityState", this.props.accessibilityState), _defineProperty(_objectSpread2, "accessibilityActions", this.props.accessibilityActions), _defineProperty(_objectSpread2, "onAccessibilityAction", this.props.onAccessibilityAction), _defineProperty(_objectSpread2, "children", children), _defineProperty(_objectSpread2, "testID", this.props.testID), _defineProperty(_objectSpread2, "onLayout", this.props.onLayout), _defineProperty(_objectSpread2, "hitSlop", this.props.hitSlop), _defineProperty(_objectSpread2, "isTVSelectable", true), _defineProperty(_objectSpread2, "nextFocusDown", this.props.nextFocusDown), _defineProperty(_objectSpread2, "nextFocusForward", this.props.nextFocusForward), _defineProperty(_objectSpread2, "nextFocusLeft", this.props.nextFocusLeft), _defineProperty(_objectSpread2, "nextFocusRight", this.props.nextFocusRight), _defineProperty(_objectSpread2, "nextFocusUp", this.props.nextFocusUp), _defineProperty(_objectSpread2, "hasTVPreferredFocus", this.props.hasTVPreferredFocus), _defineProperty(_objectSpread2, "focusable", this.props.focusable !== false && this.props.onPress !== undefined && !this.props.disabled), _defineProperty(_objectSpread2, "onClick", this.touchableHandlePress), _defineProperty(_objectSpread2, "onStartShouldSetResponder", this.touchableHandleStartShouldSetResponder), _defineProperty(_objectSpread2, "onResponderTerminationRequest", this.touchableHandleResponderTerminationRequest), _defineProperty(_objectSpread2, "onResponderGrant", this.touchableHandleResponderGrant), _defineProperty(_objectSpread2, "onResponderMove", this._handleResponderMove), _defineProperty(_objectSpread2, "onResponderRelease", this.touchableHandleResponderRelease), _defineProperty(_objectSpread2, "onResponderTerminate", this.touchableHandleResponderTerminate), _objectSpread2));

      return React.cloneElement(child, childProps);
    }
  });
  module.exports = TouchableNativeFeedback;
},250,[46,48,54,69,88,241,251,43,86,252,258,80],"node_modules/react-native/Libraries/Components/Touchable/TouchableNativeFeedback.android.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");

  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

  var DeprecatedEdgeInsetsPropType = _$$_REQUIRE(_dependencyMap[1], "../../DeprecatedPropTypes/DeprecatedEdgeInsetsPropType");

  var React = _$$_REQUIRE(_dependencyMap[2], "react");

  var PropTypes = _$$_REQUIRE(_dependencyMap[3], "prop-types");

  var Touchable = _$$_REQUIRE(_dependencyMap[4], "./Touchable");

  var View = _$$_REQUIRE(_dependencyMap[5], "../View/View");

  var createReactClass = _$$_REQUIRE(_dependencyMap[6], "create-react-class");

  var ensurePositiveDelayProps = _$$_REQUIRE(_dependencyMap[7], "./ensurePositiveDelayProps");

  var _require = _$$_REQUIRE(_dependencyMap[8], "../../DeprecatedPropTypes/DeprecatedViewAccessibility"),
      DeprecatedAccessibilityRoles = _require.DeprecatedAccessibilityRoles;

  var PRESS_RETENTION_OFFSET = {
    top: 20,
    left: 20,
    right: 20,
    bottom: 30
  };
  var OVERRIDE_PROPS = ['accessibilityLabel', 'accessibilityHint', 'accessibilityIgnoresInvertColors', 'accessibilityRole', 'accessibilityStates', 'accessibilityState', 'accessibilityActions', 'onAccessibilityAction', 'hitSlop', 'nativeID', 'onBlur', 'onFocus', 'onLayout', 'testID'];
  var TouchableWithoutFeedback = createReactClass({
    displayName: 'TouchableWithoutFeedback',
    mixins: [Touchable.Mixin],
    propTypes: {
      accessible: PropTypes.bool,
      accessibilityLabel: PropTypes.node,
      accessibilityHint: PropTypes.string,
      accessibilityIgnoresInvertColors: PropTypes.bool,
      accessibilityRole: PropTypes.oneOf(DeprecatedAccessibilityRoles),
      accessibilityStates: PropTypes.array,
      accessibilityState: PropTypes.object,
      accessibilityActions: PropTypes.array,
      onAccessibilityAction: PropTypes.func,
      onFocus: PropTypes.func,
      onBlur: PropTypes.func,
      disabled: PropTypes.bool,
      onPress: PropTypes.func,
      onPressIn: PropTypes.func,
      onPressOut: PropTypes.func,
      onLayout: PropTypes.func,
      touchSoundDisabled: PropTypes.bool,
      onLongPress: PropTypes.func,
      nativeID: PropTypes.string,
      testID: PropTypes.string,
      delayPressIn: PropTypes.number,
      delayPressOut: PropTypes.number,
      delayLongPress: PropTypes.number,
      pressRetentionOffset: DeprecatedEdgeInsetsPropType,
      hitSlop: DeprecatedEdgeInsetsPropType
    },
    getInitialState: function getInitialState() {
      return this.touchableGetInitialState();
    },
    componentDidMount: function componentDidMount() {
      ensurePositiveDelayProps(this.props);
    },
    UNSAFE_componentWillReceiveProps: function UNSAFE_componentWillReceiveProps(nextProps) {
      ensurePositiveDelayProps(nextProps);
    },
    touchableHandlePress: function touchableHandlePress(e) {
      this.props.onPress && this.props.onPress(e);
    },
    touchableHandleActivePressIn: function touchableHandleActivePressIn(e) {
      this.props.onPressIn && this.props.onPressIn(e);
    },
    touchableHandleActivePressOut: function touchableHandleActivePressOut(e) {
      this.props.onPressOut && this.props.onPressOut(e);
    },
    touchableHandleLongPress: function touchableHandleLongPress(e) {
      this.props.onLongPress && this.props.onLongPress(e);
    },
    touchableGetPressRectOffset: function touchableGetPressRectOffset() {
      return this.props.pressRetentionOffset || PRESS_RETENTION_OFFSET;
    },
    touchableGetHitSlop: function touchableGetHitSlop() {
      return this.props.hitSlop;
    },
    touchableGetHighlightDelayMS: function touchableGetHighlightDelayMS() {
      return this.props.delayPressIn || 0;
    },
    touchableGetLongPressDelayMS: function touchableGetLongPressDelayMS() {
      return this.props.delayLongPress === 0 ? 0 : this.props.delayLongPress || 500;
    },
    touchableGetPressOutDelayMS: function touchableGetPressOutDelayMS() {
      return this.props.delayPressOut || 0;
    },
    render: function render() {
      var child = React.Children.only(this.props.children);
      var children = child.props.children;

      if (Touchable.TOUCH_TARGET_DEBUG && child.type === View) {
        children = React.Children.toArray(children);
        children.push(Touchable.renderDebugView({
          color: 'red',
          hitSlop: this.props.hitSlop
        }));
      }

      var overrides = {};

      for (var _iterator = OVERRIDE_PROPS, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"]();;) {
        var _ref;

        if (_isArray) {
          if (_i >= _iterator.length) break;
          _ref = _iterator[_i++];
        } else {
          _i = _iterator.next();
          if (_i.done) break;
          _ref = _i.value;
        }

        var _prop = _ref;

        if (this.props[_prop] !== undefined) {
          overrides[_prop] = this.props[_prop];
        }
      }

      return React.cloneElement(child, _objectSpread({}, overrides, {
        accessible: this.props.accessible !== false,
        focusable: this.props.focusable !== false && this.props.onPress !== undefined,
        onClick: this.touchableHandlePress,
        onStartShouldSetResponder: this.touchableHandleStartShouldSetResponder,
        onResponderTerminationRequest: this.touchableHandleResponderTerminationRequest,
        onResponderGrant: this.touchableHandleResponderGrant,
        onResponderMove: this.touchableHandleResponderMove,
        onResponderRelease: this.touchableHandleResponderRelease,
        onResponderTerminate: this.touchableHandleResponderTerminate,
        children: children
      }));
    }
  });
  module.exports = TouchableWithoutFeedback;
},251,[46,237,54,69,241,86,252,258,259],"node_modules/react-native/Libraries/Components/Touchable/TouchableWithoutFeedback.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var React = _$$_REQUIRE(_dependencyMap[0], "react");

  var factory = _$$_REQUIRE(_dependencyMap[1], "./factory");

  if (typeof React === 'undefined') {
    throw Error('create-react-class could not find the React object. If you are using script tags, ' + 'make sure that React is being loaded before create-react-class.');
  }

  var ReactNoopUpdateQueue = new React.Component().updater;
  module.exports = factory(React.Component, React.isValidElement, ReactNoopUpdateQueue);
},252,[54,253],"node_modules/create-react-class/index.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _assign = _$$_REQUIRE(_dependencyMap[0], "object-assign");

  var emptyObject = _$$_REQUIRE(_dependencyMap[1], "fbjs/lib/emptyObject");

  var _invariant = _$$_REQUIRE(_dependencyMap[2], "fbjs/lib/invariant");

  if (process.env.NODE_ENV !== 'production') {
    var warning = _$$_REQUIRE(_dependencyMap[3], "fbjs/lib/warning");
  }

  var MIXINS_KEY = 'mixins';

  function identity(fn) {
    return fn;
  }

  var ReactPropTypeLocationNames;

  if (process.env.NODE_ENV !== 'production') {
    ReactPropTypeLocationNames = {
      prop: 'prop',
      context: 'context',
      childContext: 'child context'
    };
  } else {
    ReactPropTypeLocationNames = {};
  }

  function factory(ReactComponent, isValidElement, ReactNoopUpdateQueue) {
    var injectedMixins = [];
    var ReactClassInterface = {
      mixins: 'DEFINE_MANY',
      statics: 'DEFINE_MANY',
      propTypes: 'DEFINE_MANY',
      contextTypes: 'DEFINE_MANY',
      childContextTypes: 'DEFINE_MANY',
      getDefaultProps: 'DEFINE_MANY_MERGED',
      getInitialState: 'DEFINE_MANY_MERGED',
      getChildContext: 'DEFINE_MANY_MERGED',
      render: 'DEFINE_ONCE',
      componentWillMount: 'DEFINE_MANY',
      componentDidMount: 'DEFINE_MANY',
      componentWillReceiveProps: 'DEFINE_MANY',
      shouldComponentUpdate: 'DEFINE_ONCE',
      componentWillUpdate: 'DEFINE_MANY',
      componentDidUpdate: 'DEFINE_MANY',
      componentWillUnmount: 'DEFINE_MANY',
      UNSAFE_componentWillMount: 'DEFINE_MANY',
      UNSAFE_componentWillReceiveProps: 'DEFINE_MANY',
      UNSAFE_componentWillUpdate: 'DEFINE_MANY',
      updateComponent: 'OVERRIDE_BASE'
    };
    var ReactClassStaticInterface = {
      getDerivedStateFromProps: 'DEFINE_MANY_MERGED'
    };
    var RESERVED_SPEC_KEYS = {
      displayName: function displayName(Constructor, _displayName) {
        Constructor.displayName = _displayName;
      },
      mixins: function mixins(Constructor, _mixins) {
        if (_mixins) {
          for (var i = 0; i < _mixins.length; i++) {
            mixSpecIntoComponent(Constructor, _mixins[i]);
          }
        }
      },
      childContextTypes: function childContextTypes(Constructor, _childContextTypes) {
        if (process.env.NODE_ENV !== 'production') {
          validateTypeDef(Constructor, _childContextTypes, 'childContext');
        }

        Constructor.childContextTypes = _assign({}, Constructor.childContextTypes, _childContextTypes);
      },
      contextTypes: function contextTypes(Constructor, _contextTypes) {
        if (process.env.NODE_ENV !== 'production') {
          validateTypeDef(Constructor, _contextTypes, 'context');
        }

        Constructor.contextTypes = _assign({}, Constructor.contextTypes, _contextTypes);
      },
      getDefaultProps: function getDefaultProps(Constructor, _getDefaultProps) {
        if (Constructor.getDefaultProps) {
          Constructor.getDefaultProps = createMergedResultFunction(Constructor.getDefaultProps, _getDefaultProps);
        } else {
          Constructor.getDefaultProps = _getDefaultProps;
        }
      },
      propTypes: function propTypes(Constructor, _propTypes) {
        if (process.env.NODE_ENV !== 'production') {
          validateTypeDef(Constructor, _propTypes, 'prop');
        }

        Constructor.propTypes = _assign({}, Constructor.propTypes, _propTypes);
      },
      statics: function statics(Constructor, _statics) {
        mixStaticSpecIntoComponent(Constructor, _statics);
      },
      autobind: function autobind() {}
    };

    function validateTypeDef(Constructor, typeDef, location) {
      for (var propName in typeDef) {
        if (typeDef.hasOwnProperty(propName)) {
          if (process.env.NODE_ENV !== 'production') {
            warning(typeof typeDef[propName] === 'function', '%s: %s type `%s` is invalid; it must be a function, usually from ' + 'React.PropTypes.', Constructor.displayName || 'ReactClass', ReactPropTypeLocationNames[location], propName);
          }
        }
      }
    }

    function validateMethodOverride(isAlreadyDefined, name) {
      var specPolicy = ReactClassInterface.hasOwnProperty(name) ? ReactClassInterface[name] : null;

      if (ReactClassMixin.hasOwnProperty(name)) {
        _invariant(specPolicy === 'OVERRIDE_BASE', 'ReactClassInterface: You are attempting to override ' + '`%s` from your class specification. Ensure that your method names ' + 'do not overlap with React methods.', name);
      }

      if (isAlreadyDefined) {
        _invariant(specPolicy === 'DEFINE_MANY' || specPolicy === 'DEFINE_MANY_MERGED', 'ReactClassInterface: You are attempting to define ' + '`%s` on your component more than once. This conflict may be due ' + 'to a mixin.', name);
      }
    }

    function mixSpecIntoComponent(Constructor, spec) {
      if (!spec) {
        if (process.env.NODE_ENV !== 'production') {
          var typeofSpec = typeof spec;
          var isMixinValid = typeofSpec === 'object' && spec !== null;

          if (process.env.NODE_ENV !== 'production') {
            warning(isMixinValid, "%s: You're attempting to include a mixin that is either null " + 'or not an object. Check the mixins included by the component, ' + 'as well as any mixins they include themselves. ' + 'Expected object but got %s.', Constructor.displayName || 'ReactClass', spec === null ? null : typeofSpec);
          }
        }

        return;
      }

      _invariant(typeof spec !== 'function', "ReactClass: You're attempting to " + 'use a component class or function as a mixin. Instead, just use a ' + 'regular object.');

      _invariant(!isValidElement(spec), "ReactClass: You're attempting to " + 'use a component as a mixin. Instead, just use a regular object.');

      var proto = Constructor.prototype;
      var autoBindPairs = proto.__reactAutoBindPairs;

      if (spec.hasOwnProperty(MIXINS_KEY)) {
        RESERVED_SPEC_KEYS.mixins(Constructor, spec.mixins);
      }

      for (var name in spec) {
        if (!spec.hasOwnProperty(name)) {
          continue;
        }

        if (name === MIXINS_KEY) {
          continue;
        }

        var property = spec[name];
        var isAlreadyDefined = proto.hasOwnProperty(name);
        validateMethodOverride(isAlreadyDefined, name);

        if (RESERVED_SPEC_KEYS.hasOwnProperty(name)) {
          RESERVED_SPEC_KEYS[name](Constructor, property);
        } else {
          var isReactClassMethod = ReactClassInterface.hasOwnProperty(name);
          var isFunction = typeof property === 'function';
          var shouldAutoBind = isFunction && !isReactClassMethod && !isAlreadyDefined && spec.autobind !== false;

          if (shouldAutoBind) {
            autoBindPairs.push(name, property);
            proto[name] = property;
          } else {
            if (isAlreadyDefined) {
              var specPolicy = ReactClassInterface[name];

              _invariant(isReactClassMethod && (specPolicy === 'DEFINE_MANY_MERGED' || specPolicy === 'DEFINE_MANY'), 'ReactClass: Unexpected spec policy %s for key %s ' + 'when mixing in component specs.', specPolicy, name);

              if (specPolicy === 'DEFINE_MANY_MERGED') {
                proto[name] = createMergedResultFunction(proto[name], property);
              } else if (specPolicy === 'DEFINE_MANY') {
                proto[name] = createChainedFunction(proto[name], property);
              }
            } else {
              proto[name] = property;

              if (process.env.NODE_ENV !== 'production') {
                if (typeof property === 'function' && spec.displayName) {
                  proto[name].displayName = spec.displayName + '_' + name;
                }
              }
            }
          }
        }
      }
    }

    function mixStaticSpecIntoComponent(Constructor, statics) {
      if (!statics) {
        return;
      }

      for (var name in statics) {
        var property = statics[name];

        if (!statics.hasOwnProperty(name)) {
          continue;
        }

        var isReserved = name in RESERVED_SPEC_KEYS;

        _invariant(!isReserved, 'ReactClass: You are attempting to define a reserved ' + 'property, `%s`, that shouldn\'t be on the "statics" key. Define it ' + 'as an instance property instead; it will still be accessible on the ' + 'constructor.', name);

        var isAlreadyDefined = name in Constructor;

        if (isAlreadyDefined) {
          var specPolicy = ReactClassStaticInterface.hasOwnProperty(name) ? ReactClassStaticInterface[name] : null;

          _invariant(specPolicy === 'DEFINE_MANY_MERGED', 'ReactClass: You are attempting to define ' + '`%s` on your component more than once. This conflict may be ' + 'due to a mixin.', name);

          Constructor[name] = createMergedResultFunction(Constructor[name], property);
          return;
        }

        Constructor[name] = property;
      }
    }

    function mergeIntoWithNoDuplicateKeys(one, two) {
      _invariant(one && two && typeof one === 'object' && typeof two === 'object', 'mergeIntoWithNoDuplicateKeys(): Cannot merge non-objects.');

      for (var key in two) {
        if (two.hasOwnProperty(key)) {
          _invariant(one[key] === undefined, 'mergeIntoWithNoDuplicateKeys(): ' + 'Tried to merge two objects with the same key: `%s`. This conflict ' + 'may be due to a mixin; in particular, this may be caused by two ' + 'getInitialState() or getDefaultProps() methods returning objects ' + 'with clashing keys.', key);

          one[key] = two[key];
        }
      }

      return one;
    }

    function createMergedResultFunction(one, two) {
      return function mergedResult() {
        var a = one.apply(this, arguments);
        var b = two.apply(this, arguments);

        if (a == null) {
          return b;
        } else if (b == null) {
          return a;
        }

        var c = {};
        mergeIntoWithNoDuplicateKeys(c, a);
        mergeIntoWithNoDuplicateKeys(c, b);
        return c;
      };
    }

    function createChainedFunction(one, two) {
      return function chainedFunction() {
        one.apply(this, arguments);
        two.apply(this, arguments);
      };
    }

    function bindAutoBindMethod(component, method) {
      var boundMethod = method.bind(component);

      if (process.env.NODE_ENV !== 'production') {
        boundMethod.__reactBoundContext = component;
        boundMethod.__reactBoundMethod = method;
        boundMethod.__reactBoundArguments = null;
        var componentName = component.constructor.displayName;
        var _bind = boundMethod.bind;

        boundMethod.bind = function (newThis) {
          for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
            args[_key - 1] = arguments[_key];
          }

          if (newThis !== component && newThis !== null) {
            if (process.env.NODE_ENV !== 'production') {
              warning(false, 'bind(): React component methods may only be bound to the ' + 'component instance. See %s', componentName);
            }
          } else if (!args.length) {
            if (process.env.NODE_ENV !== 'production') {
              warning(false, 'bind(): You are binding a component method to the component. ' + 'React does this for you automatically in a high-performance ' + 'way, so you can safely remove this call. See %s', componentName);
            }

            return boundMethod;
          }

          var reboundMethod = _bind.apply(boundMethod, arguments);

          reboundMethod.__reactBoundContext = component;
          reboundMethod.__reactBoundMethod = method;
          reboundMethod.__reactBoundArguments = args;
          return reboundMethod;
        };
      }

      return boundMethod;
    }

    function bindAutoBindMethods(component) {
      var pairs = component.__reactAutoBindPairs;

      for (var i = 0; i < pairs.length; i += 2) {
        var autoBindKey = pairs[i];
        var method = pairs[i + 1];
        component[autoBindKey] = bindAutoBindMethod(component, method);
      }
    }

    var IsMountedPreMixin = {
      componentDidMount: function componentDidMount() {
        this.__isMounted = true;
      }
    };
    var IsMountedPostMixin = {
      componentWillUnmount: function componentWillUnmount() {
        this.__isMounted = false;
      }
    };
    var ReactClassMixin = {
      replaceState: function replaceState(newState, callback) {
        this.updater.enqueueReplaceState(this, newState, callback);
      },
      isMounted: function isMounted() {
        if (process.env.NODE_ENV !== 'production') {
          warning(this.__didWarnIsMounted, '%s: isMounted is deprecated. Instead, make sure to clean up ' + 'subscriptions and pending requests in componentWillUnmount to ' + 'prevent memory leaks.', this.constructor && this.constructor.displayName || this.name || 'Component');
          this.__didWarnIsMounted = true;
        }

        return !!this.__isMounted;
      }
    };

    var ReactClassComponent = function ReactClassComponent() {};

    _assign(ReactClassComponent.prototype, ReactComponent.prototype, ReactClassMixin);

    function createClass(spec) {
      var Constructor = identity(function (props, context, updater) {
        if (process.env.NODE_ENV !== 'production') {
          warning(this instanceof Constructor, 'Something is calling a React component directly. Use a factory or ' + 'JSX instead. See: https://fb.me/react-legacyfactory');
        }

        if (this.__reactAutoBindPairs.length) {
          bindAutoBindMethods(this);
        }

        this.props = props;
        this.context = context;
        this.refs = emptyObject;
        this.updater = updater || ReactNoopUpdateQueue;
        this.state = null;
        var initialState = this.getInitialState ? this.getInitialState() : null;

        if (process.env.NODE_ENV !== 'production') {
          if (initialState === undefined && this.getInitialState._isMockFunction) {
            initialState = null;
          }
        }

        _invariant(typeof initialState === 'object' && !Array.isArray(initialState), '%s.getInitialState(): must return an object or null', Constructor.displayName || 'ReactCompositeComponent');

        this.state = initialState;
      });
      Constructor.prototype = new ReactClassComponent();
      Constructor.prototype.constructor = Constructor;
      Constructor.prototype.__reactAutoBindPairs = [];
      injectedMixins.forEach(mixSpecIntoComponent.bind(null, Constructor));
      mixSpecIntoComponent(Constructor, IsMountedPreMixin);
      mixSpecIntoComponent(Constructor, spec);
      mixSpecIntoComponent(Constructor, IsMountedPostMixin);

      if (Constructor.getDefaultProps) {
        Constructor.defaultProps = Constructor.getDefaultProps();
      }

      if (process.env.NODE_ENV !== 'production') {
        if (Constructor.getDefaultProps) {
          Constructor.getDefaultProps.isReactClassApproved = {};
        }

        if (Constructor.prototype.getInitialState) {
          Constructor.prototype.getInitialState.isReactClassApproved = {};
        }
      }

      _invariant(Constructor.prototype.render, 'createClass(...): Class specification must implement a `render` method.');

      if (process.env.NODE_ENV !== 'production') {
        warning(!Constructor.prototype.componentShouldUpdate, '%s has a method called ' + 'componentShouldUpdate(). Did you mean shouldComponentUpdate()? ' + 'The name is phrased as a question because the function is ' + 'expected to return a value.', spec.displayName || 'A component');
        warning(!Constructor.prototype.componentWillRecieveProps, '%s has a method called ' + 'componentWillRecieveProps(). Did you mean componentWillReceiveProps()?', spec.displayName || 'A component');
        warning(!Constructor.prototype.UNSAFE_componentWillRecieveProps, '%s has a method called UNSAFE_componentWillRecieveProps(). ' + 'Did you mean UNSAFE_componentWillReceiveProps()?', spec.displayName || 'A component');
      }

      for (var methodName in ReactClassInterface) {
        if (!Constructor.prototype[methodName]) {
          Constructor.prototype[methodName] = null;
        }
      }

      return Constructor;
    }

    return createClass;
  }

  module.exports = factory;
},253,[56,254,255,256],"node_modules/create-react-class/factory.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var emptyObject = {};

  if (process.env.NODE_ENV !== 'production') {
    Object.freeze(emptyObject);
  }

  module.exports = emptyObject;
},254,[],"node_modules/create-react-class/node_modules/fbjs/lib/emptyObject.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var validateFormat = function validateFormat(format) {};

  if (process.env.NODE_ENV !== 'production') {
    validateFormat = function validateFormat(format) {
      if (format === undefined) {
        throw new Error('invariant requires an error message argument');
      }
    };
  }

  function invariant(condition, format, a, b, c, d, e, f) {
    validateFormat(format);

    if (!condition) {
      var error;

      if (format === undefined) {
        error = new Error('Minified exception occurred; use the non-minified dev environment ' + 'for the full error message and additional helpful warnings.');
      } else {
        var args = [a, b, c, d, e, f];
        var argIndex = 0;
        error = new Error(format.replace(/%s/g, function () {
          return args[argIndex++];
        }));
        error.name = 'Invariant Violation';
      }

      error.framesToPop = 1;
      throw error;
    }
  }

  module.exports = invariant;
},255,[],"node_modules/create-react-class/node_modules/fbjs/lib/invariant.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var emptyFunction = _$$_REQUIRE(_dependencyMap[0], "./emptyFunction");

  var warning = emptyFunction;

  if (process.env.NODE_ENV !== 'production') {
    var printWarning = function printWarning(format) {
      for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
        args[_key - 1] = arguments[_key];
      }

      var argIndex = 0;
      var message = 'Warning: ' + format.replace(/%s/g, function () {
        return args[argIndex++];
      });

      if (typeof console !== 'undefined') {
        console.error(message);
      }

      try {
        throw new Error(message);
      } catch (x) {}
    };

    warning = function warning(condition, format) {
      if (format === undefined) {
        throw new Error('`warning(condition, format, ...args)` requires a warning ' + 'message argument');
      }

      if (format.indexOf('Failed Composite propType: ') === 0) {
        return;
      }

      if (!condition) {
        for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
          args[_key2 - 2] = arguments[_key2];
        }

        printWarning.apply(undefined, [format].concat(args));
      }
    };
  }

  module.exports = warning;
},256,[257],"node_modules/create-react-class/node_modules/fbjs/lib/warning.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  "use strict";

  function makeEmptyFunction(arg) {
    return function () {
      return arg;
    };
  }

  var emptyFunction = function emptyFunction() {};

  emptyFunction.thatReturns = makeEmptyFunction;
  emptyFunction.thatReturnsFalse = makeEmptyFunction(false);
  emptyFunction.thatReturnsTrue = makeEmptyFunction(true);
  emptyFunction.thatReturnsNull = makeEmptyFunction(null);

  emptyFunction.thatReturnsThis = function () {
    return this;
  };

  emptyFunction.thatReturnsArgument = function (arg) {
    return arg;
  };

  module.exports = emptyFunction;
},257,[],"node_modules/create-react-class/node_modules/fbjs/lib/emptyFunction.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var invariant = _$$_REQUIRE(_dependencyMap[0], "invariant");

  var ensurePositiveDelayProps = function ensurePositiveDelayProps(props) {
    invariant(!(props.delayPressIn < 0 || props.delayPressOut < 0 || props.delayLongPress < 0), 'Touchable components cannot have negative delay properties');
  };

  module.exports = ensurePositiveDelayProps;
},258,[3],"node_modules/react-native/Libraries/Components/Touchable/ensurePositiveDelayProps.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  module.exports = {
    DeprecatedAccessibilityRoles: ['none', 'button', 'link', 'search', 'image', 'keyboardkey', 'text', 'adjustable', 'imagebutton', 'header', 'summary', 'alert', 'checkbox', 'combobox', 'menu', 'menubar', 'menuitem', 'progressbar', 'radio', 'radiogroup', 'scrollbar', 'spinbutton', 'switch', 'tab', 'tablist', 'timer', 'toolbar'],
    DeprecatedAccessibilityStates: ['selected', 'disabled', 'checked', 'unchecked', 'busy', 'expanded', 'collapsed', 'hasPopup']
  };
},259,[],"node_modules/react-native/Libraries/DeprecatedPropTypes/DeprecatedViewAccessibility.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native/Libraries/Components/Touchable/TouchableOpacity.js";

  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

  var Animated = _$$_REQUIRE(_dependencyMap[1], "../../Animated/src/Animated");

  var Easing = _$$_REQUIRE(_dependencyMap[2], "../../Animated/src/Easing");

  var NativeMethodsMixin = _$$_REQUIRE(_dependencyMap[3], "../../Renderer/shims/NativeMethodsMixin");

  var Platform = _$$_REQUIRE(_dependencyMap[4], "../../Utilities/Platform");

  var React = _$$_REQUIRE(_dependencyMap[5], "react");

  var PropTypes = _$$_REQUIRE(_dependencyMap[6], "prop-types");

  var Touchable = _$$_REQUIRE(_dependencyMap[7], "./Touchable");

  var TouchableWithoutFeedback = _$$_REQUIRE(_dependencyMap[8], "./TouchableWithoutFeedback");

  var createReactClass = _$$_REQUIRE(_dependencyMap[9], "create-react-class");

  var ensurePositiveDelayProps = _$$_REQUIRE(_dependencyMap[10], "./ensurePositiveDelayProps");

  var flattenStyle = _$$_REQUIRE(_dependencyMap[11], "../../StyleSheet/flattenStyle");

  var PRESS_RETENTION_OFFSET = {
    top: 20,
    left: 20,
    right: 20,
    bottom: 30
  };
  var TouchableOpacity = createReactClass({
    displayName: 'TouchableOpacity',
    mixins: [Touchable.Mixin.withoutDefaultFocusAndBlur, NativeMethodsMixin],
    propTypes: _objectSpread({}, TouchableWithoutFeedback.propTypes, {
      activeOpacity: PropTypes.number,
      hasTVPreferredFocus: PropTypes.bool,
      nextFocusDown: PropTypes.number,
      nextFocusForward: PropTypes.number,
      nextFocusLeft: PropTypes.number,
      nextFocusRight: PropTypes.number,
      nextFocusUp: PropTypes.number,
      tvParallaxProperties: PropTypes.object
    }),
    getDefaultProps: function getDefaultProps() {
      return {
        activeOpacity: 0.2
      };
    },
    getInitialState: function getInitialState() {
      return _objectSpread({}, this.touchableGetInitialState(), {
        anim: new Animated.Value(this._getChildStyleOpacityWithDefault())
      });
    },
    componentDidMount: function componentDidMount() {
      ensurePositiveDelayProps(this.props);
    },
    UNSAFE_componentWillReceiveProps: function UNSAFE_componentWillReceiveProps(nextProps) {
      ensurePositiveDelayProps(nextProps);
    },
    componentDidUpdate: function componentDidUpdate(prevProps, prevState) {
      if (this.props.disabled !== prevProps.disabled) {
        this._opacityInactive(250);
      }
    },
    setOpacityTo: function setOpacityTo(value, duration) {
      Animated.timing(this.state.anim, {
        toValue: value,
        duration: duration,
        easing: Easing.inOut(Easing.quad),
        useNativeDriver: true
      }).start();
    },
    touchableHandleActivePressIn: function touchableHandleActivePressIn(e) {
      if (e.dispatchConfig.registrationName === 'onResponderGrant') {
        this._opacityActive(0);
      } else {
        this._opacityActive(150);
      }

      this.props.onPressIn && this.props.onPressIn(e);
    },
    touchableHandleActivePressOut: function touchableHandleActivePressOut(e) {
      this._opacityInactive(250);

      this.props.onPressOut && this.props.onPressOut(e);
    },
    touchableHandleFocus: function touchableHandleFocus(e) {
      if (Platform.isTV) {
        this._opacityActive(150);
      }

      this.props.onFocus && this.props.onFocus(e);
    },
    touchableHandleBlur: function touchableHandleBlur(e) {
      if (Platform.isTV) {
        this._opacityInactive(250);
      }

      this.props.onBlur && this.props.onBlur(e);
    },
    touchableHandlePress: function touchableHandlePress(e) {
      this.props.onPress && this.props.onPress(e);
    },
    touchableHandleLongPress: function touchableHandleLongPress(e) {
      this.props.onLongPress && this.props.onLongPress(e);
    },
    touchableGetPressRectOffset: function touchableGetPressRectOffset() {
      return this.props.pressRetentionOffset || PRESS_RETENTION_OFFSET;
    },
    touchableGetHitSlop: function touchableGetHitSlop() {
      return this.props.hitSlop;
    },
    touchableGetHighlightDelayMS: function touchableGetHighlightDelayMS() {
      return this.props.delayPressIn || 0;
    },
    touchableGetLongPressDelayMS: function touchableGetLongPressDelayMS() {
      return this.props.delayLongPress === 0 ? 0 : this.props.delayLongPress || 500;
    },
    touchableGetPressOutDelayMS: function touchableGetPressOutDelayMS() {
      return this.props.delayPressOut;
    },
    _opacityActive: function _opacityActive(duration) {
      this.setOpacityTo(this.props.activeOpacity, duration);
    },
    _opacityInactive: function _opacityInactive(duration) {
      this.setOpacityTo(this._getChildStyleOpacityWithDefault(), duration);
    },
    _getChildStyleOpacityWithDefault: function _getChildStyleOpacityWithDefault() {
      var childStyle = flattenStyle(this.props.style) || {};
      return childStyle.opacity == null ? 1 : childStyle.opacity;
    },
    render: function render() {
      return React.createElement(Animated.View, {
        accessible: this.props.accessible !== false,
        accessibilityLabel: this.props.accessibilityLabel,
        accessibilityHint: this.props.accessibilityHint,
        accessibilityRole: this.props.accessibilityRole,
        accessibilityStates: this.props.accessibilityStates,
        accessibilityState: this.props.accessibilityState,
        accessibilityActions: this.props.accessibilityActions,
        onAccessibilityAction: this.props.onAccessibilityAction,
        style: [this.props.style, {
          opacity: this.state.anim
        }],
        nativeID: this.props.nativeID,
        testID: this.props.testID,
        onLayout: this.props.onLayout,
        isTVSelectable: true,
        nextFocusDown: this.props.nextFocusDown,
        nextFocusForward: this.props.nextFocusForward,
        nextFocusLeft: this.props.nextFocusLeft,
        nextFocusRight: this.props.nextFocusRight,
        nextFocusUp: this.props.nextFocusUp,
        hasTVPreferredFocus: this.props.hasTVPreferredFocus,
        tvParallaxProperties: this.props.tvParallaxProperties,
        hitSlop: this.props.hitSlop,
        focusable: this.props.focusable !== false && this.props.onPress !== undefined,
        onClick: this.touchableHandlePress,
        onStartShouldSetResponder: this.touchableHandleStartShouldSetResponder,
        onResponderTerminationRequest: this.touchableHandleResponderTerminationRequest,
        onResponderGrant: this.touchableHandleResponderGrant,
        onResponderMove: this.touchableHandleResponderMove,
        onResponderRelease: this.touchableHandleResponderRelease,
        onResponderTerminate: this.touchableHandleResponderTerminate,
        __source: {
          fileName: _jsxFileName,
          lineNumber: 308
        }
      }, this.props.children, Touchable.renderDebugView({
        color: 'cyan',
        hitSlop: this.props.hitSlop
      }));
    }
  });
  module.exports = TouchableOpacity;
},260,[46,261,289,325,48,54,69,241,251,252,258,85],"node_modules/react-native/Libraries/Components/Touchable/TouchableOpacity.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _defineProperty2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/defineProperty"));

  var _Platform = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../../Utilities/Platform"));

  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

  var AnimatedMock = _$$_REQUIRE(_dependencyMap[3], "./AnimatedMock");

  var AnimatedImplementation = _$$_REQUIRE(_dependencyMap[4], "./AnimatedImplementation");

  var Animated = _Platform.default.isTesting ? AnimatedMock : AnimatedImplementation;
  module.exports = _objectSpread({
    get FlatList() {
      return _$$_REQUIRE(_dependencyMap[5], "./components/AnimatedFlatList");
    },

    get Image() {
      return _$$_REQUIRE(_dependencyMap[6], "./components/AnimatedImage");
    },

    get ScrollView() {
      return _$$_REQUIRE(_dependencyMap[7], "./components/AnimatedScrollView");
    },

    get SectionList() {
      return _$$_REQUIRE(_dependencyMap[8], "./components/AnimatedSectionList");
    },

    get Text() {
      return _$$_REQUIRE(_dependencyMap[9], "./components/AnimatedText");
    },

    get View() {
      return _$$_REQUIRE(_dependencyMap[10], "./components/AnimatedView");
    }

  }, Animated);
},261,[1,46,48,262,272,292,313,319,320,323,324],"node_modules/react-native/Libraries/Animated/src/Animated.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");

  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

  var _require = _$$_REQUIRE(_dependencyMap[1], "./AnimatedEvent"),
      AnimatedEvent = _require.AnimatedEvent,
      attachNativeEvent = _require.attachNativeEvent;

  var AnimatedImplementation = _$$_REQUIRE(_dependencyMap[2], "./AnimatedImplementation");

  var AnimatedInterpolation = _$$_REQUIRE(_dependencyMap[3], "./nodes/AnimatedInterpolation");

  var AnimatedNode = _$$_REQUIRE(_dependencyMap[4], "./nodes/AnimatedNode");

  var AnimatedProps = _$$_REQUIRE(_dependencyMap[5], "./nodes/AnimatedProps");

  var AnimatedValue = _$$_REQUIRE(_dependencyMap[6], "./nodes/AnimatedValue");

  var AnimatedValueXY = _$$_REQUIRE(_dependencyMap[7], "./nodes/AnimatedValueXY");

  var createAnimatedComponent = _$$_REQUIRE(_dependencyMap[8], "./createAnimatedComponent");

  var emptyAnimation = {
    start: function start() {},
    stop: function stop() {},
    reset: function reset() {},
    _startNativeLoop: function _startNativeLoop() {},
    _isUsingNativeDriver: function _isUsingNativeDriver() {
      return false;
    }
  };

  var spring = function spring(value, config) {
    var anyValue = value;
    return _objectSpread({}, emptyAnimation, {
      start: function start(callback) {
        anyValue.setValue(config.toValue);
        callback && callback({
          finished: true
        });
      }
    });
  };

  var timing = function timing(value, config) {
    var anyValue = value;
    return _objectSpread({}, emptyAnimation, {
      start: function start(callback) {
        anyValue.setValue(config.toValue);
        callback && callback({
          finished: true
        });
      }
    });
  };

  var decay = function decay(value, config) {
    return emptyAnimation;
  };

  var sequence = function sequence(animations) {
    return emptyAnimation;
  };

  var parallel = function parallel(animations, config) {
    return emptyAnimation;
  };

  var delay = function delay(time) {
    return emptyAnimation;
  };

  var stagger = function stagger(time, animations) {
    return emptyAnimation;
  };

  var loop = function loop(animation) {
    var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
        _ref$iterations = _ref.iterations,
        iterations = _ref$iterations === void 0 ? -1 : _ref$iterations;

    return emptyAnimation;
  };

  var event = function event(argMapping, config) {
    return null;
  };

  module.exports = {
    Value: AnimatedValue,
    ValueXY: AnimatedValueXY,
    Interpolation: AnimatedInterpolation,
    Node: AnimatedNode,
    decay: decay,
    timing: timing,
    spring: spring,
    add: AnimatedImplementation.add,
    subtract: AnimatedImplementation.subtract,
    divide: AnimatedImplementation.divide,
    multiply: AnimatedImplementation.multiply,
    modulo: AnimatedImplementation.modulo,
    diffClamp: AnimatedImplementation.diffClamp,
    delay: delay,
    sequence: sequence,
    parallel: parallel,
    stagger: stagger,
    loop: loop,
    event: event,
    createAnimatedComponent: createAnimatedComponent,
    attachNativeEvent: attachNativeEvent,
    forkEvent: AnimatedImplementation.forkEvent,
    unforkEvent: AnimatedImplementation.unforkEvent,
    Event: AnimatedEvent,
    __PropsOnlyForTests: AnimatedProps
  };
},262,[46,263,272,265,266,278,264,283,291],"node_modules/react-native/Libraries/Animated/src/AnimatedMock.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");

  var AnimatedValue = _$$_REQUIRE(_dependencyMap[2], "./nodes/AnimatedValue");

  var NativeAnimatedHelper = _$$_REQUIRE(_dependencyMap[3], "./NativeAnimatedHelper");

  var ReactNative = _$$_REQUIRE(_dependencyMap[4], "../../Renderer/shims/ReactNative");

  var invariant = _$$_REQUIRE(_dependencyMap[5], "invariant");

  var _require = _$$_REQUIRE(_dependencyMap[3], "./NativeAnimatedHelper"),
      shouldUseNativeDriver = _require.shouldUseNativeDriver;

  function attachNativeEvent(viewRef, eventName, argMapping) {
    var eventMappings = [];

    var traverse = function traverse(value, path) {
      if (value instanceof AnimatedValue) {
        value.__makeNative();

        eventMappings.push({
          nativeEventPath: path,
          animatedValueTag: value.__getNativeTag()
        });
      } else if (typeof value === 'object') {
        for (var _key in value) {
          traverse(value[_key], path.concat(_key));
        }
      }
    };

    invariant(argMapping[0] && argMapping[0].nativeEvent, 'Native driven events only support animated values contained inside `nativeEvent`.');
    traverse(argMapping[0].nativeEvent, []);
    var viewTag = ReactNative.findNodeHandle(viewRef);
    eventMappings.forEach(function (mapping) {
      NativeAnimatedHelper.API.addAnimatedEventToView(viewTag, eventName, mapping);
    });
    return {
      detach: function detach() {
        eventMappings.forEach(function (mapping) {
          NativeAnimatedHelper.API.removeAnimatedEventFromView(viewTag, eventName, mapping.animatedValueTag);
        });
      }
    };
  }

  var AnimatedEvent = function () {
    function AnimatedEvent(argMapping) {
      var config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

      _classCallCheck(this, AnimatedEvent);

      this._listeners = [];
      this._argMapping = argMapping;

      if (config.listener) {
        this.__addListener(config.listener);
      }

      this._callListeners = this._callListeners.bind(this);
      this._attachedEvent = null;
      this.__isNative = shouldUseNativeDriver(config);

      if (__DEV__) {
        this._validateMapping();
      }
    }

    _createClass(AnimatedEvent, [{
      key: "__addListener",
      value: function __addListener(callback) {
        this._listeners.push(callback);
      }
    }, {
      key: "__removeListener",
      value: function __removeListener(callback) {
        this._listeners = this._listeners.filter(function (listener) {
          return listener !== callback;
        });
      }
    }, {
      key: "__attach",
      value: function __attach(viewRef, eventName) {
        invariant(this.__isNative, 'Only native driven events need to be attached.');
        this._attachedEvent = attachNativeEvent(viewRef, eventName, this._argMapping);
      }
    }, {
      key: "__detach",
      value: function __detach(viewTag, eventName) {
        invariant(this.__isNative, 'Only native driven events need to be detached.');
        this._attachedEvent && this._attachedEvent.detach();
      }
    }, {
      key: "__getHandler",
      value: function __getHandler() {
        var _this = this;

        if (this.__isNative) {
          return this._callListeners;
        }

        return function () {
          for (var _len = arguments.length, args = new Array(_len), _key2 = 0; _key2 < _len; _key2++) {
            args[_key2] = arguments[_key2];
          }

          var traverse = function traverse(recMapping, recEvt, key) {
            if (typeof recEvt === 'number' && recMapping instanceof AnimatedValue) {
              recMapping.setValue(recEvt);
            } else if (typeof recMapping === 'object') {
              for (var mappingKey in recMapping) {
                traverse(recMapping[mappingKey], recEvt[mappingKey], mappingKey);
              }
            }
          };

          if (!_this.__isNative) {
            _this._argMapping.forEach(function (mapping, idx) {
              traverse(mapping, args[idx], 'arg' + idx);
            });
          }

          _this._callListeners.apply(_this, args);
        };
      }
    }, {
      key: "_callListeners",
      value: function _callListeners() {
        for (var _len2 = arguments.length, args = new Array(_len2), _key3 = 0; _key3 < _len2; _key3++) {
          args[_key3] = arguments[_key3];
        }

        this._listeners.forEach(function (listener) {
          return listener.apply(void 0, args);
        });
      }
    }, {
      key: "_validateMapping",
      value: function _validateMapping() {
        var traverse = function traverse(recMapping, recEvt, key) {
          if (typeof recEvt === 'number') {
            invariant(recMapping instanceof AnimatedValue, 'Bad mapping of type ' + typeof recMapping + ' for key ' + key + ', event value must map to AnimatedValue');
            return;
          }

          invariant(typeof recMapping === 'object', 'Bad mapping of type ' + typeof recMapping + ' for key ' + key);
          invariant(typeof recEvt === 'object', 'Bad event of type ' + typeof recEvt + ' for key ' + key);

          for (var mappingKey in recMapping) {
            traverse(recMapping[mappingKey], recEvt[mappingKey], mappingKey);
          }
        };
      }
    }]);

    return AnimatedEvent;
  }();

  module.exports = {
    AnimatedEvent: AnimatedEvent,
    attachNativeEvent: attachNativeEvent
  };
},263,[24,25,264,267,88,3],"node_modules/react-native/Libraries/Animated/src/AnimatedEvent.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");

  var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");

  var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");

  var _get = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/get");

  var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");

  var AnimatedInterpolation = _$$_REQUIRE(_dependencyMap[6], "./AnimatedInterpolation");

  var AnimatedWithChildren = _$$_REQUIRE(_dependencyMap[7], "./AnimatedWithChildren");

  var InteractionManager = _$$_REQUIRE(_dependencyMap[8], "../../../Interaction/InteractionManager");

  var NativeAnimatedHelper = _$$_REQUIRE(_dependencyMap[9], "../NativeAnimatedHelper");

  var NativeAnimatedAPI = NativeAnimatedHelper.API;

  function _flush(rootNode) {
    var animatedStyles = new Set();

    function findAnimatedStyles(node) {
      if (typeof node.update === 'function') {
        animatedStyles.add(node);
      } else {
        node.__getChildren().forEach(findAnimatedStyles);
      }
    }

    findAnimatedStyles(rootNode);
    animatedStyles.forEach(function (animatedStyle) {
      return animatedStyle.update();
    });
  }

  var AnimatedValue = function (_AnimatedWithChildren) {
    _inherits(AnimatedValue, _AnimatedWithChildren);

    function AnimatedValue(value) {
      var _this;

      _classCallCheck(this, AnimatedValue);

      _this = _possibleConstructorReturn(this, _getPrototypeOf(AnimatedValue).call(this));
      _this._startingValue = _this._value = value;
      _this._offset = 0;
      _this._animation = null;
      return _this;
    }

    _createClass(AnimatedValue, [{
      key: "__detach",
      value: function __detach() {
        this.stopAnimation();

        _get(_getPrototypeOf(AnimatedValue.prototype), "__detach", this).call(this);
      }
    }, {
      key: "__getValue",
      value: function __getValue() {
        return this._value + this._offset;
      }
    }, {
      key: "setValue",
      value: function setValue(value) {
        if (this._animation) {
          this._animation.stop();

          this._animation = null;
        }

        this._updateValue(value, !this.__isNative);

        if (this.__isNative) {
          NativeAnimatedAPI.setAnimatedNodeValue(this.__getNativeTag(), value);
        }
      }
    }, {
      key: "setOffset",
      value: function setOffset(offset) {
        this._offset = offset;

        if (this.__isNative) {
          NativeAnimatedAPI.setAnimatedNodeOffset(this.__getNativeTag(), offset);
        }
      }
    }, {
      key: "flattenOffset",
      value: function flattenOffset() {
        this._value += this._offset;
        this._offset = 0;

        if (this.__isNative) {
          NativeAnimatedAPI.flattenAnimatedNodeOffset(this.__getNativeTag());
        }
      }
    }, {
      key: "extractOffset",
      value: function extractOffset() {
        this._offset += this._value;
        this._value = 0;

        if (this.__isNative) {
          NativeAnimatedAPI.extractAnimatedNodeOffset(this.__getNativeTag());
        }
      }
    }, {
      key: "stopAnimation",
      value: function stopAnimation(callback) {
        this.stopTracking();
        this._animation && this._animation.stop();
        this._animation = null;
        callback && callback(this.__getValue());
      }
    }, {
      key: "resetAnimation",
      value: function resetAnimation(callback) {
        this.stopAnimation(callback);
        this._value = this._startingValue;
      }
    }, {
      key: "_onAnimatedValueUpdateReceived",
      value: function _onAnimatedValueUpdateReceived(value) {
        this._updateValue(value, false);
      }
    }, {
      key: "interpolate",
      value: function interpolate(config) {
        return new AnimatedInterpolation(this, config);
      }
    }, {
      key: "animate",
      value: function animate(animation, callback) {
        var _this2 = this;

        var handle = null;

        if (animation.__isInteraction) {
          handle = InteractionManager.createInteractionHandle();
        }

        var previousAnimation = this._animation;
        this._animation && this._animation.stop();
        this._animation = animation;
        animation.start(this._value, function (value) {
          _this2._updateValue(value, true);
        }, function (result) {
          _this2._animation = null;

          if (handle !== null) {
            InteractionManager.clearInteractionHandle(handle);
          }

          callback && callback(result);
        }, previousAnimation, this);
      }
    }, {
      key: "stopTracking",
      value: function stopTracking() {
        this._tracking && this._tracking.__detach();
        this._tracking = null;
      }
    }, {
      key: "track",
      value: function track(tracking) {
        this.stopTracking();
        this._tracking = tracking;
      }
    }, {
      key: "_updateValue",
      value: function _updateValue(value, flush) {
        this._value = value;

        if (flush) {
          _flush(this);
        }

        _get(_getPrototypeOf(AnimatedValue.prototype), "__callListeners", this).call(this, this.__getValue());
      }
    }, {
      key: "__getNativeConfig",
      value: function __getNativeConfig() {
        return {
          type: 'value',
          value: this._value,
          offset: this._offset
        };
      }
    }]);

    return AnimatedValue;
  }(AnimatedWithChildren);

  module.exports = AnimatedValue;
},264,[24,25,32,34,35,37,265,269,270,267],"node_modules/react-native/Libraries/Animated/src/nodes/AnimatedValue.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");

  var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");

  var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");

  var _get = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/get");

  var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");

  var _defineProperty = _$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/defineProperty");

  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

  var AnimatedNode = _$$_REQUIRE(_dependencyMap[7], "./AnimatedNode");

  var AnimatedWithChildren = _$$_REQUIRE(_dependencyMap[8], "./AnimatedWithChildren");

  var NativeAnimatedHelper = _$$_REQUIRE(_dependencyMap[9], "../NativeAnimatedHelper");

  var invariant = _$$_REQUIRE(_dependencyMap[10], "invariant");

  var normalizeColor = _$$_REQUIRE(_dependencyMap[11], "../../../Color/normalizeColor");

  var linear = function linear(t) {
    return t;
  };

  function createInterpolation(config) {
    if (config.outputRange && typeof config.outputRange[0] === 'string') {
      return createInterpolationFromStringOutputRange(config);
    }

    var outputRange = config.outputRange;
    checkInfiniteRange('outputRange', outputRange);
    var inputRange = config.inputRange;
    checkInfiniteRange('inputRange', inputRange);
    checkValidInputRange(inputRange);
    invariant(inputRange.length === outputRange.length, 'inputRange (' + inputRange.length + ') and outputRange (' + outputRange.length + ') must have the same length');
    var easing = config.easing || linear;
    var extrapolateLeft = 'extend';

    if (config.extrapolateLeft !== undefined) {
      extrapolateLeft = config.extrapolateLeft;
    } else if (config.extrapolate !== undefined) {
      extrapolateLeft = config.extrapolate;
    }

    var extrapolateRight = 'extend';

    if (config.extrapolateRight !== undefined) {
      extrapolateRight = config.extrapolateRight;
    } else if (config.extrapolate !== undefined) {
      extrapolateRight = config.extrapolate;
    }

    return function (input) {
      invariant(typeof input === 'number', 'Cannot interpolation an input which is not a number');
      var range = findRange(input, inputRange);
      return interpolate(input, inputRange[range], inputRange[range + 1], outputRange[range], outputRange[range + 1], easing, extrapolateLeft, extrapolateRight);
    };
  }

  function interpolate(input, inputMin, inputMax, outputMin, outputMax, easing, extrapolateLeft, extrapolateRight) {
    var result = input;

    if (result < inputMin) {
      if (extrapolateLeft === 'identity') {
        return result;
      } else if (extrapolateLeft === 'clamp') {
        result = inputMin;
      } else if (extrapolateLeft === 'extend') {}
    }

    if (result > inputMax) {
      if (extrapolateRight === 'identity') {
        return result;
      } else if (extrapolateRight === 'clamp') {
        result = inputMax;
      } else if (extrapolateRight === 'extend') {}
    }

    if (outputMin === outputMax) {
      return outputMin;
    }

    if (inputMin === inputMax) {
      if (input <= inputMin) {
        return outputMin;
      }

      return outputMax;
    }

    if (inputMin === -Infinity) {
      result = -result;
    } else if (inputMax === Infinity) {
      result = result - inputMin;
    } else {
      result = (result - inputMin) / (inputMax - inputMin);
    }

    result = easing(result);

    if (outputMin === -Infinity) {
      result = -result;
    } else if (outputMax === Infinity) {
      result = result + outputMin;
    } else {
      result = result * (outputMax - outputMin) + outputMin;
    }

    return result;
  }

  function colorToRgba(input) {
    var int32Color = normalizeColor(input);

    if (int32Color === null) {
      return input;
    }

    int32Color = int32Color || 0;
    var r = (int32Color & 0xff000000) >>> 24;
    var g = (int32Color & 0x00ff0000) >>> 16;
    var b = (int32Color & 0x0000ff00) >>> 8;
    var a = (int32Color & 0x000000ff) / 255;
    return "rgba(" + r + ", " + g + ", " + b + ", " + a + ")";
  }

  var stringShapeRegex = /[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?/g;

  function createInterpolationFromStringOutputRange(config) {
    var outputRange = config.outputRange;
    invariant(outputRange.length >= 2, 'Bad output range');
    outputRange = outputRange.map(colorToRgba);
    checkPattern(outputRange);
    var outputRanges = outputRange[0].match(stringShapeRegex).map(function () {
      return [];
    });
    outputRange.forEach(function (value) {
      value.match(stringShapeRegex).forEach(function (number, i) {
        outputRanges[i].push(+number);
      });
    });
    var interpolations = outputRange[0].match(stringShapeRegex).map(function (value, i) {
      return createInterpolation(_objectSpread({}, config, {
        outputRange: outputRanges[i]
      }));
    });
    var shouldRound = isRgbOrRgba(outputRange[0]);
    return function (input) {
      var i = 0;
      return outputRange[0].replace(stringShapeRegex, function () {
        var val = +interpolations[i++](input);

        if (shouldRound) {
          val = i < 4 ? Math.round(val) : Math.round(val * 1000) / 1000;
        }

        return String(val);
      });
    };
  }

  function isRgbOrRgba(range) {
    return typeof range === 'string' && range.startsWith('rgb');
  }

  function checkPattern(arr) {
    var pattern = arr[0].replace(stringShapeRegex, '');

    for (var i = 1; i < arr.length; ++i) {
      invariant(pattern === arr[i].replace(stringShapeRegex, ''), 'invalid pattern ' + arr[0] + ' and ' + arr[i]);
    }
  }

  function findRange(input, inputRange) {
    var i;

    for (i = 1; i < inputRange.length - 1; ++i) {
      if (inputRange[i] >= input) {
        break;
      }
    }

    return i - 1;
  }

  function checkValidInputRange(arr) {
    invariant(arr.length >= 2, 'inputRange must have at least 2 elements');

    for (var i = 1; i < arr.length; ++i) {
      invariant(arr[i] >= arr[i - 1], 'inputRange must be monotonically non-decreasing ' + arr);
    }
  }

  function checkInfiniteRange(name, arr) {
    invariant(arr.length >= 2, name + ' must have at least 2 elements');
    invariant(arr.length !== 2 || arr[0] !== -Infinity || arr[1] !== Infinity, name + 'cannot be ]-infinity;+infinity[ ' + arr);
  }

  var AnimatedInterpolation = function (_AnimatedWithChildren) {
    _inherits(AnimatedInterpolation, _AnimatedWithChildren);

    function AnimatedInterpolation(parent, config) {
      var _this;

      _classCallCheck(this, AnimatedInterpolation);

      _this = _possibleConstructorReturn(this, _getPrototypeOf(AnimatedInterpolation).call(this));
      _this._parent = parent;
      _this._config = config;
      _this._interpolation = createInterpolation(config);
      return _this;
    }

    _createClass(AnimatedInterpolation, [{
      key: "__makeNative",
      value: function __makeNative() {
        this._parent.__makeNative();

        _get(_getPrototypeOf(AnimatedInterpolation.prototype), "__makeNative", this).call(this);
      }
    }, {
      key: "__getValue",
      value: function __getValue() {
        var parentValue = this._parent.__getValue();

        invariant(typeof parentValue === 'number', 'Cannot interpolate an input which is not a number.');
        return this._interpolation(parentValue);
      }
    }, {
      key: "interpolate",
      value: function interpolate(config) {
        return new AnimatedInterpolation(this, config);
      }
    }, {
      key: "__attach",
      value: function __attach() {
        this._parent.__addChild(this);
      }
    }, {
      key: "__detach",
      value: function __detach() {
        this._parent.__removeChild(this);

        _get(_getPrototypeOf(AnimatedInterpolation.prototype), "__detach", this).call(this);
      }
    }, {
      key: "__transformDataType",
      value: function __transformDataType(range) {
        return range.map(NativeAnimatedHelper.transformDataType);
      }
    }, {
      key: "__getNativeConfig",
      value: function __getNativeConfig() {
        if (__DEV__) {
          NativeAnimatedHelper.validateInterpolation(this._config);
        }

        return {
          inputRange: this._config.inputRange,
          outputRange: this.__transformDataType(this._config.outputRange),
          extrapolateLeft: this._config.extrapolateLeft || this._config.extrapolate || 'extend',
          extrapolateRight: this._config.extrapolateRight || this._config.extrapolate || 'extend',
          type: 'interpolation'
        };
      }
    }]);

    return AnimatedInterpolation;
  }(AnimatedWithChildren);

  AnimatedInterpolation.__createInterpolation = createInterpolation;
  module.exports = AnimatedInterpolation;
},265,[24,25,32,34,35,37,46,266,269,267,3,67],"node_modules/react-native/Libraries/Animated/src/nodes/AnimatedInterpolation.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");

  var NativeAnimatedHelper = _$$_REQUIRE(_dependencyMap[2], "../NativeAnimatedHelper");

  var NativeAnimatedAPI = NativeAnimatedHelper.API;

  var invariant = _$$_REQUIRE(_dependencyMap[3], "invariant");

  var _uniqueId = 1;

  var AnimatedNode = function () {
    _createClass(AnimatedNode, [{
      key: "__attach",
      value: function __attach() {}
    }, {
      key: "__detach",
      value: function __detach() {
        if (this.__isNative && this.__nativeTag != null) {
          NativeAnimatedHelper.API.dropAnimatedNode(this.__nativeTag);
          this.__nativeTag = undefined;
        }
      }
    }, {
      key: "__getValue",
      value: function __getValue() {}
    }, {
      key: "__getAnimatedValue",
      value: function __getAnimatedValue() {
        return this.__getValue();
      }
    }, {
      key: "__addChild",
      value: function __addChild(child) {}
    }, {
      key: "__removeChild",
      value: function __removeChild(child) {}
    }, {
      key: "__getChildren",
      value: function __getChildren() {
        return [];
      }
    }]);

    function AnimatedNode() {
      _classCallCheck(this, AnimatedNode);

      this._listeners = {};
    }

    _createClass(AnimatedNode, [{
      key: "__makeNative",
      value: function __makeNative() {
        if (!this.__isNative) {
          throw new Error('This node cannot be made a "native" animated node');
        }

        if (this.hasListeners()) {
          this._startListeningToNativeValueUpdates();
        }
      }
    }, {
      key: "addListener",
      value: function addListener(callback) {
        var id = String(_uniqueId++);
        this._listeners[id] = callback;

        if (this.__isNative) {
          this._startListeningToNativeValueUpdates();
        }

        return id;
      }
    }, {
      key: "removeListener",
      value: function removeListener(id) {
        delete this._listeners[id];

        if (this.__isNative && !this.hasListeners()) {
          this._stopListeningForNativeValueUpdates();
        }
      }
    }, {
      key: "removeAllListeners",
      value: function removeAllListeners() {
        this._listeners = {};

        if (this.__isNative) {
          this._stopListeningForNativeValueUpdates();
        }
      }
    }, {
      key: "hasListeners",
      value: function hasListeners() {
        return !!Object.keys(this._listeners).length;
      }
    }, {
      key: "_startListeningToNativeValueUpdates",
      value: function _startListeningToNativeValueUpdates() {
        var _this = this;

        if (this.__nativeAnimatedValueListener && !this.__shouldUpdateListenersForNewNativeTag) {
          return;
        }

        if (this.__shouldUpdateListenersForNewNativeTag) {
          this.__shouldUpdateListenersForNewNativeTag = false;

          this._stopListeningForNativeValueUpdates();
        }

        NativeAnimatedAPI.startListeningToAnimatedNodeValue(this.__getNativeTag());
        this.__nativeAnimatedValueListener = NativeAnimatedHelper.nativeEventEmitter.addListener('onAnimatedValueUpdate', function (data) {
          if (data.tag !== _this.__getNativeTag()) {
            return;
          }

          _this._onAnimatedValueUpdateReceived(data.value);
        });
      }
    }, {
      key: "_onAnimatedValueUpdateReceived",
      value: function _onAnimatedValueUpdateReceived(value) {
        this.__callListeners(value);
      }
    }, {
      key: "__callListeners",
      value: function __callListeners(value) {
        for (var _key in this._listeners) {
          this._listeners[_key]({
            value: value
          });
        }
      }
    }, {
      key: "_stopListeningForNativeValueUpdates",
      value: function _stopListeningForNativeValueUpdates() {
        if (!this.__nativeAnimatedValueListener) {
          return;
        }

        this.__nativeAnimatedValueListener.remove();

        this.__nativeAnimatedValueListener = null;
        NativeAnimatedAPI.stopListeningToAnimatedNodeValue(this.__getNativeTag());
      }
    }, {
      key: "__getNativeTag",
      value: function __getNativeTag() {
        NativeAnimatedHelper.assertNativeAnimatedModule();
        invariant(this.__isNative, 'Attempt to get native tag from node not marked as "native"');

        if (this.__nativeTag == null) {
          var nativeTag = NativeAnimatedHelper.generateNewNodeTag();
          this.__nativeTag = nativeTag;
          NativeAnimatedHelper.API.createAnimatedNode(nativeTag, this.__getNativeConfig());
          this.__shouldUpdateListenersForNewNativeTag = true;
        }

        return this.__nativeTag;
      }
    }, {
      key: "__getNativeConfig",
      value: function __getNativeConfig() {
        throw new Error('This JS animated node type cannot be used as native animated node');
      }
    }, {
      key: "toJSON",
      value: function toJSON() {
        return this.__getValue();
      }
    }]);

    return AnimatedNode;
  }();

  module.exports = AnimatedNode;
},266,[24,25,267,3],"node_modules/react-native/Libraries/Animated/src/nodes/AnimatedNode.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _NativeEventEmitter = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../../EventEmitter/NativeEventEmitter"));

  var _NativeAnimatedModule = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "./NativeAnimatedModule"));

  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "invariant"));

  var __nativeAnimatedNodeTagCount = 1;
  var __nativeAnimationIdCount = 1;
  var nativeEventEmitter;
  var queueConnections = false;
  var queue = [];
  var API = {
    enableQueue: function enableQueue() {
      queueConnections = true;
    },
    disableQueue: function disableQueue() {
      (0, _invariant.default)(_NativeAnimatedModule.default, 'Native animated module is not available');
      queueConnections = false;

      for (var q = 0, l = queue.length; q < l; q++) {
        var args = queue[q];

        _NativeAnimatedModule.default.connectAnimatedNodes(args[0], args[1]);
      }

      queue.length = 0;
    },
    createAnimatedNode: function createAnimatedNode(tag, config) {
      (0, _invariant.default)(_NativeAnimatedModule.default, 'Native animated module is not available');

      _NativeAnimatedModule.default.createAnimatedNode(tag, config);
    },
    startListeningToAnimatedNodeValue: function startListeningToAnimatedNodeValue(tag) {
      (0, _invariant.default)(_NativeAnimatedModule.default, 'Native animated module is not available');

      _NativeAnimatedModule.default.startListeningToAnimatedNodeValue(tag);
    },
    stopListeningToAnimatedNodeValue: function stopListeningToAnimatedNodeValue(tag) {
      (0, _invariant.default)(_NativeAnimatedModule.default, 'Native animated module is not available');

      _NativeAnimatedModule.default.stopListeningToAnimatedNodeValue(tag);
    },
    connectAnimatedNodes: function connectAnimatedNodes(parentTag, childTag) {
      (0, _invariant.default)(_NativeAnimatedModule.default, 'Native animated module is not available');

      if (queueConnections) {
        queue.push([parentTag, childTag]);
        return;
      }

      _NativeAnimatedModule.default.connectAnimatedNodes(parentTag, childTag);
    },
    disconnectAnimatedNodes: function disconnectAnimatedNodes(parentTag, childTag) {
      (0, _invariant.default)(_NativeAnimatedModule.default, 'Native animated module is not available');

      _NativeAnimatedModule.default.disconnectAnimatedNodes(parentTag, childTag);
    },
    startAnimatingNode: function startAnimatingNode(animationId, nodeTag, config, endCallback) {
      (0, _invariant.default)(_NativeAnimatedModule.default, 'Native animated module is not available');

      _NativeAnimatedModule.default.startAnimatingNode(animationId, nodeTag, config, endCallback);
    },
    stopAnimation: function stopAnimation(animationId) {
      (0, _invariant.default)(_NativeAnimatedModule.default, 'Native animated module is not available');

      _NativeAnimatedModule.default.stopAnimation(animationId);
    },
    setAnimatedNodeValue: function setAnimatedNodeValue(nodeTag, value) {
      (0, _invariant.default)(_NativeAnimatedModule.default, 'Native animated module is not available');

      _NativeAnimatedModule.default.setAnimatedNodeValue(nodeTag, value);
    },
    setAnimatedNodeOffset: function setAnimatedNodeOffset(nodeTag, offset) {
      (0, _invariant.default)(_NativeAnimatedModule.default, 'Native animated module is not available');

      _NativeAnimatedModule.default.setAnimatedNodeOffset(nodeTag, offset);
    },
    flattenAnimatedNodeOffset: function flattenAnimatedNodeOffset(nodeTag) {
      (0, _invariant.default)(_NativeAnimatedModule.default, 'Native animated module is not available');

      _NativeAnimatedModule.default.flattenAnimatedNodeOffset(nodeTag);
    },
    extractAnimatedNodeOffset: function extractAnimatedNodeOffset(nodeTag) {
      (0, _invariant.default)(_NativeAnimatedModule.default, 'Native animated module is not available');

      _NativeAnimatedModule.default.extractAnimatedNodeOffset(nodeTag);
    },
    connectAnimatedNodeToView: function connectAnimatedNodeToView(nodeTag, viewTag) {
      (0, _invariant.default)(_NativeAnimatedModule.default, 'Native animated module is not available');

      _NativeAnimatedModule.default.connectAnimatedNodeToView(nodeTag, viewTag);
    },
    disconnectAnimatedNodeFromView: function disconnectAnimatedNodeFromView(nodeTag, viewTag) {
      (0, _invariant.default)(_NativeAnimatedModule.default, 'Native animated module is not available');

      _NativeAnimatedModule.default.disconnectAnimatedNodeFromView(nodeTag, viewTag);
    },
    dropAnimatedNode: function dropAnimatedNode(tag) {
      (0, _invariant.default)(_NativeAnimatedModule.default, 'Native animated module is not available');

      _NativeAnimatedModule.default.dropAnimatedNode(tag);
    },
    addAnimatedEventToView: function addAnimatedEventToView(viewTag, eventName, eventMapping) {
      (0, _invariant.default)(_NativeAnimatedModule.default, 'Native animated module is not available');

      _NativeAnimatedModule.default.addAnimatedEventToView(viewTag, eventName, eventMapping);
    },
    removeAnimatedEventFromView: function removeAnimatedEventFromView(viewTag, eventName, animatedNodeTag) {
      (0, _invariant.default)(_NativeAnimatedModule.default, 'Native animated module is not available');

      _NativeAnimatedModule.default.removeAnimatedEventFromView(viewTag, eventName, animatedNodeTag);
    }
  };
  var STYLES_WHITELIST = {
    opacity: true,
    transform: true,
    borderRadius: true,
    borderBottomEndRadius: true,
    borderBottomLeftRadius: true,
    borderBottomRightRadius: true,
    borderBottomStartRadius: true,
    borderTopEndRadius: true,
    borderTopLeftRadius: true,
    borderTopRightRadius: true,
    borderTopStartRadius: true,
    elevation: true,
    shadowOpacity: true,
    shadowRadius: true,
    scaleX: true,
    scaleY: true,
    translateX: true,
    translateY: true
  };
  var TRANSFORM_WHITELIST = {
    translateX: true,
    translateY: true,
    scale: true,
    scaleX: true,
    scaleY: true,
    rotate: true,
    rotateX: true,
    rotateY: true,
    rotateZ: true,
    perspective: true
  };
  var SUPPORTED_INTERPOLATION_PARAMS = {
    inputRange: true,
    outputRange: true,
    extrapolate: true,
    extrapolateRight: true,
    extrapolateLeft: true
  };

  function addWhitelistedStyleProp(prop) {
    STYLES_WHITELIST[prop] = true;
  }

  function addWhitelistedTransformProp(prop) {
    TRANSFORM_WHITELIST[prop] = true;
  }

  function addWhitelistedInterpolationParam(param) {
    SUPPORTED_INTERPOLATION_PARAMS[param] = true;
  }

  function validateTransform(configs) {
    configs.forEach(function (config) {
      if (!TRANSFORM_WHITELIST.hasOwnProperty(config.property)) {
        throw new Error("Property '" + config.property + "' is not supported by native animated module");
      }
    });
  }

  function validateStyles(styles) {
    for (var _key in styles) {
      if (!STYLES_WHITELIST.hasOwnProperty(_key)) {
        throw new Error("Style property '" + _key + "' is not supported by native animated module");
      }
    }
  }

  function validateInterpolation(config) {
    for (var _key2 in config) {
      if (!SUPPORTED_INTERPOLATION_PARAMS.hasOwnProperty(_key2)) {
        throw new Error("Interpolation property '" + _key2 + "' is not supported by native animated module");
      }
    }
  }

  function generateNewNodeTag() {
    return __nativeAnimatedNodeTagCount++;
  }

  function generateNewAnimationId() {
    return __nativeAnimationIdCount++;
  }

  function assertNativeAnimatedModule() {
    (0, _invariant.default)(_NativeAnimatedModule.default, 'Native animated module is not available');
  }

  var _warnedMissingNativeAnimated = false;

  function shouldUseNativeDriver(config) {
    if (config.useNativeDriver === true && !_NativeAnimatedModule.default) {
      if (!_warnedMissingNativeAnimated) {
        console.warn('Animated: `useNativeDriver` is not supported because the native ' + 'animated module is missing. Falling back to JS-based animation. To ' + 'resolve this, add `RCTAnimation` module to this app, or remove ' + '`useNativeDriver`. ' + 'More info: https://github.com/facebook/react-native/issues/11094#issuecomment-263240420');
        _warnedMissingNativeAnimated = true;
      }

      return false;
    }

    return config.useNativeDriver || false;
  }

  function transformDataType(value) {
    if (typeof value !== 'string') {
      return value;
    }

    if (/deg$/.test(value)) {
      var degrees = parseFloat(value) || 0;
      var radians = degrees * Math.PI / 180.0;
      return radians;
    } else {
      return value;
    }
  }

  module.exports = {
    API: API,
    addWhitelistedStyleProp: addWhitelistedStyleProp,
    addWhitelistedTransformProp: addWhitelistedTransformProp,
    addWhitelistedInterpolationParam: addWhitelistedInterpolationParam,
    validateStyles: validateStyles,
    validateTransform: validateTransform,
    validateInterpolation: validateInterpolation,
    generateNewNodeTag: generateNewNodeTag,
    generateNewAnimationId: generateNewAnimationId,
    assertNativeAnimatedModule: assertNativeAnimatedModule,
    shouldUseNativeDriver: shouldUseNativeDriver,
    transformDataType: transformDataType,

    get nativeEventEmitter() {
      if (!nativeEventEmitter) {
        nativeEventEmitter = new _NativeEventEmitter.default(_NativeAnimatedModule.default);
      }

      return nativeEventEmitter;
    }

  };
},267,[1,134,268,3],"node_modules/react-native/Libraries/Animated/src/NativeAnimatedHelper.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireWildcard");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[1], "../../TurboModule/TurboModuleRegistry"));

  var _default = TurboModuleRegistry.get('NativeAnimatedModule');

  exports.default = _default;
},268,[9,11],"node_modules/react-native/Libraries/Animated/src/NativeAnimatedModule.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");

  var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");

  var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");

  var _get = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/get");

  var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");

  var AnimatedNode = _$$_REQUIRE(_dependencyMap[6], "./AnimatedNode");

  var NativeAnimatedHelper = _$$_REQUIRE(_dependencyMap[7], "../NativeAnimatedHelper");

  var AnimatedWithChildren = function (_AnimatedNode) {
    _inherits(AnimatedWithChildren, _AnimatedNode);

    function AnimatedWithChildren() {
      var _this;

      _classCallCheck(this, AnimatedWithChildren);

      _this = _possibleConstructorReturn(this, _getPrototypeOf(AnimatedWithChildren).call(this));
      _this._children = [];
      return _this;
    }

    _createClass(AnimatedWithChildren, [{
      key: "__makeNative",
      value: function __makeNative() {
        if (!this.__isNative) {
          this.__isNative = true;

          for (var _iterator = this._children, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"]();;) {
            var _ref;

            if (_isArray) {
              if (_i >= _iterator.length) break;
              _ref = _iterator[_i++];
            } else {
              _i = _iterator.next();
              if (_i.done) break;
              _ref = _i.value;
            }

            var _child = _ref;

            _child.__makeNative();

            NativeAnimatedHelper.API.connectAnimatedNodes(this.__getNativeTag(), _child.__getNativeTag());
          }
        }

        _get(_getPrototypeOf(AnimatedWithChildren.prototype), "__makeNative", this).call(this);
      }
    }, {
      key: "__addChild",
      value: function __addChild(child) {
        if (this._children.length === 0) {
          this.__attach();
        }

        this._children.push(child);

        if (this.__isNative) {
          child.__makeNative();

          NativeAnimatedHelper.API.connectAnimatedNodes(this.__getNativeTag(), child.__getNativeTag());
        }
      }
    }, {
      key: "__removeChild",
      value: function __removeChild(child) {
        var index = this._children.indexOf(child);

        if (index === -1) {
          console.warn("Trying to remove a child that doesn't exist");
          return;
        }

        if (this.__isNative && child.__isNative) {
          NativeAnimatedHelper.API.disconnectAnimatedNodes(this.__getNativeTag(), child.__getNativeTag());
        }

        this._children.splice(index, 1);

        if (this._children.length === 0) {
          this.__detach();
        }
      }
    }, {
      key: "__getChildren",
      value: function __getChildren() {
        return this._children;
      }
    }, {
      key: "__callListeners",
      value: function __callListeners(value) {
        _get(_getPrototypeOf(AnimatedWithChildren.prototype), "__callListeners", this).call(this, value);

        if (!this.__isNative) {
          for (var _iterator2 = this._children, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"]();;) {
            var _ref2;

            if (_isArray2) {
              if (_i2 >= _iterator2.length) break;
              _ref2 = _iterator2[_i2++];
            } else {
              _i2 = _iterator2.next();
              if (_i2.done) break;
              _ref2 = _i2.value;
            }

            var _child2 = _ref2;

            if (_child2.__getValue) {
              _child2.__callListeners(_child2.__getValue());
            }
          }
        }
      }
    }]);

    return AnimatedWithChildren;
  }(AnimatedNode);

  module.exports = AnimatedWithChildren;
},269,[24,25,32,34,35,37,266,267],"node_modules/react-native/Libraries/Animated/src/nodes/AnimatedWithChildren.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var BatchedBridge = _$$_REQUIRE(_dependencyMap[0], "../BatchedBridge/BatchedBridge");

  var EventEmitter = _$$_REQUIRE(_dependencyMap[1], "../vendor/emitter/EventEmitter");

  var TaskQueue = _$$_REQUIRE(_dependencyMap[2], "./TaskQueue");

  var infoLog = _$$_REQUIRE(_dependencyMap[3], "../Utilities/infoLog");

  var invariant = _$$_REQUIRE(_dependencyMap[4], "invariant");

  var keyMirror = _$$_REQUIRE(_dependencyMap[5], "fbjs/lib/keyMirror");

  var _emitter = new EventEmitter();

  var DEBUG_DELAY = 0;
  var DEBUG = false;
  var InteractionManager = {
    Events: keyMirror({
      interactionStart: true,
      interactionComplete: true
    }),
    runAfterInteractions: function runAfterInteractions(task) {
      var tasks = [];
      var promise = new Promise(function (resolve) {
        _scheduleUpdate();

        if (task) {
          tasks.push(task);
        }

        tasks.push({
          run: resolve,
          name: 'resolve ' + (task && task.name || '?')
        });

        _taskQueue.enqueueTasks(tasks);
      });
      return {
        then: promise.then.bind(promise),
        done: function done() {
          if (promise.done) {
            return promise.done.apply(promise, arguments);
          } else {
            console.warn('Tried to call done when not supported by current Promise implementation.');
          }
        },
        cancel: function cancel() {
          _taskQueue.cancelTasks(tasks);
        }
      };
    },
    createInteractionHandle: function createInteractionHandle() {
      DEBUG && infoLog('InteractionManager: create interaction handle');

      _scheduleUpdate();

      var handle = ++_inc;

      _addInteractionSet.add(handle);

      return handle;
    },
    clearInteractionHandle: function clearInteractionHandle(handle) {
      DEBUG && infoLog('InteractionManager: clear interaction handle');
      invariant(!!handle, 'InteractionManager: Must provide a handle to clear.');

      _scheduleUpdate();

      _addInteractionSet.delete(handle);

      _deleteInteractionSet.add(handle);
    },
    addListener: _emitter.addListener.bind(_emitter),
    setDeadline: function setDeadline(deadline) {
      _deadline = deadline;
    }
  };

  var _interactionSet = new Set();

  var _addInteractionSet = new Set();

  var _deleteInteractionSet = new Set();

  var _taskQueue = new TaskQueue({
    onMoreTasks: _scheduleUpdate
  });

  var _nextUpdateHandle = 0;
  var _inc = 0;

  var _deadline = -1;

  function _scheduleUpdate() {
    if (!_nextUpdateHandle) {
      if (_deadline > 0) {
        _nextUpdateHandle = setTimeout(_processUpdate, 0 + DEBUG_DELAY);
      } else {
        _nextUpdateHandle = setImmediate(_processUpdate);
      }
    }
  }

  function _processUpdate() {
    _nextUpdateHandle = 0;
    var interactionCount = _interactionSet.size;

    _addInteractionSet.forEach(function (handle) {
      return _interactionSet.add(handle);
    });

    _deleteInteractionSet.forEach(function (handle) {
      return _interactionSet.delete(handle);
    });

    var nextInteractionCount = _interactionSet.size;

    if (interactionCount !== 0 && nextInteractionCount === 0) {
      _emitter.emit(InteractionManager.Events.interactionComplete);
    } else if (interactionCount === 0 && nextInteractionCount !== 0) {
      _emitter.emit(InteractionManager.Events.interactionStart);
    }

    if (nextInteractionCount === 0) {
      while (_taskQueue.hasTasksToProcess()) {
        _taskQueue.processNext();

        if (_deadline > 0 && BatchedBridge.getEventLoopRunningTime() >= _deadline) {
          _scheduleUpdate();

          break;
        }
      }
    }

    _addInteractionSet.clear();

    _deleteInteractionSet.clear();
  }

  module.exports = InteractionManager;
},270,[18,39,271,161,3,247],"node_modules/react-native/Libraries/Interaction/InteractionManager.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass");

  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

  var infoLog = _$$_REQUIRE(_dependencyMap[3], "../Utilities/infoLog");

  var invariant = _$$_REQUIRE(_dependencyMap[4], "invariant");

  var DEBUG = false;

  var TaskQueue = function () {
    function TaskQueue(_ref) {
      var onMoreTasks = _ref.onMoreTasks;

      _classCallCheck(this, TaskQueue);

      this._onMoreTasks = onMoreTasks;
      this._queueStack = [{
        tasks: [],
        popable: false
      }];
    }

    _createClass(TaskQueue, [{
      key: "enqueue",
      value: function enqueue(task) {
        this._getCurrentQueue().push(task);
      }
    }, {
      key: "enqueueTasks",
      value: function enqueueTasks(tasks) {
        var _this = this;

        tasks.forEach(function (task) {
          return _this.enqueue(task);
        });
      }
    }, {
      key: "cancelTasks",
      value: function cancelTasks(tasksToCancel) {
        this._queueStack = this._queueStack.map(function (queue) {
          return _objectSpread({}, queue, {
            tasks: queue.tasks.filter(function (task) {
              return tasksToCancel.indexOf(task) === -1;
            })
          });
        }).filter(function (queue, idx) {
          return queue.tasks.length > 0 || idx === 0;
        });
      }
    }, {
      key: "hasTasksToProcess",
      value: function hasTasksToProcess() {
        return this._getCurrentQueue().length > 0;
      }
    }, {
      key: "processNext",
      value: function processNext() {
        var queue = this._getCurrentQueue();

        if (queue.length) {
          var task = queue.shift();

          try {
            if (task.gen) {
              DEBUG && infoLog('TaskQueue: genPromise for task ' + task.name);

              this._genPromise(task);
            } else if (task.run) {
              DEBUG && infoLog('TaskQueue: run task ' + task.name);
              task.run();
            } else {
              invariant(typeof task === 'function', 'Expected Function, SimpleTask, or PromiseTask, but got:\n' + JSON.stringify(task, null, 2));
              DEBUG && infoLog('TaskQueue: run anonymous task');
              task();
            }
          } catch (e) {
            e.message = 'TaskQueue: Error with task ' + (task.name || '') + ': ' + e.message;
            throw e;
          }
        }
      }
    }, {
      key: "_getCurrentQueue",
      value: function _getCurrentQueue() {
        var stackIdx = this._queueStack.length - 1;
        var queue = this._queueStack[stackIdx];

        if (queue.popable && queue.tasks.length === 0 && this._queueStack.length > 1) {
          this._queueStack.pop();

          DEBUG && infoLog('TaskQueue: popped queue: ', {
            stackIdx: stackIdx,
            queueStackSize: this._queueStack.length
          });
          return this._getCurrentQueue();
        } else {
          return queue.tasks;
        }
      }
    }, {
      key: "_genPromise",
      value: function _genPromise(task) {
        var _this2 = this;

        this._queueStack.push({
          tasks: [],
          popable: false
        });

        var stackIdx = this._queueStack.length - 1;
        DEBUG && infoLog('TaskQueue: push new queue: ', {
          stackIdx: stackIdx
        });
        DEBUG && infoLog('TaskQueue: exec gen task ' + task.name);
        task.gen().then(function () {
          DEBUG && infoLog('TaskQueue: onThen for gen task ' + task.name, {
            stackIdx: stackIdx,
            queueStackSize: _this2._queueStack.length
          });
          _this2._queueStack[stackIdx].popable = true;
          _this2.hasTasksToProcess() && _this2._onMoreTasks();
        }).catch(function (ex) {
          ex.message = "TaskQueue: Error resolving Promise in task " + task.name + ": " + ex.message;
          throw ex;
        }).done();
      }
    }]);

    return TaskQueue;
  }();

  module.exports = TaskQueue;
},271,[46,24,25,161,3],"node_modules/react-native/Libraries/Interaction/TaskQueue.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");

  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

  var _require = _$$_REQUIRE(_dependencyMap[1], "./AnimatedEvent"),
      AnimatedEvent = _require.AnimatedEvent,
      attachNativeEvent = _require.attachNativeEvent;

  var AnimatedAddition = _$$_REQUIRE(_dependencyMap[2], "./nodes/AnimatedAddition");

  var AnimatedDiffClamp = _$$_REQUIRE(_dependencyMap[3], "./nodes/AnimatedDiffClamp");

  var AnimatedDivision = _$$_REQUIRE(_dependencyMap[4], "./nodes/AnimatedDivision");

  var AnimatedInterpolation = _$$_REQUIRE(_dependencyMap[5], "./nodes/AnimatedInterpolation");

  var AnimatedModulo = _$$_REQUIRE(_dependencyMap[6], "./nodes/AnimatedModulo");

  var AnimatedMultiplication = _$$_REQUIRE(_dependencyMap[7], "./nodes/AnimatedMultiplication");

  var AnimatedNode = _$$_REQUIRE(_dependencyMap[8], "./nodes/AnimatedNode");

  var AnimatedProps = _$$_REQUIRE(_dependencyMap[9], "./nodes/AnimatedProps");

  var AnimatedSubtraction = _$$_REQUIRE(_dependencyMap[10], "./nodes/AnimatedSubtraction");

  var AnimatedTracking = _$$_REQUIRE(_dependencyMap[11], "./nodes/AnimatedTracking");

  var AnimatedValue = _$$_REQUIRE(_dependencyMap[12], "./nodes/AnimatedValue");

  var AnimatedValueXY = _$$_REQUIRE(_dependencyMap[13], "./nodes/AnimatedValueXY");

  var DecayAnimation = _$$_REQUIRE(_dependencyMap[14], "./animations/DecayAnimation");

  var SpringAnimation = _$$_REQUIRE(_dependencyMap[15], "./animations/SpringAnimation");

  var TimingAnimation = _$$_REQUIRE(_dependencyMap[16], "./animations/TimingAnimation");

  var createAnimatedComponent = _$$_REQUIRE(_dependencyMap[17], "./createAnimatedComponent");

  var add = function add(a, b) {
    return new AnimatedAddition(a, b);
  };

  var subtract = function subtract(a, b) {
    return new AnimatedSubtraction(a, b);
  };

  var divide = function divide(a, b) {
    return new AnimatedDivision(a, b);
  };

  var multiply = function multiply(a, b) {
    return new AnimatedMultiplication(a, b);
  };

  var modulo = function modulo(a, modulus) {
    return new AnimatedModulo(a, modulus);
  };

  var diffClamp = function diffClamp(a, min, max) {
    return new AnimatedDiffClamp(a, min, max);
  };

  var _combineCallbacks = function _combineCallbacks(callback, config) {
    if (callback && config.onComplete) {
      return function () {
        config.onComplete && config.onComplete.apply(config, arguments);
        callback && callback.apply(void 0, arguments);
      };
    } else {
      return callback || config.onComplete;
    }
  };

  var maybeVectorAnim = function maybeVectorAnim(value, config, anim) {
    if (value instanceof AnimatedValueXY) {
      var configX = _objectSpread({}, config);

      var configY = _objectSpread({}, config);

      for (var key in config) {
        var _config$key = config[key],
            x = _config$key.x,
            y = _config$key.y;

        if (x !== undefined && y !== undefined) {
          configX[key] = x;
          configY[key] = y;
        }
      }

      var aX = anim(value.x, configX);
      var aY = anim(value.y, configY);
      return parallel([aX, aY], {
        stopTogether: false
      });
    }

    return null;
  };

  var spring = function spring(value, config) {
    var _start = function start(animatedValue, configuration, callback) {
      callback = _combineCallbacks(callback, configuration);
      var singleValue = animatedValue;
      var singleConfig = configuration;
      singleValue.stopTracking();

      if (configuration.toValue instanceof AnimatedNode) {
        singleValue.track(new AnimatedTracking(singleValue, configuration.toValue, SpringAnimation, singleConfig, callback));
      } else {
        singleValue.animate(new SpringAnimation(singleConfig), callback);
      }
    };

    return maybeVectorAnim(value, config, spring) || {
      start: function start(callback) {
        _start(value, config, callback);
      },
      stop: function stop() {
        value.stopAnimation();
      },
      reset: function reset() {
        value.resetAnimation();
      },
      _startNativeLoop: function _startNativeLoop(iterations) {
        var singleConfig = _objectSpread({}, config, {
          iterations: iterations
        });

        _start(value, singleConfig);
      },
      _isUsingNativeDriver: function _isUsingNativeDriver() {
        return config.useNativeDriver || false;
      }
    };
  };

  var timing = function timing(value, config) {
    var _start2 = function start(animatedValue, configuration, callback) {
      callback = _combineCallbacks(callback, configuration);
      var singleValue = animatedValue;
      var singleConfig = configuration;
      singleValue.stopTracking();

      if (configuration.toValue instanceof AnimatedNode) {
        singleValue.track(new AnimatedTracking(singleValue, configuration.toValue, TimingAnimation, singleConfig, callback));
      } else {
        singleValue.animate(new TimingAnimation(singleConfig), callback);
      }
    };

    return maybeVectorAnim(value, config, timing) || {
      start: function start(callback) {
        _start2(value, config, callback);
      },
      stop: function stop() {
        value.stopAnimation();
      },
      reset: function reset() {
        value.resetAnimation();
      },
      _startNativeLoop: function _startNativeLoop(iterations) {
        var singleConfig = _objectSpread({}, config, {
          iterations: iterations
        });

        _start2(value, singleConfig);
      },
      _isUsingNativeDriver: function _isUsingNativeDriver() {
        return config.useNativeDriver || false;
      }
    };
  };

  var decay = function decay(value, config) {
    var _start3 = function start(animatedValue, configuration, callback) {
      callback = _combineCallbacks(callback, configuration);
      var singleValue = animatedValue;
      var singleConfig = configuration;
      singleValue.stopTracking();
      singleValue.animate(new DecayAnimation(singleConfig), callback);
    };

    return maybeVectorAnim(value, config, decay) || {
      start: function start(callback) {
        _start3(value, config, callback);
      },
      stop: function stop() {
        value.stopAnimation();
      },
      reset: function reset() {
        value.resetAnimation();
      },
      _startNativeLoop: function _startNativeLoop(iterations) {
        var singleConfig = _objectSpread({}, config, {
          iterations: iterations
        });

        _start3(value, singleConfig);
      },
      _isUsingNativeDriver: function _isUsingNativeDriver() {
        return config.useNativeDriver || false;
      }
    };
  };

  var sequence = function sequence(animations) {
    var current = 0;
    return {
      start: function start(callback) {
        var onComplete = function onComplete(result) {
          if (!result.finished) {
            callback && callback(result);
            return;
          }

          current++;

          if (current === animations.length) {
            callback && callback(result);
            return;
          }

          animations[current].start(onComplete);
        };

        if (animations.length === 0) {
          callback && callback({
            finished: true
          });
        } else {
          animations[current].start(onComplete);
        }
      },
      stop: function stop() {
        if (current < animations.length) {
          animations[current].stop();
        }
      },
      reset: function reset() {
        animations.forEach(function (animation, idx) {
          if (idx <= current) {
            animation.reset();
          }
        });
        current = 0;
      },
      _startNativeLoop: function _startNativeLoop() {
        throw new Error('Loops run using the native driver cannot contain Animated.sequence animations');
      },
      _isUsingNativeDriver: function _isUsingNativeDriver() {
        return false;
      }
    };
  };

  var parallel = function parallel(animations, config) {
    var doneCount = 0;
    var hasEnded = {};
    var stopTogether = !(config && config.stopTogether === false);
    var result = {
      start: function start(callback) {
        if (doneCount === animations.length) {
          callback && callback({
            finished: true
          });
          return;
        }

        animations.forEach(function (animation, idx) {
          var cb = function cb(endResult) {
            hasEnded[idx] = true;
            doneCount++;

            if (doneCount === animations.length) {
              doneCount = 0;
              callback && callback(endResult);
              return;
            }

            if (!endResult.finished && stopTogether) {
              result.stop();
            }
          };

          if (!animation) {
            cb({
              finished: true
            });
          } else {
            animation.start(cb);
          }
        });
      },
      stop: function stop() {
        animations.forEach(function (animation, idx) {
          !hasEnded[idx] && animation.stop();
          hasEnded[idx] = true;
        });
      },
      reset: function reset() {
        animations.forEach(function (animation, idx) {
          animation.reset();
          hasEnded[idx] = false;
          doneCount = 0;
        });
      },
      _startNativeLoop: function _startNativeLoop() {
        throw new Error('Loops run using the native driver cannot contain Animated.parallel animations');
      },
      _isUsingNativeDriver: function _isUsingNativeDriver() {
        return false;
      }
    };
    return result;
  };

  var delay = function delay(time) {
    return timing(new AnimatedValue(0), {
      toValue: 0,
      delay: time,
      duration: 0,
      useNativeDriver: false
    });
  };

  var stagger = function stagger(time, animations) {
    return parallel(animations.map(function (animation, i) {
      return sequence([delay(time * i), animation]);
    }));
  };

  var loop = function loop(animation) {
    var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
        _ref$iterations = _ref.iterations,
        iterations = _ref$iterations === void 0 ? -1 : _ref$iterations,
        _ref$resetBeforeItera = _ref.resetBeforeIteration,
        resetBeforeIteration = _ref$resetBeforeItera === void 0 ? true : _ref$resetBeforeItera;

    var isFinished = false;
    var iterationsSoFar = 0;
    return {
      start: function start(callback) {
        var restart = function restart() {
          var result = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
            finished: true
          };

          if (isFinished || iterationsSoFar === iterations || result.finished === false) {
            callback && callback(result);
          } else {
            iterationsSoFar++;
            resetBeforeIteration && animation.reset();
            animation.start(restart);
          }
        };

        if (!animation || iterations === 0) {
          callback && callback({
            finished: true
          });
        } else {
          if (animation._isUsingNativeDriver()) {
            animation._startNativeLoop(iterations);
          } else {
            restart();
          }
        }
      },
      stop: function stop() {
        isFinished = true;
        animation.stop();
      },
      reset: function reset() {
        iterationsSoFar = 0;
        isFinished = false;
        animation.reset();
      },
      _startNativeLoop: function _startNativeLoop() {
        throw new Error('Loops run using the native driver cannot contain Animated.loop animations');
      },
      _isUsingNativeDriver: function _isUsingNativeDriver() {
        return animation._isUsingNativeDriver();
      }
    };
  };

  function forkEvent(event, listener) {
    if (!event) {
      return listener;
    } else if (event instanceof AnimatedEvent) {
      event.__addListener(listener);

      return event;
    } else {
      return function () {
        typeof event === 'function' && event.apply(void 0, arguments);
        listener.apply(void 0, arguments);
      };
    }
  }

  function unforkEvent(event, listener) {
    if (event && event instanceof AnimatedEvent) {
      event.__removeListener(listener);
    }
  }

  var event = function event(argMapping, config) {
    var animatedEvent = new AnimatedEvent(argMapping, config);

    if (animatedEvent.__isNative) {
      return animatedEvent;
    } else {
      return animatedEvent.__getHandler();
    }
  };

  module.exports = {
    Value: AnimatedValue,
    ValueXY: AnimatedValueXY,
    Interpolation: AnimatedInterpolation,
    Node: AnimatedNode,
    decay: decay,
    timing: timing,
    spring: spring,
    add: add,
    subtract: subtract,
    divide: divide,
    multiply: multiply,
    modulo: modulo,
    diffClamp: diffClamp,
    delay: delay,
    sequence: sequence,
    parallel: parallel,
    stagger: stagger,
    loop: loop,
    event: event,
    createAnimatedComponent: createAnimatedComponent,
    attachNativeEvent: attachNativeEvent,
    forkEvent: forkEvent,
    unforkEvent: unforkEvent,
    Event: AnimatedEvent,
    __PropsOnlyForTests: AnimatedProps
  };
},272,[46,263,273,274,275,265,276,277,266,278,281,282,264,283,284,286,288,291],"node_modules/react-native/Libraries/Animated/src/AnimatedImplementation.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");

  var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");

  var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");

  var _get = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/get");

  var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");

  var AnimatedInterpolation = _$$_REQUIRE(_dependencyMap[6], "./AnimatedInterpolation");

  var AnimatedNode = _$$_REQUIRE(_dependencyMap[7], "./AnimatedNode");

  var AnimatedValue = _$$_REQUIRE(_dependencyMap[8], "./AnimatedValue");

  var AnimatedWithChildren = _$$_REQUIRE(_dependencyMap[9], "./AnimatedWithChildren");

  var AnimatedAddition = function (_AnimatedWithChildren) {
    _inherits(AnimatedAddition, _AnimatedWithChildren);

    function AnimatedAddition(a, b) {
      var _this;

      _classCallCheck(this, AnimatedAddition);

      _this = _possibleConstructorReturn(this, _getPrototypeOf(AnimatedAddition).call(this));
      _this._a = typeof a === 'number' ? new AnimatedValue(a) : a;
      _this._b = typeof b === 'number' ? new AnimatedValue(b) : b;
      return _this;
    }

    _createClass(AnimatedAddition, [{
      key: "__makeNative",
      value: function __makeNative() {
        this._a.__makeNative();

        this._b.__makeNative();

        _get(_getPrototypeOf(AnimatedAddition.prototype), "__makeNative", this).call(this);
      }
    }, {
      key: "__getValue",
      value: function __getValue() {
        return this._a.__getValue() + this._b.__getValue();
      }
    }, {
      key: "interpolate",
      value: function interpolate(config) {
        return new AnimatedInterpolation(this, config);
      }
    }, {
      key: "__attach",
      value: function __attach() {
        this._a.__addChild(this);

        this._b.__addChild(this);
      }
    }, {
      key: "__detach",
      value: function __detach() {
        this._a.__removeChild(this);

        this._b.__removeChild(this);

        _get(_getPrototypeOf(AnimatedAddition.prototype), "__detach", this).call(this);
      }
    }, {
      key: "__getNativeConfig",
      value: function __getNativeConfig() {
        return {
          type: 'addition',
          input: [this._a.__getNativeTag(), this._b.__getNativeTag()]
        };
      }
    }]);

    return AnimatedAddition;
  }(AnimatedWithChildren);

  module.exports = AnimatedAddition;
},273,[24,25,32,34,35,37,265,266,264,269],"node_modules/react-native/Libraries/Animated/src/nodes/AnimatedAddition.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");

  var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");

  var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");

  var _get = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/get");

  var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");

  var AnimatedInterpolation = _$$_REQUIRE(_dependencyMap[6], "./AnimatedInterpolation");

  var AnimatedNode = _$$_REQUIRE(_dependencyMap[7], "./AnimatedNode");

  var AnimatedWithChildren = _$$_REQUIRE(_dependencyMap[8], "./AnimatedWithChildren");

  var AnimatedDiffClamp = function (_AnimatedWithChildren) {
    _inherits(AnimatedDiffClamp, _AnimatedWithChildren);

    function AnimatedDiffClamp(a, min, max) {
      var _this;

      _classCallCheck(this, AnimatedDiffClamp);

      _this = _possibleConstructorReturn(this, _getPrototypeOf(AnimatedDiffClamp).call(this));
      _this._a = a;
      _this._min = min;
      _this._max = max;
      _this._value = _this._lastValue = _this._a.__getValue();
      return _this;
    }

    _createClass(AnimatedDiffClamp, [{
      key: "__makeNative",
      value: function __makeNative() {
        this._a.__makeNative();

        _get(_getPrototypeOf(AnimatedDiffClamp.prototype), "__makeNative", this).call(this);
      }
    }, {
      key: "interpolate",
      value: function interpolate(config) {
        return new AnimatedInterpolation(this, config);
      }
    }, {
      key: "__getValue",
      value: function __getValue() {
        var value = this._a.__getValue();

        var diff = value - this._lastValue;
        this._lastValue = value;
        this._value = Math.min(Math.max(this._value + diff, this._min), this._max);
        return this._value;
      }
    }, {
      key: "__attach",
      value: function __attach() {
        this._a.__addChild(this);
      }
    }, {
      key: "__detach",
      value: function __detach() {
        this._a.__removeChild(this);

        _get(_getPrototypeOf(AnimatedDiffClamp.prototype), "__detach", this).call(this);
      }
    }, {
      key: "__getNativeConfig",
      value: function __getNativeConfig() {
        return {
          type: 'diffclamp',
          input: this._a.__getNativeTag(),
          min: this._min,
          max: this._max
        };
      }
    }]);

    return AnimatedDiffClamp;
  }(AnimatedWithChildren);

  module.exports = AnimatedDiffClamp;
},274,[24,25,32,34,35,37,265,266,269],"node_modules/react-native/Libraries/Animated/src/nodes/AnimatedDiffClamp.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");

  var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");

  var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");

  var _get = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/get");

  var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");

  var AnimatedInterpolation = _$$_REQUIRE(_dependencyMap[6], "./AnimatedInterpolation");

  var AnimatedNode = _$$_REQUIRE(_dependencyMap[7], "./AnimatedNode");

  var AnimatedValue = _$$_REQUIRE(_dependencyMap[8], "./AnimatedValue");

  var AnimatedWithChildren = _$$_REQUIRE(_dependencyMap[9], "./AnimatedWithChildren");

  var AnimatedDivision = function (_AnimatedWithChildren) {
    _inherits(AnimatedDivision, _AnimatedWithChildren);

    function AnimatedDivision(a, b) {
      var _this;

      _classCallCheck(this, AnimatedDivision);

      _this = _possibleConstructorReturn(this, _getPrototypeOf(AnimatedDivision).call(this));
      _this._a = typeof a === 'number' ? new AnimatedValue(a) : a;
      _this._b = typeof b === 'number' ? new AnimatedValue(b) : b;
      return _this;
    }

    _createClass(AnimatedDivision, [{
      key: "__makeNative",
      value: function __makeNative() {
        this._a.__makeNative();

        this._b.__makeNative();

        _get(_getPrototypeOf(AnimatedDivision.prototype), "__makeNative", this).call(this);
      }
    }, {
      key: "__getValue",
      value: function __getValue() {
        var a = this._a.__getValue();

        var b = this._b.__getValue();

        if (b === 0) {
          console.error('Detected division by zero in AnimatedDivision');
        }

        return a / b;
      }
    }, {
      key: "interpolate",
      value: function interpolate(config) {
        return new AnimatedInterpolation(this, config);
      }
    }, {
      key: "__attach",
      value: function __attach() {
        this._a.__addChild(this);

        this._b.__addChild(this);
      }
    }, {
      key: "__detach",
      value: function __detach() {
        this._a.__removeChild(this);

        this._b.__removeChild(this);

        _get(_getPrototypeOf(AnimatedDivision.prototype), "__detach", this).call(this);
      }
    }, {
      key: "__getNativeConfig",
      value: function __getNativeConfig() {
        return {
          type: 'division',
          input: [this._a.__getNativeTag(), this._b.__getNativeTag()]
        };
      }
    }]);

    return AnimatedDivision;
  }(AnimatedWithChildren);

  module.exports = AnimatedDivision;
},275,[24,25,32,34,35,37,265,266,264,269],"node_modules/react-native/Libraries/Animated/src/nodes/AnimatedDivision.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");

  var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");

  var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");

  var _get = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/get");

  var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");

  var AnimatedInterpolation = _$$_REQUIRE(_dependencyMap[6], "./AnimatedInterpolation");

  var AnimatedNode = _$$_REQUIRE(_dependencyMap[7], "./AnimatedNode");

  var AnimatedWithChildren = _$$_REQUIRE(_dependencyMap[8], "./AnimatedWithChildren");

  var AnimatedModulo = function (_AnimatedWithChildren) {
    _inherits(AnimatedModulo, _AnimatedWithChildren);

    function AnimatedModulo(a, modulus) {
      var _this;

      _classCallCheck(this, AnimatedModulo);

      _this = _possibleConstructorReturn(this, _getPrototypeOf(AnimatedModulo).call(this));
      _this._a = a;
      _this._modulus = modulus;
      return _this;
    }

    _createClass(AnimatedModulo, [{
      key: "__makeNative",
      value: function __makeNative() {
        this._a.__makeNative();

        _get(_getPrototypeOf(AnimatedModulo.prototype), "__makeNative", this).call(this);
      }
    }, {
      key: "__getValue",
      value: function __getValue() {
        return (this._a.__getValue() % this._modulus + this._modulus) % this._modulus;
      }
    }, {
      key: "interpolate",
      value: function interpolate(config) {
        return new AnimatedInterpolation(this, config);
      }
    }, {
      key: "__attach",
      value: function __attach() {
        this._a.__addChild(this);
      }
    }, {
      key: "__detach",
      value: function __detach() {
        this._a.__removeChild(this);

        _get(_getPrototypeOf(AnimatedModulo.prototype), "__detach", this).call(this);
      }
    }, {
      key: "__getNativeConfig",
      value: function __getNativeConfig() {
        return {
          type: 'modulus',
          input: this._a.__getNativeTag(),
          modulus: this._modulus
        };
      }
    }]);

    return AnimatedModulo;
  }(AnimatedWithChildren);

  module.exports = AnimatedModulo;
},276,[24,25,32,34,35,37,265,266,269],"node_modules/react-native/Libraries/Animated/src/nodes/AnimatedModulo.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");

  var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");

  var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");

  var _get = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/get");

  var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");

  var AnimatedInterpolation = _$$_REQUIRE(_dependencyMap[6], "./AnimatedInterpolation");

  var AnimatedNode = _$$_REQUIRE(_dependencyMap[7], "./AnimatedNode");

  var AnimatedValue = _$$_REQUIRE(_dependencyMap[8], "./AnimatedValue");

  var AnimatedWithChildren = _$$_REQUIRE(_dependencyMap[9], "./AnimatedWithChildren");

  var AnimatedMultiplication = function (_AnimatedWithChildren) {
    _inherits(AnimatedMultiplication, _AnimatedWithChildren);

    function AnimatedMultiplication(a, b) {
      var _this;

      _classCallCheck(this, AnimatedMultiplication);

      _this = _possibleConstructorReturn(this, _getPrototypeOf(AnimatedMultiplication).call(this));
      _this._a = typeof a === 'number' ? new AnimatedValue(a) : a;
      _this._b = typeof b === 'number' ? new AnimatedValue(b) : b;
      return _this;
    }

    _createClass(AnimatedMultiplication, [{
      key: "__makeNative",
      value: function __makeNative() {
        this._a.__makeNative();

        this._b.__makeNative();

        _get(_getPrototypeOf(AnimatedMultiplication.prototype), "__makeNative", this).call(this);
      }
    }, {
      key: "__getValue",
      value: function __getValue() {
        return this._a.__getValue() * this._b.__getValue();
      }
    }, {
      key: "interpolate",
      value: function interpolate(config) {
        return new AnimatedInterpolation(this, config);
      }
    }, {
      key: "__attach",
      value: function __attach() {
        this._a.__addChild(this);

        this._b.__addChild(this);
      }
    }, {
      key: "__detach",
      value: function __detach() {
        this._a.__removeChild(this);

        this._b.__removeChild(this);

        _get(_getPrototypeOf(AnimatedMultiplication.prototype), "__detach", this).call(this);
      }
    }, {
      key: "__getNativeConfig",
      value: function __getNativeConfig() {
        return {
          type: 'multiplication',
          input: [this._a.__getNativeTag(), this._b.__getNativeTag()]
        };
      }
    }]);

    return AnimatedMultiplication;
  }(AnimatedWithChildren);

  module.exports = AnimatedMultiplication;
},277,[24,25,32,34,35,37,265,266,264,269],"node_modules/react-native/Libraries/Animated/src/nodes/AnimatedMultiplication.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass");

  var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn");

  var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf");

  var _get = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/get");

  var _inherits = _$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits");

  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

  var _require = _$$_REQUIRE(_dependencyMap[7], "../AnimatedEvent"),
      AnimatedEvent = _require.AnimatedEvent;

  var AnimatedNode = _$$_REQUIRE(_dependencyMap[8], "./AnimatedNode");

  var AnimatedStyle = _$$_REQUIRE(_dependencyMap[9], "./AnimatedStyle");

  var NativeAnimatedHelper = _$$_REQUIRE(_dependencyMap[10], "../NativeAnimatedHelper");

  var ReactNative = _$$_REQUIRE(_dependencyMap[11], "../../../Renderer/shims/ReactNative");

  var invariant = _$$_REQUIRE(_dependencyMap[12], "invariant");

  var AnimatedProps = function (_AnimatedNode) {
    _inherits(AnimatedProps, _AnimatedNode);

    function AnimatedProps(props, callback) {
      var _this;

      _classCallCheck(this, AnimatedProps);

      _this = _possibleConstructorReturn(this, _getPrototypeOf(AnimatedProps).call(this));

      if (props.style) {
        props = _objectSpread({}, props, {
          style: new AnimatedStyle(props.style)
        });
      }

      _this._props = props;
      _this._callback = callback;

      _this.__attach();

      return _this;
    }

    _createClass(AnimatedProps, [{
      key: "__getValue",
      value: function __getValue() {
        var props = {};

        for (var key in this._props) {
          var value = this._props[key];

          if (value instanceof AnimatedNode) {
            if (!value.__isNative || value instanceof AnimatedStyle) {
              props[key] = value.__getValue();
            }
          } else if (value instanceof AnimatedEvent) {
            props[key] = value.__getHandler();
          } else {
            props[key] = value;
          }
        }

        return props;
      }
    }, {
      key: "__getAnimatedValue",
      value: function __getAnimatedValue() {
        var props = {};

        for (var key in this._props) {
          var value = this._props[key];

          if (value instanceof AnimatedNode) {
            props[key] = value.__getAnimatedValue();
          }
        }

        return props;
      }
    }, {
      key: "__attach",
      value: function __attach() {
        for (var key in this._props) {
          var value = this._props[key];

          if (value instanceof AnimatedNode) {
            value.__addChild(this);
          }
        }
      }
    }, {
      key: "__detach",
      value: function __detach() {
        if (this.__isNative && this._animatedView) {
          this.__disconnectAnimatedView();
        }

        for (var key in this._props) {
          var value = this._props[key];

          if (value instanceof AnimatedNode) {
            value.__removeChild(this);
          }
        }

        _get(_getPrototypeOf(AnimatedProps.prototype), "__detach", this).call(this);
      }
    }, {
      key: "update",
      value: function update() {
        this._callback();
      }
    }, {
      key: "__makeNative",
      value: function __makeNative() {
        if (!this.__isNative) {
          this.__isNative = true;

          for (var key in this._props) {
            var value = this._props[key];

            if (value instanceof AnimatedNode) {
              value.__makeNative();
            }
          }

          if (this._animatedView) {
            this.__connectAnimatedView();
          }
        }
      }
    }, {
      key: "setNativeView",
      value: function setNativeView(animatedView) {
        if (this._animatedView === animatedView) {
          return;
        }

        this._animatedView = animatedView;

        if (this.__isNative) {
          this.__connectAnimatedView();
        }
      }
    }, {
      key: "__connectAnimatedView",
      value: function __connectAnimatedView() {
        invariant(this.__isNative, 'Expected node to be marked as "native"');
        var nativeViewTag = ReactNative.findNodeHandle(this._animatedView);
        invariant(nativeViewTag != null, 'Unable to locate attached view in the native tree');
        NativeAnimatedHelper.API.connectAnimatedNodeToView(this.__getNativeTag(), nativeViewTag);
      }
    }, {
      key: "__disconnectAnimatedView",
      value: function __disconnectAnimatedView() {
        invariant(this.__isNative, 'Expected node to be marked as "native"');
        var nativeViewTag = ReactNative.findNodeHandle(this._animatedView);
        invariant(nativeViewTag != null, 'Unable to locate attached view in the native tree');
        NativeAnimatedHelper.API.disconnectAnimatedNodeFromView(this.__getNativeTag(), nativeViewTag);
      }
    }, {
      key: "__getNativeConfig",
      value: function __getNativeConfig() {
        var propsConfig = {};

        for (var propKey in this._props) {
          var value = this._props[propKey];

          if (value instanceof AnimatedNode) {
            value.__makeNative();

            propsConfig[propKey] = value.__getNativeTag();
          }
        }

        return {
          type: 'props',
          props: propsConfig
        };
      }
    }]);

    return AnimatedProps;
  }(AnimatedNode);

  module.exports = AnimatedProps;
},278,[46,24,25,32,34,35,37,263,266,279,267,88,3],"node_modules/react-native/Libraries/Animated/src/nodes/AnimatedProps.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass");

  var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn");

  var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf");

  var _get = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/get");

  var _inherits = _$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits");

  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

  var AnimatedNode = _$$_REQUIRE(_dependencyMap[7], "./AnimatedNode");

  var AnimatedTransform = _$$_REQUIRE(_dependencyMap[8], "./AnimatedTransform");

  var AnimatedWithChildren = _$$_REQUIRE(_dependencyMap[9], "./AnimatedWithChildren");

  var NativeAnimatedHelper = _$$_REQUIRE(_dependencyMap[10], "../NativeAnimatedHelper");

  var flattenStyle = _$$_REQUIRE(_dependencyMap[11], "../../../StyleSheet/flattenStyle");

  var AnimatedStyle = function (_AnimatedWithChildren) {
    _inherits(AnimatedStyle, _AnimatedWithChildren);

    function AnimatedStyle(style) {
      var _this;

      _classCallCheck(this, AnimatedStyle);

      _this = _possibleConstructorReturn(this, _getPrototypeOf(AnimatedStyle).call(this));
      style = flattenStyle(style) || {};

      if (style.transform) {
        style = _objectSpread({}, style, {
          transform: new AnimatedTransform(style.transform)
        });
      }

      _this._style = style;
      return _this;
    }

    _createClass(AnimatedStyle, [{
      key: "_walkStyleAndGetValues",
      value: function _walkStyleAndGetValues(style) {
        var updatedStyle = {};

        for (var key in style) {
          var value = style[key];

          if (value instanceof AnimatedNode) {
            if (!value.__isNative) {
              updatedStyle[key] = value.__getValue();
            }
          } else if (value && !Array.isArray(value) && typeof value === 'object') {
            updatedStyle[key] = this._walkStyleAndGetValues(value);
          } else {
            updatedStyle[key] = value;
          }
        }

        return updatedStyle;
      }
    }, {
      key: "__getValue",
      value: function __getValue() {
        return this._walkStyleAndGetValues(this._style);
      }
    }, {
      key: "_walkStyleAndGetAnimatedValues",
      value: function _walkStyleAndGetAnimatedValues(style) {
        var updatedStyle = {};

        for (var key in style) {
          var value = style[key];

          if (value instanceof AnimatedNode) {
            updatedStyle[key] = value.__getAnimatedValue();
          } else if (value && !Array.isArray(value) && typeof value === 'object') {
            updatedStyle[key] = this._walkStyleAndGetAnimatedValues(value);
          }
        }

        return updatedStyle;
      }
    }, {
      key: "__getAnimatedValue",
      value: function __getAnimatedValue() {
        return this._walkStyleAndGetAnimatedValues(this._style);
      }
    }, {
      key: "__attach",
      value: function __attach() {
        for (var key in this._style) {
          var value = this._style[key];

          if (value instanceof AnimatedNode) {
            value.__addChild(this);
          }
        }
      }
    }, {
      key: "__detach",
      value: function __detach() {
        for (var key in this._style) {
          var value = this._style[key];

          if (value instanceof AnimatedNode) {
            value.__removeChild(this);
          }
        }

        _get(_getPrototypeOf(AnimatedStyle.prototype), "__detach", this).call(this);
      }
    }, {
      key: "__makeNative",
      value: function __makeNative() {
        for (var key in this._style) {
          var value = this._style[key];

          if (value instanceof AnimatedNode) {
            value.__makeNative();
          }
        }

        _get(_getPrototypeOf(AnimatedStyle.prototype), "__makeNative", this).call(this);
      }
    }, {
      key: "__getNativeConfig",
      value: function __getNativeConfig() {
        var styleConfig = {};

        for (var styleKey in this._style) {
          if (this._style[styleKey] instanceof AnimatedNode) {
            var style = this._style[styleKey];

            style.__makeNative();

            styleConfig[styleKey] = style.__getNativeTag();
          }
        }

        NativeAnimatedHelper.validateStyles(styleConfig);
        return {
          type: 'style',
          style: styleConfig
        };
      }
    }]);

    return AnimatedStyle;
  }(AnimatedWithChildren);

  module.exports = AnimatedStyle;
},279,[46,24,25,32,34,35,37,266,280,269,267,85],"node_modules/react-native/Libraries/Animated/src/nodes/AnimatedStyle.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");

  var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");

  var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");

  var _get = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/get");

  var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");

  var AnimatedNode = _$$_REQUIRE(_dependencyMap[6], "./AnimatedNode");

  var AnimatedWithChildren = _$$_REQUIRE(_dependencyMap[7], "./AnimatedWithChildren");

  var NativeAnimatedHelper = _$$_REQUIRE(_dependencyMap[8], "../NativeAnimatedHelper");

  var AnimatedTransform = function (_AnimatedWithChildren) {
    _inherits(AnimatedTransform, _AnimatedWithChildren);

    function AnimatedTransform(transforms) {
      var _this;

      _classCallCheck(this, AnimatedTransform);

      _this = _possibleConstructorReturn(this, _getPrototypeOf(AnimatedTransform).call(this));
      _this._transforms = transforms;
      return _this;
    }

    _createClass(AnimatedTransform, [{
      key: "__makeNative",
      value: function __makeNative() {
        this._transforms.forEach(function (transform) {
          for (var key in transform) {
            var value = transform[key];

            if (value instanceof AnimatedNode) {
              value.__makeNative();
            }
          }
        });

        _get(_getPrototypeOf(AnimatedTransform.prototype), "__makeNative", this).call(this);
      }
    }, {
      key: "__getValue",
      value: function __getValue() {
        return this._transforms.map(function (transform) {
          var result = {};

          for (var key in transform) {
            var value = transform[key];

            if (value instanceof AnimatedNode) {
              result[key] = value.__getValue();
            } else {
              result[key] = value;
            }
          }

          return result;
        });
      }
    }, {
      key: "__getAnimatedValue",
      value: function __getAnimatedValue() {
        return this._transforms.map(function (transform) {
          var result = {};

          for (var key in transform) {
            var value = transform[key];

            if (value instanceof AnimatedNode) {
              result[key] = value.__getAnimatedValue();
            } else {
              result[key] = value;
            }
          }

          return result;
        });
      }
    }, {
      key: "__attach",
      value: function __attach() {
        var _this2 = this;

        this._transforms.forEach(function (transform) {
          for (var key in transform) {
            var value = transform[key];

            if (value instanceof AnimatedNode) {
              value.__addChild(_this2);
            }
          }
        });
      }
    }, {
      key: "__detach",
      value: function __detach() {
        var _this3 = this;

        this._transforms.forEach(function (transform) {
          for (var key in transform) {
            var value = transform[key];

            if (value instanceof AnimatedNode) {
              value.__removeChild(_this3);
            }
          }
        });

        _get(_getPrototypeOf(AnimatedTransform.prototype), "__detach", this).call(this);
      }
    }, {
      key: "__getNativeConfig",
      value: function __getNativeConfig() {
        var transConfigs = [];

        this._transforms.forEach(function (transform) {
          for (var key in transform) {
            var value = transform[key];

            if (value instanceof AnimatedNode) {
              transConfigs.push({
                type: 'animated',
                property: key,
                nodeTag: value.__getNativeTag()
              });
            } else {
              transConfigs.push({
                type: 'static',
                property: key,
                value: NativeAnimatedHelper.transformDataType(value)
              });
            }
          }
        });

        NativeAnimatedHelper.validateTransform(transConfigs);
        return {
          type: 'transform',
          transforms: transConfigs
        };
      }
    }]);

    return AnimatedTransform;
  }(AnimatedWithChildren);

  module.exports = AnimatedTransform;
},280,[24,25,32,34,35,37,266,269,267],"node_modules/react-native/Libraries/Animated/src/nodes/AnimatedTransform.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");

  var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");

  var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");

  var _get = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/get");

  var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");

  var AnimatedInterpolation = _$$_REQUIRE(_dependencyMap[6], "./AnimatedInterpolation");

  var AnimatedNode = _$$_REQUIRE(_dependencyMap[7], "./AnimatedNode");

  var AnimatedValue = _$$_REQUIRE(_dependencyMap[8], "./AnimatedValue");

  var AnimatedWithChildren = _$$_REQUIRE(_dependencyMap[9], "./AnimatedWithChildren");

  var AnimatedSubtraction = function (_AnimatedWithChildren) {
    _inherits(AnimatedSubtraction, _AnimatedWithChildren);

    function AnimatedSubtraction(a, b) {
      var _this;

      _classCallCheck(this, AnimatedSubtraction);

      _this = _possibleConstructorReturn(this, _getPrototypeOf(AnimatedSubtraction).call(this));
      _this._a = typeof a === 'number' ? new AnimatedValue(a) : a;
      _this._b = typeof b === 'number' ? new AnimatedValue(b) : b;
      return _this;
    }

    _createClass(AnimatedSubtraction, [{
      key: "__makeNative",
      value: function __makeNative() {
        this._a.__makeNative();

        this._b.__makeNative();

        _get(_getPrototypeOf(AnimatedSubtraction.prototype), "__makeNative", this).call(this);
      }
    }, {
      key: "__getValue",
      value: function __getValue() {
        return this._a.__getValue() - this._b.__getValue();
      }
    }, {
      key: "interpolate",
      value: function interpolate(config) {
        return new AnimatedInterpolation(this, config);
      }
    }, {
      key: "__attach",
      value: function __attach() {
        this._a.__addChild(this);

        this._b.__addChild(this);
      }
    }, {
      key: "__detach",
      value: function __detach() {
        this._a.__removeChild(this);

        this._b.__removeChild(this);

        _get(_getPrototypeOf(AnimatedSubtraction.prototype), "__detach", this).call(this);
      }
    }, {
      key: "__getNativeConfig",
      value: function __getNativeConfig() {
        return {
          type: 'subtraction',
          input: [this._a.__getNativeTag(), this._b.__getNativeTag()]
        };
      }
    }]);

    return AnimatedSubtraction;
  }(AnimatedWithChildren);

  module.exports = AnimatedSubtraction;
},281,[24,25,32,34,35,37,265,266,264,269],"node_modules/react-native/Libraries/Animated/src/nodes/AnimatedSubtraction.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass");

  var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn");

  var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf");

  var _get = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/get");

  var _inherits = _$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits");

  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

  var AnimatedValue = _$$_REQUIRE(_dependencyMap[7], "./AnimatedValue");

  var AnimatedNode = _$$_REQUIRE(_dependencyMap[8], "./AnimatedNode");

  var _require = _$$_REQUIRE(_dependencyMap[9], "../NativeAnimatedHelper"),
      generateNewAnimationId = _require.generateNewAnimationId,
      shouldUseNativeDriver = _require.shouldUseNativeDriver;

  var AnimatedTracking = function (_AnimatedNode) {
    _inherits(AnimatedTracking, _AnimatedNode);

    function AnimatedTracking(value, parent, animationClass, animationConfig, callback) {
      var _this;

      _classCallCheck(this, AnimatedTracking);

      _this = _possibleConstructorReturn(this, _getPrototypeOf(AnimatedTracking).call(this));
      _this._value = value;
      _this._parent = parent;
      _this._animationClass = animationClass;
      _this._animationConfig = animationConfig;
      _this._useNativeDriver = shouldUseNativeDriver(animationConfig);
      _this._callback = callback;

      _this.__attach();

      return _this;
    }

    _createClass(AnimatedTracking, [{
      key: "__makeNative",
      value: function __makeNative() {
        this.__isNative = true;

        this._parent.__makeNative();

        _get(_getPrototypeOf(AnimatedTracking.prototype), "__makeNative", this).call(this);

        this._value.__makeNative();
      }
    }, {
      key: "__getValue",
      value: function __getValue() {
        return this._parent.__getValue();
      }
    }, {
      key: "__attach",
      value: function __attach() {
        this._parent.__addChild(this);

        if (this._useNativeDriver) {
          this.__makeNative();
        }
      }
    }, {
      key: "__detach",
      value: function __detach() {
        this._parent.__removeChild(this);

        _get(_getPrototypeOf(AnimatedTracking.prototype), "__detach", this).call(this);
      }
    }, {
      key: "update",
      value: function update() {
        this._value.animate(new this._animationClass(_objectSpread({}, this._animationConfig, {
          toValue: this._animationConfig.toValue.__getValue()
        })), this._callback);
      }
    }, {
      key: "__getNativeConfig",
      value: function __getNativeConfig() {
        var animation = new this._animationClass(_objectSpread({}, this._animationConfig, {
          toValue: undefined
        }));

        var animationConfig = animation.__getNativeAnimationConfig();

        return {
          type: 'tracking',
          animationId: generateNewAnimationId(),
          animationConfig: animationConfig,
          toValue: this._parent.__getNativeTag(),
          value: this._value.__getNativeTag()
        };
      }
    }]);

    return AnimatedTracking;
  }(AnimatedNode);

  module.exports = AnimatedTracking;
},282,[46,24,25,32,34,35,37,264,266,267],"node_modules/react-native/Libraries/Animated/src/nodes/AnimatedTracking.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");

  var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");

  var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");

  var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");

  var AnimatedValue = _$$_REQUIRE(_dependencyMap[5], "./AnimatedValue");

  var AnimatedWithChildren = _$$_REQUIRE(_dependencyMap[6], "./AnimatedWithChildren");

  var invariant = _$$_REQUIRE(_dependencyMap[7], "invariant");

  var _uniqueId = 1;

  var AnimatedValueXY = function (_AnimatedWithChildren) {
    _inherits(AnimatedValueXY, _AnimatedWithChildren);

    function AnimatedValueXY(valueIn) {
      var _this;

      _classCallCheck(this, AnimatedValueXY);

      _this = _possibleConstructorReturn(this, _getPrototypeOf(AnimatedValueXY).call(this));
      var value = valueIn || {
        x: 0,
        y: 0
      };

      if (typeof value.x === 'number' && typeof value.y === 'number') {
        _this.x = new AnimatedValue(value.x);
        _this.y = new AnimatedValue(value.y);
      } else {
        invariant(value.x instanceof AnimatedValue && value.y instanceof AnimatedValue, 'AnimatedValueXY must be initialized with an object of numbers or ' + 'AnimatedValues.');
        _this.x = value.x;
        _this.y = value.y;
      }

      _this._listeners = {};
      return _this;
    }

    _createClass(AnimatedValueXY, [{
      key: "setValue",
      value: function setValue(value) {
        this.x.setValue(value.x);
        this.y.setValue(value.y);
      }
    }, {
      key: "setOffset",
      value: function setOffset(offset) {
        this.x.setOffset(offset.x);
        this.y.setOffset(offset.y);
      }
    }, {
      key: "flattenOffset",
      value: function flattenOffset() {
        this.x.flattenOffset();
        this.y.flattenOffset();
      }
    }, {
      key: "extractOffset",
      value: function extractOffset() {
        this.x.extractOffset();
        this.y.extractOffset();
      }
    }, {
      key: "__getValue",
      value: function __getValue() {
        return {
          x: this.x.__getValue(),
          y: this.y.__getValue()
        };
      }
    }, {
      key: "resetAnimation",
      value: function resetAnimation(callback) {
        this.x.resetAnimation();
        this.y.resetAnimation();
        callback && callback(this.__getValue());
      }
    }, {
      key: "stopAnimation",
      value: function stopAnimation(callback) {
        this.x.stopAnimation();
        this.y.stopAnimation();
        callback && callback(this.__getValue());
      }
    }, {
      key: "addListener",
      value: function addListener(callback) {
        var _this2 = this;

        var id = String(_uniqueId++);

        var jointCallback = function jointCallback(_ref) {
          var number = _ref.value;
          callback(_this2.__getValue());
        };

        this._listeners[id] = {
          x: this.x.addListener(jointCallback),
          y: this.y.addListener(jointCallback)
        };
        return id;
      }
    }, {
      key: "removeListener",
      value: function removeListener(id) {
        this.x.removeListener(this._listeners[id].x);
        this.y.removeListener(this._listeners[id].y);
        delete this._listeners[id];
      }
    }, {
      key: "removeAllListeners",
      value: function removeAllListeners() {
        this.x.removeAllListeners();
        this.y.removeAllListeners();
        this._listeners = {};
      }
    }, {
      key: "getLayout",
      value: function getLayout() {
        return {
          left: this.x,
          top: this.y
        };
      }
    }, {
      key: "getTranslateTransform",
      value: function getTranslateTransform() {
        return [{
          translateX: this.x
        }, {
          translateY: this.y
        }];
      }
    }]);

    return AnimatedValueXY;
  }(AnimatedWithChildren);

  module.exports = AnimatedValueXY;
},283,[24,25,32,34,37,264,269,3],"node_modules/react-native/Libraries/Animated/src/nodes/AnimatedValueXY.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");

  var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");

  var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");

  var _get = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/get");

  var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");

  var Animation = _$$_REQUIRE(_dependencyMap[6], "./Animation");

  var _require = _$$_REQUIRE(_dependencyMap[7], "../NativeAnimatedHelper"),
      shouldUseNativeDriver = _require.shouldUseNativeDriver;

  var DecayAnimation = function (_Animation) {
    _inherits(DecayAnimation, _Animation);

    function DecayAnimation(config) {
      var _config$deceleration, _config$isInteraction, _config$iterations;

      var _this;

      _classCallCheck(this, DecayAnimation);

      _this = _possibleConstructorReturn(this, _getPrototypeOf(DecayAnimation).call(this));
      _this._deceleration = (_config$deceleration = config.deceleration) != null ? _config$deceleration : 0.998;
      _this._velocity = config.velocity;
      _this._useNativeDriver = shouldUseNativeDriver(config);
      _this.__isInteraction = (_config$isInteraction = config.isInteraction) != null ? _config$isInteraction : !_this._useNativeDriver;
      _this.__iterations = (_config$iterations = config.iterations) != null ? _config$iterations : 1;
      return _this;
    }

    _createClass(DecayAnimation, [{
      key: "__getNativeAnimationConfig",
      value: function __getNativeAnimationConfig() {
        return {
          type: 'decay',
          deceleration: this._deceleration,
          velocity: this._velocity,
          iterations: this.__iterations
        };
      }
    }, {
      key: "start",
      value: function start(fromValue, onUpdate, onEnd, previousAnimation, animatedValue) {
        this.__active = true;
        this._lastValue = fromValue;
        this._fromValue = fromValue;
        this._onUpdate = onUpdate;
        this.__onEnd = onEnd;
        this._startTime = Date.now();

        if (this._useNativeDriver) {
          this.__startNativeAnimation(animatedValue);
        } else {
          this._animationFrame = requestAnimationFrame(this.onUpdate.bind(this));
        }
      }
    }, {
      key: "onUpdate",
      value: function onUpdate() {
        var now = Date.now();
        var value = this._fromValue + this._velocity / (1 - this._deceleration) * (1 - Math.exp(-(1 - this._deceleration) * (now - this._startTime)));

        this._onUpdate(value);

        if (Math.abs(this._lastValue - value) < 0.1) {
          this.__debouncedOnEnd({
            finished: true
          });

          return;
        }

        this._lastValue = value;

        if (this.__active) {
          this._animationFrame = requestAnimationFrame(this.onUpdate.bind(this));
        }
      }
    }, {
      key: "stop",
      value: function stop() {
        _get(_getPrototypeOf(DecayAnimation.prototype), "stop", this).call(this);

        this.__active = false;
        global.cancelAnimationFrame(this._animationFrame);

        this.__debouncedOnEnd({
          finished: false
        });
      }
    }]);

    return DecayAnimation;
  }(Animation);

  module.exports = DecayAnimation;
},284,[24,25,32,34,35,37,285,267],"node_modules/react-native/Libraries/Animated/src/animations/DecayAnimation.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");

  var NativeAnimatedHelper = _$$_REQUIRE(_dependencyMap[2], "../NativeAnimatedHelper");

  var Animation = function () {
    function Animation() {
      _classCallCheck(this, Animation);
    }

    _createClass(Animation, [{
      key: "start",
      value: function start(fromValue, onUpdate, onEnd, previousAnimation, animatedValue) {}
    }, {
      key: "stop",
      value: function stop() {
        if (this.__nativeId) {
          NativeAnimatedHelper.API.stopAnimation(this.__nativeId);
        }
      }
    }, {
      key: "__getNativeAnimationConfig",
      value: function __getNativeAnimationConfig() {
        throw new Error('This animation type cannot be offloaded to native');
      }
    }, {
      key: "__debouncedOnEnd",
      value: function __debouncedOnEnd(result) {
        var onEnd = this.__onEnd;
        this.__onEnd = null;
        onEnd && onEnd(result);
      }
    }, {
      key: "__startNativeAnimation",
      value: function __startNativeAnimation(animatedValue) {
        NativeAnimatedHelper.API.enableQueue();

        animatedValue.__makeNative();

        NativeAnimatedHelper.API.disableQueue();
        this.__nativeId = NativeAnimatedHelper.generateNewAnimationId();
        NativeAnimatedHelper.API.startAnimatingNode(this.__nativeId, animatedValue.__getNativeTag(), this.__getNativeAnimationConfig(), this.__debouncedOnEnd.bind(this));
      }
    }]);

    return Animation;
  }();

  module.exports = Animation;
},285,[24,25,267],"node_modules/react-native/Libraries/Animated/src/animations/Animation.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");

  var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");

  var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");

  var _get = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/get");

  var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");

  var AnimatedValue = _$$_REQUIRE(_dependencyMap[6], "../nodes/AnimatedValue");

  var AnimatedValueXY = _$$_REQUIRE(_dependencyMap[7], "../nodes/AnimatedValueXY");

  var Animation = _$$_REQUIRE(_dependencyMap[8], "./Animation");

  var SpringConfig = _$$_REQUIRE(_dependencyMap[9], "../SpringConfig");

  var invariant = _$$_REQUIRE(_dependencyMap[10], "invariant");

  var _require = _$$_REQUIRE(_dependencyMap[11], "../NativeAnimatedHelper"),
      shouldUseNativeDriver = _require.shouldUseNativeDriver;

  var SpringAnimation = function (_Animation) {
    _inherits(SpringAnimation, _Animation);

    function SpringAnimation(config) {
      var _config$overshootClam, _config$restDisplacem, _config$restSpeedThre, _config$velocity, _config$velocity2, _config$delay, _config$isInteraction, _config$iterations;

      var _this;

      _classCallCheck(this, SpringAnimation);

      _this = _possibleConstructorReturn(this, _getPrototypeOf(SpringAnimation).call(this));
      _this._overshootClamping = (_config$overshootClam = config.overshootClamping) != null ? _config$overshootClam : false;
      _this._restDisplacementThreshold = (_config$restDisplacem = config.restDisplacementThreshold) != null ? _config$restDisplacem : 0.001;
      _this._restSpeedThreshold = (_config$restSpeedThre = config.restSpeedThreshold) != null ? _config$restSpeedThre : 0.001;
      _this._initialVelocity = (_config$velocity = config.velocity) != null ? _config$velocity : 0;
      _this._lastVelocity = (_config$velocity2 = config.velocity) != null ? _config$velocity2 : 0;
      _this._toValue = config.toValue;
      _this._delay = (_config$delay = config.delay) != null ? _config$delay : 0;
      _this._useNativeDriver = shouldUseNativeDriver(config);
      _this.__isInteraction = (_config$isInteraction = config.isInteraction) != null ? _config$isInteraction : !_this._useNativeDriver;
      _this.__iterations = (_config$iterations = config.iterations) != null ? _config$iterations : 1;

      if (config.stiffness !== undefined || config.damping !== undefined || config.mass !== undefined) {
        var _config$stiffness, _config$damping, _config$mass;

        invariant(config.bounciness === undefined && config.speed === undefined && config.tension === undefined && config.friction === undefined, 'You can define one of bounciness/speed, tension/friction, or stiffness/damping/mass, but not more than one');
        _this._stiffness = (_config$stiffness = config.stiffness) != null ? _config$stiffness : 100;
        _this._damping = (_config$damping = config.damping) != null ? _config$damping : 10;
        _this._mass = (_config$mass = config.mass) != null ? _config$mass : 1;
      } else if (config.bounciness !== undefined || config.speed !== undefined) {
        var _config$bounciness, _config$speed;

        invariant(config.tension === undefined && config.friction === undefined && config.stiffness === undefined && config.damping === undefined && config.mass === undefined, 'You can define one of bounciness/speed, tension/friction, or stiffness/damping/mass, but not more than one');
        var springConfig = SpringConfig.fromBouncinessAndSpeed((_config$bounciness = config.bounciness) != null ? _config$bounciness : 8, (_config$speed = config.speed) != null ? _config$speed : 12);
        _this._stiffness = springConfig.stiffness;
        _this._damping = springConfig.damping;
        _this._mass = 1;
      } else {
        var _config$tension, _config$friction;

        var _springConfig = SpringConfig.fromOrigamiTensionAndFriction((_config$tension = config.tension) != null ? _config$tension : 40, (_config$friction = config.friction) != null ? _config$friction : 7);

        _this._stiffness = _springConfig.stiffness;
        _this._damping = _springConfig.damping;
        _this._mass = 1;
      }

      invariant(_this._stiffness > 0, 'Stiffness value must be greater than 0');
      invariant(_this._damping > 0, 'Damping value must be greater than 0');
      invariant(_this._mass > 0, 'Mass value must be greater than 0');
      return _this;
    }

    _createClass(SpringAnimation, [{
      key: "__getNativeAnimationConfig",
      value: function __getNativeAnimationConfig() {
        var _this$_initialVelocit;

        return {
          type: 'spring',
          overshootClamping: this._overshootClamping,
          restDisplacementThreshold: this._restDisplacementThreshold,
          restSpeedThreshold: this._restSpeedThreshold,
          stiffness: this._stiffness,
          damping: this._damping,
          mass: this._mass,
          initialVelocity: (_this$_initialVelocit = this._initialVelocity) != null ? _this$_initialVelocit : this._lastVelocity,
          toValue: this._toValue,
          iterations: this.__iterations
        };
      }
    }, {
      key: "start",
      value: function start(fromValue, onUpdate, onEnd, previousAnimation, animatedValue) {
        var _this2 = this;

        this.__active = true;
        this._startPosition = fromValue;
        this._lastPosition = this._startPosition;
        this._onUpdate = onUpdate;
        this.__onEnd = onEnd;
        this._lastTime = Date.now();
        this._frameTime = 0.0;

        if (previousAnimation instanceof SpringAnimation) {
          var internalState = previousAnimation.getInternalState();
          this._lastPosition = internalState.lastPosition;
          this._lastVelocity = internalState.lastVelocity;
          this._initialVelocity = this._lastVelocity;
          this._lastTime = internalState.lastTime;
        }

        var start = function start() {
          if (_this2._useNativeDriver) {
            _this2.__startNativeAnimation(animatedValue);
          } else {
            _this2.onUpdate();
          }
        };

        if (this._delay) {
          this._timeout = setTimeout(start, this._delay);
        } else {
          start();
        }
      }
    }, {
      key: "getInternalState",
      value: function getInternalState() {
        return {
          lastPosition: this._lastPosition,
          lastVelocity: this._lastVelocity,
          lastTime: this._lastTime
        };
      }
    }, {
      key: "onUpdate",
      value: function onUpdate() {
        var MAX_STEPS = 64;
        var now = Date.now();

        if (now > this._lastTime + MAX_STEPS) {
          now = this._lastTime + MAX_STEPS;
        }

        var deltaTime = (now - this._lastTime) / 1000;
        this._frameTime += deltaTime;
        var c = this._damping;
        var m = this._mass;
        var k = this._stiffness;
        var v0 = -this._initialVelocity;
        var zeta = c / (2 * Math.sqrt(k * m));
        var omega0 = Math.sqrt(k / m);
        var omega1 = omega0 * Math.sqrt(1.0 - zeta * zeta);
        var x0 = this._toValue - this._startPosition;
        var position = 0.0;
        var velocity = 0.0;
        var t = this._frameTime;

        if (zeta < 1) {
          var envelope = Math.exp(-zeta * omega0 * t);
          position = this._toValue - envelope * ((v0 + zeta * omega0 * x0) / omega1 * Math.sin(omega1 * t) + x0 * Math.cos(omega1 * t));
          velocity = zeta * omega0 * envelope * (Math.sin(omega1 * t) * (v0 + zeta * omega0 * x0) / omega1 + x0 * Math.cos(omega1 * t)) - envelope * (Math.cos(omega1 * t) * (v0 + zeta * omega0 * x0) - omega1 * x0 * Math.sin(omega1 * t));
        } else {
          var _envelope = Math.exp(-omega0 * t);

          position = this._toValue - _envelope * (x0 + (v0 + omega0 * x0) * t);
          velocity = _envelope * (v0 * (t * omega0 - 1) + t * x0 * (omega0 * omega0));
        }

        this._lastTime = now;
        this._lastPosition = position;
        this._lastVelocity = velocity;

        this._onUpdate(position);

        if (!this.__active) {
          return;
        }

        var isOvershooting = false;

        if (this._overshootClamping && this._stiffness !== 0) {
          if (this._startPosition < this._toValue) {
            isOvershooting = position > this._toValue;
          } else {
            isOvershooting = position < this._toValue;
          }
        }

        var isVelocity = Math.abs(velocity) <= this._restSpeedThreshold;

        var isDisplacement = true;

        if (this._stiffness !== 0) {
          isDisplacement = Math.abs(this._toValue - position) <= this._restDisplacementThreshold;
        }

        if (isOvershooting || isVelocity && isDisplacement) {
          if (this._stiffness !== 0) {
            this._lastPosition = this._toValue;
            this._lastVelocity = 0;

            this._onUpdate(this._toValue);
          }

          this.__debouncedOnEnd({
            finished: true
          });

          return;
        }

        this._animationFrame = requestAnimationFrame(this.onUpdate.bind(this));
      }
    }, {
      key: "stop",
      value: function stop() {
        _get(_getPrototypeOf(SpringAnimation.prototype), "stop", this).call(this);

        this.__active = false;
        clearTimeout(this._timeout);
        global.cancelAnimationFrame(this._animationFrame);

        this.__debouncedOnEnd({
          finished: false
        });
      }
    }]);

    return SpringAnimation;
  }(Animation);

  module.exports = SpringAnimation;
},286,[24,25,32,34,35,37,264,283,285,287,3,267],"node_modules/react-native/Libraries/Animated/src/animations/SpringAnimation.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  function stiffnessFromOrigamiValue(oValue) {
    return (oValue - 30) * 3.62 + 194;
  }

  function dampingFromOrigamiValue(oValue) {
    return (oValue - 8) * 3 + 25;
  }

  function fromOrigamiTensionAndFriction(tension, friction) {
    return {
      stiffness: stiffnessFromOrigamiValue(tension),
      damping: dampingFromOrigamiValue(friction)
    };
  }

  function fromBouncinessAndSpeed(bounciness, speed) {
    function normalize(value, startValue, endValue) {
      return (value - startValue) / (endValue - startValue);
    }

    function projectNormal(n, start, end) {
      return start + n * (end - start);
    }

    function linearInterpolation(t, start, end) {
      return t * end + (1 - t) * start;
    }

    function quadraticOutInterpolation(t, start, end) {
      return linearInterpolation(2 * t - t * t, start, end);
    }

    function b3Friction1(x) {
      return 0.0007 * Math.pow(x, 3) - 0.031 * Math.pow(x, 2) + 0.64 * x + 1.28;
    }

    function b3Friction2(x) {
      return 0.000044 * Math.pow(x, 3) - 0.006 * Math.pow(x, 2) + 0.36 * x + 2;
    }

    function b3Friction3(x) {
      return 0.00000045 * Math.pow(x, 3) - 0.000332 * Math.pow(x, 2) + 0.1078 * x + 5.84;
    }

    function b3Nobounce(tension) {
      if (tension <= 18) {
        return b3Friction1(tension);
      } else if (tension > 18 && tension <= 44) {
        return b3Friction2(tension);
      } else {
        return b3Friction3(tension);
      }
    }

    var b = normalize(bounciness / 1.7, 0, 20);
    b = projectNormal(b, 0, 0.8);
    var s = normalize(speed / 1.7, 0, 20);
    var bouncyTension = projectNormal(s, 0.5, 200);
    var bouncyFriction = quadraticOutInterpolation(b, b3Nobounce(bouncyTension), 0.01);
    return {
      stiffness: stiffnessFromOrigamiValue(bouncyTension),
      damping: dampingFromOrigamiValue(bouncyFriction)
    };
  }

  module.exports = {
    fromOrigamiTensionAndFriction: fromOrigamiTensionAndFriction,
    fromBouncinessAndSpeed: fromBouncinessAndSpeed
  };
},287,[],"node_modules/react-native/Libraries/Animated/src/SpringConfig.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");

  var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");

  var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");

  var _get = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/get");

  var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");

  var AnimatedValue = _$$_REQUIRE(_dependencyMap[6], "../nodes/AnimatedValue");

  var AnimatedValueXY = _$$_REQUIRE(_dependencyMap[7], "../nodes/AnimatedValueXY");

  var Animation = _$$_REQUIRE(_dependencyMap[8], "./Animation");

  var _require = _$$_REQUIRE(_dependencyMap[9], "../NativeAnimatedHelper"),
      shouldUseNativeDriver = _require.shouldUseNativeDriver;

  var _easeInOut;

  function easeInOut() {
    if (!_easeInOut) {
      var Easing = _$$_REQUIRE(_dependencyMap[10], "../Easing");

      _easeInOut = Easing.inOut(Easing.ease);
    }

    return _easeInOut;
  }

  var TimingAnimation = function (_Animation) {
    _inherits(TimingAnimation, _Animation);

    function TimingAnimation(config) {
      var _config$easing, _config$duration, _config$delay, _config$iterations, _config$isInteraction;

      var _this;

      _classCallCheck(this, TimingAnimation);

      _this = _possibleConstructorReturn(this, _getPrototypeOf(TimingAnimation).call(this));
      _this._toValue = config.toValue;
      _this._easing = (_config$easing = config.easing) != null ? _config$easing : easeInOut();
      _this._duration = (_config$duration = config.duration) != null ? _config$duration : 500;
      _this._delay = (_config$delay = config.delay) != null ? _config$delay : 0;
      _this.__iterations = (_config$iterations = config.iterations) != null ? _config$iterations : 1;
      _this._useNativeDriver = shouldUseNativeDriver(config);
      _this.__isInteraction = (_config$isInteraction = config.isInteraction) != null ? _config$isInteraction : !_this._useNativeDriver;
      return _this;
    }

    _createClass(TimingAnimation, [{
      key: "__getNativeAnimationConfig",
      value: function __getNativeAnimationConfig() {
        var frameDuration = 1000.0 / 60.0;
        var frames = [];
        var numFrames = Math.round(this._duration / frameDuration);

        for (var frame = 0; frame < numFrames; frame++) {
          frames.push(this._easing(frame / numFrames));
        }

        frames.push(this._easing(1));
        return {
          type: 'frames',
          frames: frames,
          toValue: this._toValue,
          iterations: this.__iterations
        };
      }
    }, {
      key: "start",
      value: function start(fromValue, onUpdate, onEnd, previousAnimation, animatedValue) {
        var _this2 = this;

        this.__active = true;
        this._fromValue = fromValue;
        this._onUpdate = onUpdate;
        this.__onEnd = onEnd;

        var start = function start() {
          if (_this2._duration === 0 && !_this2._useNativeDriver) {
            _this2._onUpdate(_this2._toValue);

            _this2.__debouncedOnEnd({
              finished: true
            });
          } else {
            _this2._startTime = Date.now();

            if (_this2._useNativeDriver) {
              _this2.__startNativeAnimation(animatedValue);
            } else {
              _this2._animationFrame = requestAnimationFrame(_this2.onUpdate.bind(_this2));
            }
          }
        };

        if (this._delay) {
          this._timeout = setTimeout(start, this._delay);
        } else {
          start();
        }
      }
    }, {
      key: "onUpdate",
      value: function onUpdate() {
        var now = Date.now();

        if (now >= this._startTime + this._duration) {
          if (this._duration === 0) {
            this._onUpdate(this._toValue);
          } else {
            this._onUpdate(this._fromValue + this._easing(1) * (this._toValue - this._fromValue));
          }

          this.__debouncedOnEnd({
            finished: true
          });

          return;
        }

        this._onUpdate(this._fromValue + this._easing((now - this._startTime) / this._duration) * (this._toValue - this._fromValue));

        if (this.__active) {
          this._animationFrame = requestAnimationFrame(this.onUpdate.bind(this));
        }
      }
    }, {
      key: "stop",
      value: function stop() {
        _get(_getPrototypeOf(TimingAnimation.prototype), "stop", this).call(this);

        this.__active = false;
        clearTimeout(this._timeout);
        global.cancelAnimationFrame(this._animationFrame);

        this.__debouncedOnEnd({
          finished: false
        });
      }
    }]);

    return TimingAnimation;
  }(Animation);

  module.exports = TimingAnimation;
},288,[24,25,32,34,35,37,264,283,285,267,289],"node_modules/react-native/Libraries/Animated/src/animations/TimingAnimation.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");

  var _ease;

  var Easing = function () {
    function Easing() {
      _classCallCheck(this, Easing);
    }

    _createClass(Easing, null, [{
      key: "step0",
      value: function step0(n) {
        return n > 0 ? 1 : 0;
      }
    }, {
      key: "step1",
      value: function step1(n) {
        return n >= 1 ? 1 : 0;
      }
    }, {
      key: "linear",
      value: function linear(t) {
        return t;
      }
    }, {
      key: "ease",
      value: function ease(t) {
        if (!_ease) {
          _ease = Easing.bezier(0.42, 0, 1, 1);
        }

        return _ease(t);
      }
    }, {
      key: "quad",
      value: function quad(t) {
        return t * t;
      }
    }, {
      key: "cubic",
      value: function cubic(t) {
        return t * t * t;
      }
    }, {
      key: "poly",
      value: function poly(n) {
        return function (t) {
          return Math.pow(t, n);
        };
      }
    }, {
      key: "sin",
      value: function sin(t) {
        return 1 - Math.cos(t * Math.PI / 2);
      }
    }, {
      key: "circle",
      value: function circle(t) {
        return 1 - Math.sqrt(1 - t * t);
      }
    }, {
      key: "exp",
      value: function exp(t) {
        return Math.pow(2, 10 * (t - 1));
      }
    }, {
      key: "elastic",
      value: function elastic() {
        var bounciness = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;
        var p = bounciness * Math.PI;
        return function (t) {
          return 1 - Math.pow(Math.cos(t * Math.PI / 2), 3) * Math.cos(t * p);
        };
      }
    }, {
      key: "back",
      value: function back() {
        var s = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1.70158;
        return function (t) {
          return t * t * ((s + 1) * t - s);
        };
      }
    }, {
      key: "bounce",
      value: function bounce(t) {
        if (t < 1 / 2.75) {
          return 7.5625 * t * t;
        }

        if (t < 2 / 2.75) {
          var _t = t - 1.5 / 2.75;

          return 7.5625 * _t * _t + 0.75;
        }

        if (t < 2.5 / 2.75) {
          var _t2 = t - 2.25 / 2.75;

          return 7.5625 * _t2 * _t2 + 0.9375;
        }

        var t2 = t - 2.625 / 2.75;
        return 7.5625 * t2 * t2 + 0.984375;
      }
    }, {
      key: "bezier",
      value: function bezier(x1, y1, x2, y2) {
        var _bezier = _$$_REQUIRE(_dependencyMap[2], "./bezier");

        return _bezier(x1, y1, x2, y2);
      }
    }, {
      key: "in",
      value: function _in(easing) {
        return easing;
      }
    }, {
      key: "out",
      value: function out(easing) {
        return function (t) {
          return 1 - easing(1 - t);
        };
      }
    }, {
      key: "inOut",
      value: function inOut(easing) {
        return function (t) {
          if (t < 0.5) {
            return easing(t * 2) / 2;
          }

          return 1 - easing((1 - t) * 2) / 2;
        };
      }
    }]);

    return Easing;
  }();

  module.exports = Easing;
},289,[24,25,290],"node_modules/react-native/Libraries/Animated/src/Easing.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var NEWTON_ITERATIONS = 4;
  var NEWTON_MIN_SLOPE = 0.001;
  var SUBDIVISION_PRECISION = 0.0000001;
  var SUBDIVISION_MAX_ITERATIONS = 10;
  var kSplineTableSize = 11;
  var kSampleStepSize = 1.0 / (kSplineTableSize - 1.0);
  var float32ArraySupported = typeof Float32Array === 'function';

  function A(aA1, aA2) {
    return 1.0 - 3.0 * aA2 + 3.0 * aA1;
  }

  function B(aA1, aA2) {
    return 3.0 * aA2 - 6.0 * aA1;
  }

  function C(aA1) {
    return 3.0 * aA1;
  }

  function calcBezier(aT, aA1, aA2) {
    return ((A(aA1, aA2) * aT + B(aA1, aA2)) * aT + C(aA1)) * aT;
  }

  function getSlope(aT, aA1, aA2) {
    return 3.0 * A(aA1, aA2) * aT * aT + 2.0 * B(aA1, aA2) * aT + C(aA1);
  }

  function binarySubdivide(aX, _aA, _aB, mX1, mX2) {
    var currentX,
        currentT,
        i = 0,
        aA = _aA,
        aB = _aB;

    do {
      currentT = aA + (aB - aA) / 2.0;
      currentX = calcBezier(currentT, mX1, mX2) - aX;

      if (currentX > 0.0) {
        aB = currentT;
      } else {
        aA = currentT;
      }
    } while (Math.abs(currentX) > SUBDIVISION_PRECISION && ++i < SUBDIVISION_MAX_ITERATIONS);

    return currentT;
  }

  function newtonRaphsonIterate(aX, _aGuessT, mX1, mX2) {
    var aGuessT = _aGuessT;

    for (var i = 0; i < NEWTON_ITERATIONS; ++i) {
      var currentSlope = getSlope(aGuessT, mX1, mX2);

      if (currentSlope === 0.0) {
        return aGuessT;
      }

      var currentX = calcBezier(aGuessT, mX1, mX2) - aX;
      aGuessT -= currentX / currentSlope;
    }

    return aGuessT;
  }

  module.exports = function bezier(mX1, mY1, mX2, mY2) {
    if (!(mX1 >= 0 && mX1 <= 1 && mX2 >= 0 && mX2 <= 1)) {
      throw new Error('bezier x values must be in [0, 1] range');
    }

    var sampleValues = float32ArraySupported ? new Float32Array(kSplineTableSize) : new Array(kSplineTableSize);

    if (mX1 !== mY1 || mX2 !== mY2) {
      for (var i = 0; i < kSplineTableSize; ++i) {
        sampleValues[i] = calcBezier(i * kSampleStepSize, mX1, mX2);
      }
    }

    function getTForX(aX) {
      var intervalStart = 0.0;
      var currentSample = 1;
      var lastSample = kSplineTableSize - 1;

      for (; currentSample !== lastSample && sampleValues[currentSample] <= aX; ++currentSample) {
        intervalStart += kSampleStepSize;
      }

      --currentSample;
      var dist = (aX - sampleValues[currentSample]) / (sampleValues[currentSample + 1] - sampleValues[currentSample]);
      var guessForT = intervalStart + dist * kSampleStepSize;
      var initialSlope = getSlope(guessForT, mX1, mX2);

      if (initialSlope >= NEWTON_MIN_SLOPE) {
        return newtonRaphsonIterate(aX, guessForT, mX1, mX2);
      } else if (initialSlope === 0.0) {
        return guessForT;
      } else {
        return binarySubdivide(aX, intervalStart, intervalStart + kSampleStepSize, mX1, mX2);
      }
    }

    return function BezierEasing(x) {
      if (mX1 === mY1 && mX2 === mY2) {
        return x;
      }

      if (x === 0) {
        return 0;
      }

      if (x === 1) {
        return 1;
      }

      return calcBezier(getTForX(x), mY1, mY2);
    };
  };
},290,[],"node_modules/react-native/Libraries/Animated/src/bezier.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass");

  var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn");

  var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf");

  var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native/Libraries/Animated/src/createAnimatedComponent.js";

  var _require = _$$_REQUIRE(_dependencyMap[6], "./AnimatedEvent"),
      AnimatedEvent = _require.AnimatedEvent;

  var AnimatedProps = _$$_REQUIRE(_dependencyMap[7], "./nodes/AnimatedProps");

  var React = _$$_REQUIRE(_dependencyMap[8], "react");

  var DeprecatedViewStylePropTypes = _$$_REQUIRE(_dependencyMap[9], "../../DeprecatedPropTypes/DeprecatedViewStylePropTypes");

  var invariant = _$$_REQUIRE(_dependencyMap[10], "invariant");

  function createAnimatedComponent(Component, defaultProps) {
    invariant(typeof Component !== 'function' || Component.prototype && Component.prototype.isReactComponent, '`createAnimatedComponent` does not support stateless functional components; ' + 'use a class component instead.');

    var AnimatedComponent = function (_React$Component) {
      _inherits(AnimatedComponent, _React$Component);

      function AnimatedComponent(props) {
        var _this;

        _classCallCheck(this, AnimatedComponent);

        _this = _possibleConstructorReturn(this, _getPrototypeOf(AnimatedComponent).call(this, props));
        _this._invokeAnimatedPropsCallbackOnMount = false;
        _this._eventDetachers = [];

        _this._animatedPropsCallback = function () {
          if (_this._component == null) {
            _this._invokeAnimatedPropsCallbackOnMount = true;
          } else if (AnimatedComponent.__skipSetNativeProps_FOR_TESTS_ONLY || typeof _this._component.setNativeProps !== 'function') {
            _this.forceUpdate();
          } else if (!_this._propsAnimated.__isNative) {
            _this._component.setNativeProps(_this._propsAnimated.__getAnimatedValue());
          } else {
            throw new Error('Attempting to run JS driven animation on animated ' + 'node that has been moved to "native" earlier by starting an ' + 'animation with `useNativeDriver: true`');
          }
        };

        _this._setComponentRef = function (c) {
          _this._prevComponent = _this._component;
          _this._component = c;
        };

        return _this;
      }

      _createClass(AnimatedComponent, [{
        key: "componentWillUnmount",
        value: function componentWillUnmount() {
          this._propsAnimated && this._propsAnimated.__detach();

          this._detachNativeEvents();
        }
      }, {
        key: "setNativeProps",
        value: function setNativeProps(props) {
          this._component.setNativeProps(props);
        }
      }, {
        key: "UNSAFE_componentWillMount",
        value: function UNSAFE_componentWillMount() {
          this._attachProps(this.props);
        }
      }, {
        key: "componentDidMount",
        value: function componentDidMount() {
          if (this._invokeAnimatedPropsCallbackOnMount) {
            this._invokeAnimatedPropsCallbackOnMount = false;

            this._animatedPropsCallback();
          }

          this._propsAnimated.setNativeView(this._component);

          this._attachNativeEvents();
        }
      }, {
        key: "_attachNativeEvents",
        value: function _attachNativeEvents() {
          var _this$_component,
              _this2 = this;

          var scrollableNode = ((_this$_component = this._component) == null ? void 0 : _this$_component.getScrollableNode) ? this._component.getScrollableNode() : this._component;

          var _loop = function _loop(key) {
            var prop = _this2.props[key];

            if (prop instanceof AnimatedEvent && prop.__isNative) {
              prop.__attach(scrollableNode, key);

              _this2._eventDetachers.push(function () {
                return prop.__detach(scrollableNode, key);
              });
            }
          };

          for (var key in this.props) {
            _loop(key);
          }
        }
      }, {
        key: "_detachNativeEvents",
        value: function _detachNativeEvents() {
          this._eventDetachers.forEach(function (remove) {
            return remove();
          });

          this._eventDetachers = [];
        }
      }, {
        key: "_attachProps",
        value: function _attachProps(nextProps) {
          var oldPropsAnimated = this._propsAnimated;
          this._propsAnimated = new AnimatedProps(nextProps, this._animatedPropsCallback);
          oldPropsAnimated && oldPropsAnimated.__detach();
        }
      }, {
        key: "UNSAFE_componentWillReceiveProps",
        value: function UNSAFE_componentWillReceiveProps(newProps) {
          this._attachProps(newProps);
        }
      }, {
        key: "componentDidUpdate",
        value: function componentDidUpdate(prevProps) {
          if (this._component !== this._prevComponent) {
            this._propsAnimated.setNativeView(this._component);
          }

          if (this._component !== this._prevComponent || prevProps !== this.props) {
            this._detachNativeEvents();

            this._attachNativeEvents();
          }
        }
      }, {
        key: "render",
        value: function render() {
          var props = this._propsAnimated.__getValue();

          return React.createElement(Component, _extends({}, defaultProps, props, {
            ref: this._setComponentRef,
            collapsable: this._propsAnimated.__isNative ? false : props.collapsable,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 151
            }
          }));
        }
      }, {
        key: "getNode",
        value: function getNode() {
          return this._component;
        }
      }]);

      return AnimatedComponent;
    }(React.Component);

    AnimatedComponent.__skipSetNativeProps_FOR_TESTS_ONLY = false;
    var propTypes = Component.propTypes;
    AnimatedComponent.propTypes = {
      style: function style(props, propName, componentName) {
        if (!propTypes) {
          return;
        }

        for (var key in DeprecatedViewStylePropTypes) {
          if (!propTypes[key] && props[key] !== undefined) {
            console.warn('You are setting the style `{ ' + key + ': ... }` as a prop. You ' + 'should nest it in a style object. ' + 'E.g. `{ style: { ' + key + ': ... } }`');
          }
        }
      }
    };
    return AnimatedComponent;
  }

  module.exports = createAnimatedComponent;
},291,[13,24,25,32,34,37,263,278,54,79,3],"node_modules/react-native/Libraries/Animated/src/createAnimatedComponent.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var FlatList = _$$_REQUIRE(_dependencyMap[0], "../../../Lists/FlatList");

  var createAnimatedComponent = _$$_REQUIRE(_dependencyMap[1], "../createAnimatedComponent");

  module.exports = createAnimatedComponent(FlatList, {
    scrollEventThrottle: 0.0001
  });
},292,[293,291],"node_modules/react-native/Libraries/Animated/src/components/AnimatedFlatList.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");

  var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");

  var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");

  var _createClass = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/createClass");

  var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");

  var _defineProperty = _$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/defineProperty");

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native/Libraries/Lists/FlatList.js";

  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

  var Platform = _$$_REQUIRE(_dependencyMap[7], "../Utilities/Platform");

  var deepDiffer = _$$_REQUIRE(_dependencyMap[8], "../Utilities/differ/deepDiffer");

  var React = _$$_REQUIRE(_dependencyMap[9], "react");

  var View = _$$_REQUIRE(_dependencyMap[10], "../Components/View/View");

  var VirtualizedList = _$$_REQUIRE(_dependencyMap[11], "./VirtualizedList");

  var StyleSheet = _$$_REQUIRE(_dependencyMap[12], "../StyleSheet/StyleSheet");

  var invariant = _$$_REQUIRE(_dependencyMap[13], "invariant");

  var defaultProps = _objectSpread({}, VirtualizedList.defaultProps, {
    numColumns: 1,
    removeClippedSubviews: "android" === 'android'
  });

  var FlatList = function (_React$PureComponent) {
    _inherits(FlatList, _React$PureComponent);

    _createClass(FlatList, [{
      key: "scrollToEnd",
      value: function scrollToEnd(params) {
        if (this._listRef) {
          this._listRef.scrollToEnd(params);
        }
      }
    }, {
      key: "scrollToIndex",
      value: function scrollToIndex(params) {
        if (this._listRef) {
          this._listRef.scrollToIndex(params);
        }
      }
    }, {
      key: "scrollToItem",
      value: function scrollToItem(params) {
        if (this._listRef) {
          this._listRef.scrollToItem(params);
        }
      }
    }, {
      key: "scrollToOffset",
      value: function scrollToOffset(params) {
        if (this._listRef) {
          this._listRef.scrollToOffset(params);
        }
      }
    }, {
      key: "recordInteraction",
      value: function recordInteraction() {
        if (this._listRef) {
          this._listRef.recordInteraction();
        }
      }
    }, {
      key: "flashScrollIndicators",
      value: function flashScrollIndicators() {
        if (this._listRef) {
          this._listRef.flashScrollIndicators();
        }
      }
    }, {
      key: "getScrollResponder",
      value: function getScrollResponder() {
        if (this._listRef) {
          return this._listRef.getScrollResponder();
        }
      }
    }, {
      key: "getScrollableNode",
      value: function getScrollableNode() {
        if (this._listRef) {
          return this._listRef.getScrollableNode();
        }
      }
    }, {
      key: "setNativeProps",
      value: function setNativeProps(props) {
        if (this._listRef) {
          this._listRef.setNativeProps(props);
        }
      }
    }]);

    function FlatList(_props) {
      var _this;

      _classCallCheck(this, FlatList);

      _this = _possibleConstructorReturn(this, _getPrototypeOf(FlatList).call(this, _props));
      _this._virtualizedListPairs = [];

      _this._captureRef = function (ref) {
        _this._listRef = ref;
      };

      _this._getItem = function (data, index) {
        var numColumns = _this.props.numColumns;

        if (numColumns > 1) {
          var ret = [];

          for (var kk = 0; kk < numColumns; kk++) {
            var _item = data[index * numColumns + kk];

            if (_item != null) {
              ret.push(_item);
            }
          }

          return ret;
        } else {
          return data[index];
        }
      };

      _this._getItemCount = function (data) {
        return data ? Math.ceil(data.length / _this.props.numColumns) : 0;
      };

      _this._keyExtractor = function (items, index) {
        var _this$props = _this.props,
            keyExtractor = _this$props.keyExtractor,
            numColumns = _this$props.numColumns;

        if (numColumns > 1) {
          invariant(Array.isArray(items), 'FlatList: Encountered internal consistency error, expected each item to consist of an ' + 'array with 1-%s columns; instead, received a single item.', numColumns);
          return items.map(function (it, kk) {
            return keyExtractor(it, index * numColumns + kk);
          }).join(':');
        } else {
          return keyExtractor(items, index);
        }
      };

      _this._renderer = function () {
        var _this$props2 = _this.props,
            ListItemComponent = _this$props2.ListItemComponent,
            renderItem = _this$props2.renderItem,
            numColumns = _this$props2.numColumns,
            columnWrapperStyle = _this$props2.columnWrapperStyle;
        var virtualizedListRenderKey = ListItemComponent ? 'ListItemComponent' : 'renderItem';

        var renderer = function renderer(props) {
          if (ListItemComponent) {
            return React.createElement(ListItemComponent, _extends({}, props, {
              __source: {
                fileName: _jsxFileName,
                lineNumber: 633
              }
            }));
          } else if (renderItem) {
            return renderItem(props);
          } else {
            return null;
          }
        };

        return _defineProperty({}, virtualizedListRenderKey, function (info) {
          if (numColumns > 1) {
            var _item2 = info.item,
                _index = info.index;
            invariant(Array.isArray(_item2), 'Expected array of items with numColumns > 1');
            return React.createElement(View, {
              style: StyleSheet.compose(styles.row, columnWrapperStyle),
              __source: {
                fileName: _jsxFileName,
                lineNumber: 650
              }
            }, _item2.map(function (it, kk) {
              var element = renderer({
                item: it,
                index: _index * numColumns + kk,
                separators: info.separators
              });
              return element != null ? React.createElement(React.Fragment, {
                key: kk,
                __source: {
                  fileName: _jsxFileName,
                  lineNumber: 662
                }
              }, element) : null;
            }));
          } else {
            return renderer(info);
          }
        });
      };

      _this._checkProps(_this.props);

      if (_this.props.viewabilityConfigCallbackPairs) {
        _this._virtualizedListPairs = _this.props.viewabilityConfigCallbackPairs.map(function (pair) {
          return {
            viewabilityConfig: pair.viewabilityConfig,
            onViewableItemsChanged: _this._createOnViewableItemsChanged(pair.onViewableItemsChanged)
          };
        });
      } else if (_this.props.onViewableItemsChanged) {
        _this._virtualizedListPairs.push({
          viewabilityConfig: _this.props.viewabilityConfig,
          onViewableItemsChanged: _this._createOnViewableItemsChanged(_this.props.onViewableItemsChanged)
        });
      }

      return _this;
    }

    _createClass(FlatList, [{
      key: "componentDidUpdate",
      value: function componentDidUpdate(prevProps) {
        invariant(prevProps.numColumns === this.props.numColumns, 'Changing numColumns on the fly is not supported. Change the key prop on FlatList when ' + 'changing the number of columns to force a fresh render of the component.');
        invariant(prevProps.onViewableItemsChanged === this.props.onViewableItemsChanged, 'Changing onViewableItemsChanged on the fly is not supported');
        invariant(!deepDiffer(prevProps.viewabilityConfig, this.props.viewabilityConfig), 'Changing viewabilityConfig on the fly is not supported');
        invariant(prevProps.viewabilityConfigCallbackPairs === this.props.viewabilityConfigCallbackPairs, 'Changing viewabilityConfigCallbackPairs on the fly is not supported');

        this._checkProps(this.props);
      }
    }, {
      key: "_checkProps",
      value: function _checkProps(props) {
        var getItem = props.getItem,
            getItemCount = props.getItemCount,
            horizontal = props.horizontal,
            numColumns = props.numColumns,
            columnWrapperStyle = props.columnWrapperStyle,
            onViewableItemsChanged = props.onViewableItemsChanged,
            viewabilityConfigCallbackPairs = props.viewabilityConfigCallbackPairs;
        invariant(!getItem && !getItemCount, 'FlatList does not support custom data formats.');

        if (numColumns > 1) {
          invariant(!horizontal, 'numColumns does not support horizontal.');
        } else {
          invariant(!columnWrapperStyle, 'columnWrapperStyle not supported for single column lists');
        }

        invariant(!(onViewableItemsChanged && viewabilityConfigCallbackPairs), 'FlatList does not support setting both onViewableItemsChanged and ' + 'viewabilityConfigCallbackPairs.');
      }
    }, {
      key: "_pushMultiColumnViewable",
      value: function _pushMultiColumnViewable(arr, v) {
        var _this$props3 = this.props,
            numColumns = _this$props3.numColumns,
            keyExtractor = _this$props3.keyExtractor;
        v.item.forEach(function (item, ii) {
          invariant(v.index != null, 'Missing index!');
          var index = v.index * numColumns + ii;
          arr.push(_objectSpread({}, v, {
            item: item,
            key: keyExtractor(item, index),
            index: index
          }));
        });
      }
    }, {
      key: "_createOnViewableItemsChanged",
      value: function _createOnViewableItemsChanged(onViewableItemsChanged) {
        var _this2 = this;

        return function (info) {
          var numColumns = _this2.props.numColumns;

          if (onViewableItemsChanged) {
            if (numColumns > 1) {
              var changed = [];
              var viewableItems = [];
              info.viewableItems.forEach(function (v) {
                return _this2._pushMultiColumnViewable(viewableItems, v);
              });
              info.changed.forEach(function (v) {
                return _this2._pushMultiColumnViewable(changed, v);
              });
              onViewableItemsChanged({
                viewableItems: viewableItems,
                changed: changed
              });
            } else {
              onViewableItemsChanged(info);
            }
          }
        };
      }
    }, {
      key: "render",
      value: function render() {
        return React.createElement(VirtualizedList, _extends({}, this.props, {
          getItem: this._getItem,
          getItemCount: this._getItemCount,
          keyExtractor: this._keyExtractor,
          ref: this._captureRef,
          viewabilityConfigCallbackPairs: this._virtualizedListPairs
        }, this._renderer(), {
          __source: {
            fileName: _jsxFileName,
            lineNumber: 676
          }
        }));
      }
    }]);

    return FlatList;
  }(React.PureComponent);

  FlatList.defaultProps = defaultProps;
  var styles = StyleSheet.create({
    row: {
      flexDirection: 'row'
    }
  });
  module.exports = FlatList;
},293,[13,24,32,34,25,37,46,48,196,54,86,294,60,3],"node_modules/react-native/Libraries/Lists/FlatList.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");

  var _defineProperty = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/defineProperty");

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck");

  var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn");

  var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf");

  var _assertThisInitialized = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/assertThisInitialized");

  var _createClass = _$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/createClass");

  var _inherits = _$$_REQUIRE(_dependencyMap[7], "@babel/runtime/helpers/inherits");

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native/Libraries/Lists/VirtualizedList.js";

  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

  var Batchinator = _$$_REQUIRE(_dependencyMap[8], "../Interaction/Batchinator");

  var FillRateHelper = _$$_REQUIRE(_dependencyMap[9], "./FillRateHelper");

  var PropTypes = _$$_REQUIRE(_dependencyMap[10], "prop-types");

  var React = _$$_REQUIRE(_dependencyMap[11], "react");

  var ReactNative = _$$_REQUIRE(_dependencyMap[12], "../Renderer/shims/ReactNative");

  var RefreshControl = _$$_REQUIRE(_dependencyMap[13], "../Components/RefreshControl/RefreshControl");

  var ScrollView = _$$_REQUIRE(_dependencyMap[14], "../Components/ScrollView/ScrollView");

  var StyleSheet = _$$_REQUIRE(_dependencyMap[15], "../StyleSheet/StyleSheet");

  var View = _$$_REQUIRE(_dependencyMap[16], "../Components/View/View");

  var ViewabilityHelper = _$$_REQUIRE(_dependencyMap[17], "./ViewabilityHelper");

  var flattenStyle = _$$_REQUIRE(_dependencyMap[18], "../StyleSheet/flattenStyle");

  var infoLog = _$$_REQUIRE(_dependencyMap[19], "../Utilities/infoLog");

  var invariant = _$$_REQUIRE(_dependencyMap[20], "invariant");

  var warning = _$$_REQUIRE(_dependencyMap[21], "fbjs/lib/warning");

  var _require = _$$_REQUIRE(_dependencyMap[22], "./VirtualizeUtils"),
      computeWindowedRenderLimits = _require.computeWindowedRenderLimits;

  var _usedIndexForKey = false;
  var _keylessItemComponentName = '';

  var VirtualizedList = function (_React$PureComponent) {
    _inherits(VirtualizedList, _React$PureComponent);

    _createClass(VirtualizedList, [{
      key: "scrollToEnd",
      value: function scrollToEnd(params) {
        var animated = params ? params.animated : true;
        var veryLast = this.props.getItemCount(this.props.data) - 1;

        var frame = this._getFrameMetricsApprox(veryLast);

        var offset = Math.max(0, frame.offset + frame.length + this._footerLength - this._scrollMetrics.visibleLength);

        this._scrollRef.scrollTo(this.props.horizontal ? {
          x: offset,
          animated: animated
        } : {
          y: offset,
          animated: animated
        });
      }
    }, {
      key: "scrollToIndex",
      value: function scrollToIndex(params) {
        var _this$props = this.props,
            data = _this$props.data,
            horizontal = _this$props.horizontal,
            getItemCount = _this$props.getItemCount,
            getItemLayout = _this$props.getItemLayout,
            onScrollToIndexFailed = _this$props.onScrollToIndexFailed;
        var animated = params.animated,
            index = params.index,
            viewOffset = params.viewOffset,
            viewPosition = params.viewPosition;
        invariant(index >= 0 && index < getItemCount(data), "scrollToIndex out of range: requested index " + index + " but maximum is " + (getItemCount(data) - 1));

        if (!getItemLayout && index > this._highestMeasuredFrameIndex) {
          invariant(!!onScrollToIndexFailed, 'scrollToIndex should be used in conjunction with getItemLayout or onScrollToIndexFailed, ' + 'otherwise there is no way to know the location of offscreen indices or handle failures.');
          onScrollToIndexFailed({
            averageItemLength: this._averageCellLength,
            highestMeasuredFrameIndex: this._highestMeasuredFrameIndex,
            index: index
          });
          return;
        }

        var frame = this._getFrameMetricsApprox(index);

        var offset = Math.max(0, frame.offset - (viewPosition || 0) * (this._scrollMetrics.visibleLength - frame.length)) - (viewOffset || 0);

        this._scrollRef.scrollTo(horizontal ? {
          x: offset,
          animated: animated
        } : {
          y: offset,
          animated: animated
        });
      }
    }, {
      key: "scrollToItem",
      value: function scrollToItem(params) {
        var item = params.item;
        var _this$props2 = this.props,
            data = _this$props2.data,
            getItem = _this$props2.getItem,
            getItemCount = _this$props2.getItemCount;
        var itemCount = getItemCount(data);

        for (var _index = 0; _index < itemCount; _index++) {
          if (getItem(data, _index) === item) {
            this.scrollToIndex(_objectSpread({}, params, {
              index: _index
            }));
            break;
          }
        }
      }
    }, {
      key: "scrollToOffset",
      value: function scrollToOffset(params) {
        var animated = params.animated,
            offset = params.offset;

        this._scrollRef.scrollTo(this.props.horizontal ? {
          x: offset,
          animated: animated
        } : {
          y: offset,
          animated: animated
        });
      }
    }, {
      key: "recordInteraction",
      value: function recordInteraction() {
        this._nestedChildLists.forEach(function (childList) {
          childList.ref && childList.ref.recordInteraction();
        });

        this._viewabilityTuples.forEach(function (t) {
          t.viewabilityHelper.recordInteraction();
        });

        this._updateViewableItems(this.props.data);
      }
    }, {
      key: "flashScrollIndicators",
      value: function flashScrollIndicators() {
        this._scrollRef.flashScrollIndicators();
      }
    }, {
      key: "getScrollResponder",
      value: function getScrollResponder() {
        if (this._scrollRef && this._scrollRef.getScrollResponder) {
          return this._scrollRef.getScrollResponder();
        }
      }
    }, {
      key: "getScrollableNode",
      value: function getScrollableNode() {
        if (this._scrollRef && this._scrollRef.getScrollableNode) {
          return this._scrollRef.getScrollableNode();
        } else {
          return ReactNative.findNodeHandle(this._scrollRef);
        }
      }
    }, {
      key: "getScrollRef",
      value: function getScrollRef() {
        if (this._scrollRef && this._scrollRef.getScrollRef) {
          return this._scrollRef.getScrollRef();
        } else {
          return this._scrollRef;
        }
      }
    }, {
      key: "setNativeProps",
      value: function setNativeProps(props) {
        if (this._scrollRef) {
          this._scrollRef.setNativeProps(props);
        }
      }
    }, {
      key: "getChildContext",
      value: function getChildContext() {
        return {
          virtualizedList: {
            getScrollMetrics: this._getScrollMetrics,
            horizontal: this.props.horizontal,
            getOutermostParentListRef: this._getOutermostParentListRef,
            getNestedChildState: this._getNestedChildState,
            registerAsNestedChild: this._registerAsNestedChild,
            unregisterAsNestedChild: this._unregisterAsNestedChild
          }
        };
      }
    }, {
      key: "_getCellKey",
      value: function _getCellKey() {
        return this.context.virtualizedCell && this.context.virtualizedCell.cellKey || 'rootList';
      }
    }, {
      key: "hasMore",
      value: function hasMore() {
        return this._hasMore;
      }
    }]);

    function VirtualizedList(_props, context) {
      var _this;

      _classCallCheck(this, VirtualizedList);

      _this = _possibleConstructorReturn(this, _getPrototypeOf(VirtualizedList).call(this, _props, context));

      _this._getScrollMetrics = function () {
        return _this._scrollMetrics;
      };

      _this._getOutermostParentListRef = function () {
        if (_this._isNestedWithSameOrientation()) {
          return _this.context.virtualizedList.getOutermostParentListRef();
        } else {
          return _assertThisInitialized(_this);
        }
      };

      _this._getNestedChildState = function (key) {
        var existingChildData = _this._nestedChildLists.get(key);

        return existingChildData && existingChildData.state;
      };

      _this._registerAsNestedChild = function (childList) {
        var childListsInCell = _this._cellKeysToChildListKeys.get(childList.cellKey) || new Set();
        childListsInCell.add(childList.key);

        _this._cellKeysToChildListKeys.set(childList.cellKey, childListsInCell);

        var existingChildData = _this._nestedChildLists.get(childList.key);

        if (existingChildData && existingChildData.ref !== null) {
          console.error('A VirtualizedList contains a cell which itself contains ' + 'more than one VirtualizedList of the same orientation as the parent ' + 'list. You must pass a unique listKey prop to each sibling list.');
        }

        _this._nestedChildLists.set(childList.key, {
          ref: childList.ref,
          state: null
        });

        if (_this._hasInteracted) {
          childList.ref.recordInteraction();
        }
      };

      _this._unregisterAsNestedChild = function (childList) {
        _this._nestedChildLists.set(childList.key, {
          ref: null,
          state: childList.state
        });
      };

      _this._onUpdateSeparators = function (keys, newProps) {
        keys.forEach(function (key) {
          var ref = key != null && _this._cellRefs[key];
          ref && ref.updateSeparatorProps(newProps);
        });
      };

      _this._averageCellLength = 0;
      _this._cellKeysToChildListKeys = new Map();
      _this._cellRefs = {};
      _this._frames = {};
      _this._footerLength = 0;
      _this._hasDataChangedSinceEndReached = true;
      _this._hasDoneInitialScroll = false;
      _this._hasInteracted = false;
      _this._hasMore = false;
      _this._hasWarned = {};
      _this._headerLength = 0;
      _this._hiPriInProgress = false;
      _this._highestMeasuredFrameIndex = 0;
      _this._indicesToKeys = new Map();
      _this._nestedChildLists = new Map();
      _this._offsetFromParentVirtualizedList = 0;
      _this._prevParentOffset = 0;
      _this._scrollMetrics = {
        contentLength: 0,
        dOffset: 0,
        dt: 10,
        offset: 0,
        timestamp: 0,
        velocity: 0,
        visibleLength: 0
      };
      _this._scrollRef = null;
      _this._sentEndForContentLength = 0;
      _this._totalCellLength = 0;
      _this._totalCellsMeasured = 0;
      _this._viewabilityTuples = [];

      _this._captureScrollRef = function (ref) {
        _this._scrollRef = ref;
      };

      _this._defaultRenderScrollComponent = function (props) {
        var onRefresh = props.onRefresh;

        if (_this._isNestedWithSameOrientation()) {
          return React.createElement(View, _extends({}, props, {
            __source: {
              fileName: _jsxFileName,
              lineNumber: 1156
            }
          }));
        } else if (onRefresh) {
          invariant(typeof props.refreshing === 'boolean', '`refreshing` prop must be set as a boolean in order to use `onRefresh`, but got `' + JSON.stringify(props.refreshing) + '`');
          return React.createElement(ScrollView, _extends({}, props, {
            refreshControl: props.refreshControl == null ? React.createElement(RefreshControl, {
              refreshing: props.refreshing,
              onRefresh: onRefresh,
              progressViewOffset: props.progressViewOffset,
              __source: {
                fileName: _jsxFileName,
                lineNumber: 1170
              }
            }) : props.refreshControl,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 1166
            }
          }));
        } else {
          return React.createElement(ScrollView, _extends({}, props, {
            __source: {
              fileName: _jsxFileName,
              lineNumber: 1183
            }
          }));
        }
      };

      _this._onCellUnmount = function (cellKey) {
        var curr = _this._frames[cellKey];

        if (curr) {
          _this._frames[cellKey] = _objectSpread({}, curr, {
            inLayout: false
          });
        }
      };

      _this._onLayout = function (e) {
        if (_this._isNestedWithSameOrientation()) {
          _this.measureLayoutRelativeToContainingList();
        } else {
          _this._scrollMetrics.visibleLength = _this._selectLength(e.nativeEvent.layout);
        }

        _this.props.onLayout && _this.props.onLayout(e);

        _this._scheduleCellsToRenderUpdate();

        _this._maybeCallOnEndReached();
      };

      _this._onLayoutEmpty = function (e) {
        _this.props.onLayout && _this.props.onLayout(e);
      };

      _this._onLayoutFooter = function (e) {
        _this._footerLength = _this._selectLength(e.nativeEvent.layout);
      };

      _this._onLayoutHeader = function (e) {
        _this._headerLength = _this._selectLength(e.nativeEvent.layout);
      };

      _this._onContentSizeChange = function (width, height) {
        if (width > 0 && height > 0 && _this.props.initialScrollIndex != null && _this.props.initialScrollIndex > 0 && !_this._hasDoneInitialScroll) {
          _this.scrollToIndex({
            animated: false,
            index: _this.props.initialScrollIndex
          });

          _this._hasDoneInitialScroll = true;
        }

        if (_this.props.onContentSizeChange) {
          _this.props.onContentSizeChange(width, height);
        }

        _this._scrollMetrics.contentLength = _this._selectLength({
          height: height,
          width: width
        });

        _this._scheduleCellsToRenderUpdate();

        _this._maybeCallOnEndReached();
      };

      _this._convertParentScrollMetrics = function (metrics) {
        var offset = metrics.offset - _this._offsetFromParentVirtualizedList;
        var visibleLength = metrics.visibleLength;
        var dOffset = offset - _this._scrollMetrics.offset;
        var contentLength = _this._scrollMetrics.contentLength;
        return {
          visibleLength: visibleLength,
          contentLength: contentLength,
          offset: offset,
          dOffset: dOffset
        };
      };

      _this._onScroll = function (e) {
        _this._nestedChildLists.forEach(function (childList) {
          childList.ref && childList.ref._onScroll(e);
        });

        if (_this.props.onScroll) {
          _this.props.onScroll(e);
        }

        var timestamp = e.timeStamp;

        var visibleLength = _this._selectLength(e.nativeEvent.layoutMeasurement);

        var contentLength = _this._selectLength(e.nativeEvent.contentSize);

        var offset = _this._selectOffset(e.nativeEvent.contentOffset);

        var dOffset = offset - _this._scrollMetrics.offset;

        if (_this._isNestedWithSameOrientation()) {
          if (_this._scrollMetrics.contentLength === 0) {
            return;
          }

          var _this$_convertParentS = _this._convertParentScrollMetrics({
            visibleLength: visibleLength,
            offset: offset
          });

          visibleLength = _this$_convertParentS.visibleLength;
          contentLength = _this$_convertParentS.contentLength;
          offset = _this$_convertParentS.offset;
          dOffset = _this$_convertParentS.dOffset;
        }

        var dt = _this._scrollMetrics.timestamp ? Math.max(1, timestamp - _this._scrollMetrics.timestamp) : 1;
        var velocity = dOffset / dt;

        if (dt > 500 && _this._scrollMetrics.dt > 500 && contentLength > 5 * visibleLength && !_this._hasWarned.perf) {
          infoLog('VirtualizedList: You have a large list that is slow to update - make sure your ' + 'renderItem function renders components that follow React performance best practices ' + 'like PureComponent, shouldComponentUpdate, etc.', {
            dt: dt,
            prevDt: _this._scrollMetrics.dt,
            contentLength: contentLength
          });
          _this._hasWarned.perf = true;
        }

        _this._scrollMetrics = {
          contentLength: contentLength,
          dt: dt,
          dOffset: dOffset,
          offset: offset,
          timestamp: timestamp,
          velocity: velocity,
          visibleLength: visibleLength
        };

        _this._updateViewableItems(_this.props.data);

        if (!_this.props) {
          return;
        }

        _this._maybeCallOnEndReached();

        if (velocity !== 0) {
          _this._fillRateHelper.activate();
        }

        _this._computeBlankness();

        _this._scheduleCellsToRenderUpdate();
      };

      _this._onScrollBeginDrag = function (e) {
        _this._nestedChildLists.forEach(function (childList) {
          childList.ref && childList.ref._onScrollBeginDrag(e);
        });

        _this._viewabilityTuples.forEach(function (tuple) {
          tuple.viewabilityHelper.recordInteraction();
        });

        _this._hasInteracted = true;
        _this.props.onScrollBeginDrag && _this.props.onScrollBeginDrag(e);
      };

      _this._onScrollEndDrag = function (e) {
        var velocity = e.nativeEvent.velocity;

        if (velocity) {
          _this._scrollMetrics.velocity = _this._selectOffset(velocity);
        }

        _this._computeBlankness();

        _this.props.onScrollEndDrag && _this.props.onScrollEndDrag(e);
      };

      _this._onMomentumScrollEnd = function (e) {
        _this._scrollMetrics.velocity = 0;

        _this._computeBlankness();

        _this.props.onMomentumScrollEnd && _this.props.onMomentumScrollEnd(e);
      };

      _this._updateCellsToRender = function () {
        var _this$props3 = _this.props,
            data = _this$props3.data,
            getItemCount = _this$props3.getItemCount,
            onEndReachedThreshold = _this$props3.onEndReachedThreshold;

        var isVirtualizationDisabled = _this._isVirtualizationDisabled();

        _this._updateViewableItems(data);

        if (!data) {
          return;
        }

        _this.setState(function (state) {
          var newState;

          if (!isVirtualizationDisabled) {
            if (_this._scrollMetrics.visibleLength) {
              if (!_this.props.initialScrollIndex || _this._scrollMetrics.offset) {
                newState = computeWindowedRenderLimits(_this.props, state, _this._getFrameMetricsApprox, _this._scrollMetrics);
              }
            }
          } else {
            var _this$_scrollMetrics = _this._scrollMetrics,
                contentLength = _this$_scrollMetrics.contentLength,
                offset = _this$_scrollMetrics.offset,
                visibleLength = _this$_scrollMetrics.visibleLength;
            var distanceFromEnd = contentLength - visibleLength - offset;
            var renderAhead = distanceFromEnd < onEndReachedThreshold * visibleLength ? _this.props.maxToRenderPerBatch : 0;
            newState = {
              first: 0,
              last: Math.min(state.last + renderAhead, getItemCount(data) - 1)
            };
          }

          if (newState && _this._nestedChildLists.size > 0) {
            var newFirst = newState.first;
            var newLast = newState.last;

            for (var ii = newFirst; ii <= newLast; ii++) {
              var cellKeyForIndex = _this._indicesToKeys.get(ii);

              var childListKeys = cellKeyForIndex && _this._cellKeysToChildListKeys.get(cellKeyForIndex);

              if (!childListKeys) {
                continue;
              }

              var someChildHasMore = false;

              for (var _iterator = childListKeys, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[typeof Symbol === "function" ? typeof Symbol === "function" ? Symbol.iterator : "@@iterator" : "@@iterator"]();;) {
                var _ref;

                if (_isArray) {
                  if (_i >= _iterator.length) break;
                  _ref = _iterator[_i++];
                } else {
                  _i = _iterator.next();
                  if (_i.done) break;
                  _ref = _i.value;
                }

                var _childKey = _ref;

                var _childList = _this._nestedChildLists.get(_childKey);

                if (_childList && _childList.ref && _childList.ref.hasMore()) {
                  someChildHasMore = true;
                  break;
                }
              }

              if (someChildHasMore) {
                newState.last = ii;
                break;
              }
            }
          }

          return newState;
        });
      };

      _this._createViewToken = function (index, isViewable) {
        var _this$props4 = _this.props,
            data = _this$props4.data,
            getItem = _this$props4.getItem,
            keyExtractor = _this$props4.keyExtractor;
        var item = getItem(data, index);
        return {
          index: index,
          item: item,
          key: keyExtractor(item, index),
          isViewable: isViewable
        };
      };

      _this._getFrameMetricsApprox = function (index) {
        var frame = _this._getFrameMetrics(index);

        if (frame && frame.index === index) {
          return frame;
        } else {
          var getItemLayout = _this.props.getItemLayout;
          invariant(!getItemLayout, 'Should not have to estimate frames when a measurement metrics function is provided');
          return {
            length: _this._averageCellLength,
            offset: _this._averageCellLength * index
          };
        }
      };

      _this._getFrameMetrics = function (index) {
        var _this$props5 = _this.props,
            data = _this$props5.data,
            getItem = _this$props5.getItem,
            getItemCount = _this$props5.getItemCount,
            getItemLayout = _this$props5.getItemLayout,
            keyExtractor = _this$props5.keyExtractor;
        invariant(getItemCount(data) > index, 'Tried to get frame for out of range index ' + index);
        var item = getItem(data, index);

        var frame = item && _this._frames[keyExtractor(item, index)];

        if (!frame || frame.index !== index) {
          if (getItemLayout) {
            frame = getItemLayout(data, index);

            if (__DEV__) {
              var frameType = PropTypes.shape({
                length: PropTypes.number.isRequired,
                offset: PropTypes.number.isRequired,
                index: PropTypes.number.isRequired
              }).isRequired;
              PropTypes.checkPropTypes({
                frame: frameType
              }, {
                frame: frame
              }, 'frame', 'VirtualizedList.getItemLayout');
            }
          }
        }

        return frame;
      };

      invariant(!_props.onScroll || !_props.onScroll.__isNative, 'Components based on VirtualizedList must be wrapped with Animated.createAnimatedComponent ' + 'to support native onScroll events with useNativeDriver');
      invariant(_props.windowSize > 0, 'VirtualizedList: The windowSize prop must be present and set to a value greater than 0.');
      _this._fillRateHelper = new FillRateHelper(_this._getFrameMetrics);
      _this._updateCellsToRenderBatcher = new Batchinator(_this._updateCellsToRender, _this.props.updateCellsBatchingPeriod);

      if (_this.props.viewabilityConfigCallbackPairs) {
        _this._viewabilityTuples = _this.props.viewabilityConfigCallbackPairs.map(function (pair) {
          return {
            viewabilityHelper: new ViewabilityHelper(pair.viewabilityConfig),
            onViewableItemsChanged: pair.onViewableItemsChanged
          };
        });
      } else if (_this.props.onViewableItemsChanged) {
        _this._viewabilityTuples.push({
          viewabilityHelper: new ViewabilityHelper(_this.props.viewabilityConfig),
          onViewableItemsChanged: _this.props.onViewableItemsChanged
        });
      }

      var initialState = {
        first: _this.props.initialScrollIndex || 0,
        last: Math.min(_this.props.getItemCount(_this.props.data), (_this.props.initialScrollIndex || 0) + _this.props.initialNumToRender) - 1
      };

      if (_this._isNestedWithSameOrientation()) {
        var storedState = _this.context.virtualizedList.getNestedChildState(_this.props.listKey || _this._getCellKey());

        if (storedState) {
          initialState = storedState;
          _this.state = storedState;
          _this._frames = storedState.frames;
        }
      }

      _this.state = initialState;
      return _this;
    }

    _createClass(VirtualizedList, [{
      key: "componentDidMount",
      value: function componentDidMount() {
        if (this._isNestedWithSameOrientation()) {
          this.context.virtualizedList.registerAsNestedChild({
            cellKey: this._getCellKey(),
            key: this.props.listKey || this._getCellKey(),
            ref: this
          });
        }
      }
    }, {
      key: "componentWillUnmount",
      value: function componentWillUnmount() {
        if (this._isNestedWithSameOrientation()) {
          this.context.virtualizedList.unregisterAsNestedChild({
            key: this.props.listKey || this._getCellKey(),
            state: {
              first: this.state.first,
              last: this.state.last,
              frames: this._frames
            }
          });
        }

        this._updateViewableItems(null);

        this._updateCellsToRenderBatcher.dispose({
          abort: true
        });

        this._viewabilityTuples.forEach(function (tuple) {
          tuple.viewabilityHelper.dispose();
        });

        this._fillRateHelper.deactivateAndFlush();
      }
    }, {
      key: "_pushCells",
      value: function _pushCells(cells, stickyHeaderIndices, stickyIndicesFromProps, first, last, inversionStyle) {
        var _this2 = this;

        var _this$props6 = this.props,
            CellRendererComponent = _this$props6.CellRendererComponent,
            ItemSeparatorComponent = _this$props6.ItemSeparatorComponent,
            data = _this$props6.data,
            getItem = _this$props6.getItem,
            getItemCount = _this$props6.getItemCount,
            horizontal = _this$props6.horizontal,
            keyExtractor = _this$props6.keyExtractor;
        var stickyOffset = this.props.ListHeaderComponent ? 1 : 0;
        var end = getItemCount(data) - 1;
        var prevCellKey;
        last = Math.min(end, last);

        var _loop = function _loop(ii) {
          var item = getItem(data, ii);
          var key = keyExtractor(item, ii);

          _this2._indicesToKeys.set(ii, key);

          if (stickyIndicesFromProps.has(ii + stickyOffset)) {
            stickyHeaderIndices.push(cells.length);
          }

          cells.push(React.createElement(CellRenderer, {
            CellRendererComponent: CellRendererComponent,
            ItemSeparatorComponent: ii < end ? ItemSeparatorComponent : undefined,
            cellKey: key,
            fillRateHelper: _this2._fillRateHelper,
            horizontal: horizontal,
            index: ii,
            inversionStyle: inversionStyle,
            item: item,
            key: key,
            prevCellKey: prevCellKey,
            onUpdateSeparators: _this2._onUpdateSeparators,
            onLayout: function onLayout(e) {
              return _this2._onCellLayout(e, key, ii);
            },
            onUnmount: _this2._onCellUnmount,
            parentProps: _this2.props,
            ref: function ref(_ref2) {
              _this2._cellRefs[key] = _ref2;
            },
            __source: {
              fileName: _jsxFileName,
              lineNumber: 767
            }
          }));
          prevCellKey = key;
        };

        for (var ii = first; ii <= last; ii++) {
          _loop(ii);
        }
      }
    }, {
      key: "_isVirtualizationDisabled",
      value: function _isVirtualizationDisabled() {
        return this.props.disableVirtualization || false;
      }
    }, {
      key: "_isNestedWithSameOrientation",
      value: function _isNestedWithSameOrientation() {
        var nestedContext = this.context.virtualizedList;
        return !!(nestedContext && !!nestedContext.horizontal === !!this.props.horizontal);
      }
    }, {
      key: "render",
      value: function render() {
        var _this3 = this;

        if (__DEV__) {
          var flatStyles = flattenStyle(this.props.contentContainerStyle);
          warning(flatStyles == null || flatStyles.flexWrap !== 'wrap', '`flexWrap: `wrap`` is not supported with the `VirtualizedList` components.' + 'Consider using `numColumns` with `FlatList` instead.');
        }

        var _this$props7 = this.props,
            ListEmptyComponent = _this$props7.ListEmptyComponent,
            ListFooterComponent = _this$props7.ListFooterComponent,
            ListHeaderComponent = _this$props7.ListHeaderComponent;
        var _this$props8 = this.props,
            data = _this$props8.data,
            horizontal = _this$props8.horizontal;

        var isVirtualizationDisabled = this._isVirtualizationDisabled();

        var inversionStyle = this.props.inverted ? this.props.horizontal ? styles.horizontallyInverted : styles.verticallyInverted : null;
        var cells = [];
        var stickyIndicesFromProps = new Set(this.props.stickyHeaderIndices);
        var stickyHeaderIndices = [];

        if (ListHeaderComponent) {
          if (stickyIndicesFromProps.has(0)) {
            stickyHeaderIndices.push(0);
          }

          var element = React.isValidElement(ListHeaderComponent) ? ListHeaderComponent : React.createElement(ListHeaderComponent, {
            __source: {
              fileName: _jsxFileName,
              lineNumber: 841
            }
          });
          cells.push(React.createElement(VirtualizedCellWrapper, {
            cellKey: this._getCellKey() + '-header',
            key: "$header",
            __source: {
              fileName: _jsxFileName,
              lineNumber: 844
            }
          }, React.createElement(View, {
            onLayout: this._onLayoutHeader,
            style: StyleSheet.compose(inversionStyle, this.props.ListHeaderComponentStyle),
            __source: {
              fileName: _jsxFileName,
              lineNumber: 847
            }
          }, element)));
        }

        var itemCount = this.props.getItemCount(data);

        if (itemCount > 0) {
          _usedIndexForKey = false;
          _keylessItemComponentName = '';
          var spacerKey = !horizontal ? 'height' : 'width';
          var lastInitialIndex = this.props.initialScrollIndex ? -1 : this.props.initialNumToRender - 1;
          var _this$state = this.state,
              first = _this$state.first,
              last = _this$state.last;

          this._pushCells(cells, stickyHeaderIndices, stickyIndicesFromProps, 0, lastInitialIndex, inversionStyle);

          var firstAfterInitial = Math.max(lastInitialIndex + 1, first);

          if (!isVirtualizationDisabled && first > lastInitialIndex + 1) {
            var insertedStickySpacer = false;

            if (stickyIndicesFromProps.size > 0) {
              var stickyOffset = ListHeaderComponent ? 1 : 0;

              for (var ii = firstAfterInitial - 1; ii > lastInitialIndex; ii--) {
                if (stickyIndicesFromProps.has(ii + stickyOffset)) {
                  var initBlock = this._getFrameMetricsApprox(lastInitialIndex);

                  var stickyBlock = this._getFrameMetricsApprox(ii);

                  var leadSpace = stickyBlock.offset - initBlock.offset - (this.props.initialScrollIndex ? 0 : initBlock.length);
                  cells.push(React.createElement(View, {
                    key: "$sticky_lead",
                    style: _defineProperty({}, spacerKey, leadSpace),
                    __source: {
                      fileName: _jsxFileName,
                      lineNumber: 893
                    }
                  }));

                  this._pushCells(cells, stickyHeaderIndices, stickyIndicesFromProps, ii, ii, inversionStyle);

                  var trailSpace = this._getFrameMetricsApprox(first).offset - (stickyBlock.offset + stickyBlock.length);
                  cells.push(React.createElement(View, {
                    key: "$sticky_trail",
                    style: _defineProperty({}, spacerKey, trailSpace),
                    __source: {
                      fileName: _jsxFileName,
                      lineNumber: 907
                    }
                  }));
                  insertedStickySpacer = true;
                  break;
                }
              }
            }

            if (!insertedStickySpacer) {
              var _initBlock = this._getFrameMetricsApprox(lastInitialIndex);

              var firstSpace = this._getFrameMetricsApprox(first).offset - (_initBlock.offset + _initBlock.length);

              cells.push(React.createElement(View, {
                key: "$lead_spacer",
                style: _defineProperty({}, spacerKey, firstSpace),
                __source: {
                  fileName: _jsxFileName,
                  lineNumber: 920
                }
              }));
            }
          }

          this._pushCells(cells, stickyHeaderIndices, stickyIndicesFromProps, firstAfterInitial, last, inversionStyle);

          if (!this._hasWarned.keys && _usedIndexForKey) {
            console.warn('VirtualizedList: missing keys for items, make sure to specify a key or id property on each ' + 'item or provide a custom keyExtractor.', _keylessItemComponentName);
            this._hasWarned.keys = true;
          }

          if (!isVirtualizationDisabled && last < itemCount - 1) {
            var lastFrame = this._getFrameMetricsApprox(last);

            var end = this.props.getItemLayout ? itemCount - 1 : Math.min(itemCount - 1, this._highestMeasuredFrameIndex);

            var endFrame = this._getFrameMetricsApprox(end);

            var tailSpacerLength = endFrame.offset + endFrame.length - (lastFrame.offset + lastFrame.length);
            cells.push(React.createElement(View, {
              key: "$tail_spacer",
              style: _defineProperty({}, spacerKey, tailSpacerLength),
              __source: {
                fileName: _jsxFileName,
                lineNumber: 954
              }
            }));
          }
        } else if (ListEmptyComponent) {
          var _element = React.isValidElement(ListEmptyComponent) ? ListEmptyComponent : React.createElement(ListEmptyComponent, {
            __source: {
              fileName: _jsxFileName,
              lineNumber: 964
            }
          });

          cells.push(React.cloneElement(_element, {
            key: '$empty',
            onLayout: function onLayout(event) {
              _this3._onLayoutEmpty(event);

              if (_element.props.onLayout) {
                _element.props.onLayout(event);
              }
            },
            style: StyleSheet.compose(inversionStyle, _element.props.style)
          }));
        }

        if (ListFooterComponent) {
          var _element2 = React.isValidElement(ListFooterComponent) ? ListFooterComponent : React.createElement(ListFooterComponent, {
            __source: {
              fileName: _jsxFileName,
              lineNumber: 987
            }
          });

          cells.push(React.createElement(VirtualizedCellWrapper, {
            cellKey: this._getCellKey() + '-footer',
            key: "$footer",
            __source: {
              fileName: _jsxFileName,
              lineNumber: 990
            }
          }, React.createElement(View, {
            onLayout: this._onLayoutFooter,
            style: StyleSheet.compose(inversionStyle, this.props.ListFooterComponentStyle),
            __source: {
              fileName: _jsxFileName,
              lineNumber: 993
            }
          }, _element2)));
        }

        var scrollProps = _objectSpread({}, this.props, {
          onContentSizeChange: this._onContentSizeChange,
          onLayout: this._onLayout,
          onScroll: this._onScroll,
          onScrollBeginDrag: this._onScrollBeginDrag,
          onScrollEndDrag: this._onScrollEndDrag,
          onMomentumScrollEnd: this._onMomentumScrollEnd,
          scrollEventThrottle: this.props.scrollEventThrottle,
          invertStickyHeaders: this.props.invertStickyHeaders !== undefined ? this.props.invertStickyHeaders : this.props.inverted,
          stickyHeaderIndices: stickyHeaderIndices
        });

        if (inversionStyle) {
          scrollProps.style = [inversionStyle, this.props.style];
        }

        this._hasMore = this.state.last < this.props.getItemCount(this.props.data) - 1;
        var innerRet = React.cloneElement((this.props.renderScrollComponent || this._defaultRenderScrollComponent)(scrollProps), {
          ref: this._captureScrollRef
        }, cells);
        var ret = innerRet;

        if (__DEV__) {
          ret = React.createElement(ScrollView.Context.Consumer, {
            __source: {
              fileName: _jsxFileName,
              lineNumber: 1044
            }
          }, function (scrollContext) {
            if (scrollContext != null && !scrollContext.horizontal === !_this3.props.horizontal && !_this3._hasWarned.nesting && _this3.context.virtualizedList == null) {
              console.warn('VirtualizedLists should never be nested inside plain ScrollViews with the same ' + 'orientation - use another VirtualizedList-backed container instead.');
              _this3._hasWarned.nesting = true;
            }

            return innerRet;
          });
        }

        if (this.props.debug) {
          return React.createElement(View, {
            style: styles.debug,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 1066
            }
          }, ret, this._renderDebugOverlay());
        } else {
          return ret;
        }
      }
    }, {
      key: "componentDidUpdate",
      value: function componentDidUpdate(prevProps) {
        var _this$props9 = this.props,
            data = _this$props9.data,
            extraData = _this$props9.extraData;

        if (data !== prevProps.data || extraData !== prevProps.extraData) {
          this._hasDataChangedSinceEndReached = true;

          this._viewabilityTuples.forEach(function (tuple) {
            tuple.viewabilityHelper.resetViewableIndices();
          });
        }

        var hiPriInProgress = this._hiPriInProgress;

        this._scheduleCellsToRenderUpdate();

        if (hiPriInProgress) {
          this._hiPriInProgress = false;
        }
      }
    }, {
      key: "_computeBlankness",
      value: function _computeBlankness() {
        this._fillRateHelper.computeBlankness(this.props, this.state, this._scrollMetrics);
      }
    }, {
      key: "_onCellLayout",
      value: function _onCellLayout(e, cellKey, index) {
        var layout = e.nativeEvent.layout;
        var next = {
          offset: this._selectOffset(layout),
          length: this._selectLength(layout),
          index: index,
          inLayout: true
        };
        var curr = this._frames[cellKey];

        if (!curr || next.offset !== curr.offset || next.length !== curr.length || index !== curr.index) {
          this._totalCellLength += next.length - (curr ? curr.length : 0);
          this._totalCellsMeasured += curr ? 0 : 1;
          this._averageCellLength = this._totalCellLength / this._totalCellsMeasured;
          this._frames[cellKey] = next;
          this._highestMeasuredFrameIndex = Math.max(this._highestMeasuredFrameIndex, index);

          this._scheduleCellsToRenderUpdate();
        } else {
          this._frames[cellKey].inLayout = true;
        }

        var childListKeys = this._cellKeysToChildListKeys.get(cellKey);

        if (childListKeys) {
          for (var _iterator2 = childListKeys, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"]();;) {
            var _ref7;

            if (_isArray2) {
              if (_i2 >= _iterator2.length) break;
              _ref7 = _iterator2[_i2++];
            } else {
              _i2 = _iterator2.next();
              if (_i2.done) break;
              _ref7 = _i2.value;
            }

            var _childKey2 = _ref7;

            var _childList2 = this._nestedChildLists.get(_childKey2);

            _childList2 && _childList2.ref && _childList2.ref.measureLayoutRelativeToContainingList();
          }
        }

        this._computeBlankness();

        this._updateViewableItems(this.props.data);
      }
    }, {
      key: "measureLayoutRelativeToContainingList",
      value: function measureLayoutRelativeToContainingList() {
        var _this4 = this;

        try {
          if (!this._scrollRef) {
            return;
          }

          this._scrollRef.measureLayout(this.context.virtualizedList.getOutermostParentListRef().getScrollRef().getNativeScrollRef(), function (x, y, width, height) {
            _this4._offsetFromParentVirtualizedList = _this4._selectOffset({
              x: x,
              y: y
            });
            _this4._scrollMetrics.contentLength = _this4._selectLength({
              width: width,
              height: height
            });

            var scrollMetrics = _this4._convertParentScrollMetrics(_this4.context.virtualizedList.getScrollMetrics());

            _this4._scrollMetrics.visibleLength = scrollMetrics.visibleLength;
            _this4._scrollMetrics.offset = scrollMetrics.offset;
          }, function (error) {
            console.warn("VirtualizedList: Encountered an error while measuring a list's" + ' offset from its containing VirtualizedList.');
          });
        } catch (error) {
          console.warn('measureLayoutRelativeToContainingList threw an error', error.stack);
        }
      }
    }, {
      key: "_renderDebugOverlay",
      value: function _renderDebugOverlay() {
        var normalize = this._scrollMetrics.visibleLength / (this._scrollMetrics.contentLength || 1);
        var framesInLayout = [];
        var itemCount = this.props.getItemCount(this.props.data);

        for (var ii = 0; ii < itemCount; ii++) {
          var frame = this._getFrameMetricsApprox(ii);

          if (frame.inLayout) {
            framesInLayout.push(frame);
          }
        }

        var windowTop = this._getFrameMetricsApprox(this.state.first).offset;

        var frameLast = this._getFrameMetricsApprox(this.state.last);

        var windowLen = frameLast.offset + frameLast.length - windowTop;
        var visTop = this._scrollMetrics.offset;
        var visLen = this._scrollMetrics.visibleLength;
        return React.createElement(View, {
          style: [styles.debugOverlayBase, styles.debugOverlay],
          __source: {
            fileName: _jsxFileName,
            lineNumber: 1327
          }
        }, framesInLayout.map(function (f, ii) {
          return React.createElement(View, {
            key: 'f' + ii,
            style: [styles.debugOverlayBase, styles.debugOverlayFrame, {
              top: f.offset * normalize,
              height: f.length * normalize
            }],
            __source: {
              fileName: _jsxFileName,
              lineNumber: 1329
            }
          });
        }), React.createElement(View, {
          style: [styles.debugOverlayBase, styles.debugOverlayFrameLast, {
            top: windowTop * normalize,
            height: windowLen * normalize
          }],
          __source: {
            fileName: _jsxFileName,
            lineNumber: 1341
          }
        }), React.createElement(View, {
          style: [styles.debugOverlayBase, styles.debugOverlayFrameVis, {
            top: visTop * normalize,
            height: visLen * normalize
          }],
          __source: {
            fileName: _jsxFileName,
            lineNumber: 1351
          }
        }));
      }
    }, {
      key: "_selectLength",
      value: function _selectLength(metrics) {
        return !this.props.horizontal ? metrics.height : metrics.width;
      }
    }, {
      key: "_selectOffset",
      value: function _selectOffset(metrics) {
        return !this.props.horizontal ? metrics.y : metrics.x;
      }
    }, {
      key: "_maybeCallOnEndReached",
      value: function _maybeCallOnEndReached() {
        var _this$props10 = this.props,
            data = _this$props10.data,
            getItemCount = _this$props10.getItemCount,
            onEndReached = _this$props10.onEndReached,
            onEndReachedThreshold = _this$props10.onEndReachedThreshold;
        var _this$_scrollMetrics2 = this._scrollMetrics,
            contentLength = _this$_scrollMetrics2.contentLength,
            visibleLength = _this$_scrollMetrics2.visibleLength,
            offset = _this$_scrollMetrics2.offset;
        var distanceFromEnd = contentLength - visibleLength - offset;

        if (onEndReached && this.state.last === getItemCount(data) - 1 && distanceFromEnd < onEndReachedThreshold * visibleLength && (this._hasDataChangedSinceEndReached || this._scrollMetrics.contentLength !== this._sentEndForContentLength)) {
          this._hasDataChangedSinceEndReached = false;
          this._sentEndForContentLength = this._scrollMetrics.contentLength;
          onEndReached({
            distanceFromEnd: distanceFromEnd
          });
        }
      }
    }, {
      key: "_scheduleCellsToRenderUpdate",
      value: function _scheduleCellsToRenderUpdate() {
        var _this$state2 = this.state,
            first = _this$state2.first,
            last = _this$state2.last;
        var _this$_scrollMetrics3 = this._scrollMetrics,
            offset = _this$_scrollMetrics3.offset,
            visibleLength = _this$_scrollMetrics3.visibleLength,
            velocity = _this$_scrollMetrics3.velocity;
        var itemCount = this.props.getItemCount(this.props.data);
        var hiPri = false;
        var scrollingThreshold = this.props.onEndReachedThreshold * visibleLength / 2;

        if (first > 0) {
          var distTop = offset - this._getFrameMetricsApprox(first).offset;

          hiPri = hiPri || distTop < 0 || velocity < -2 && distTop < scrollingThreshold;
        }

        if (last < itemCount - 1) {
          var distBottom = this._getFrameMetricsApprox(last).offset - (offset + visibleLength);
          hiPri = hiPri || distBottom < 0 || velocity > 2 && distBottom < scrollingThreshold;
        }

        if (hiPri && (this._averageCellLength || this.props.getItemLayout) && !this._hiPriInProgress) {
          this._hiPriInProgress = true;

          this._updateCellsToRenderBatcher.dispose({
            abort: true
          });

          this._updateCellsToRender();

          return;
        } else {
          this._updateCellsToRenderBatcher.schedule();
        }
      }
    }, {
      key: "_updateViewableItems",
      value: function _updateViewableItems(data) {
        var _this5 = this;

        var getItemCount = this.props.getItemCount;

        this._viewabilityTuples.forEach(function (tuple) {
          tuple.viewabilityHelper.onUpdate(getItemCount(data), _this5._scrollMetrics.offset, _this5._scrollMetrics.visibleLength, _this5._getFrameMetrics, _this5._createViewToken, tuple.onViewableItemsChanged, _this5.state);
        });
      }
    }], [{
      key: "getDerivedStateFromProps",
      value: function getDerivedStateFromProps(newProps, prevState) {
        var data = newProps.data,
            getItemCount = newProps.getItemCount,
            maxToRenderPerBatch = newProps.maxToRenderPerBatch;
        return {
          first: Math.max(0, Math.min(prevState.first, getItemCount(data) - 1 - maxToRenderPerBatch)),
          last: Math.max(0, Math.min(prevState.last, getItemCount(data) - 1))
        };
      }
    }]);

    return VirtualizedList;
  }(React.PureComponent);

  VirtualizedList.defaultProps = {
    disableVirtualization: false,
    horizontal: false,
    initialNumToRender: 10,
    keyExtractor: function keyExtractor(item, index) {
      if (item.key != null) {
        return item.key;
      }

      if (item.id != null) {
        return item.id;
      }

      _usedIndexForKey = true;

      if (item.type && item.type.displayName) {
        _keylessItemComponentName = item.type.displayName;
      }

      return String(index);
    },
    maxToRenderPerBatch: 10,
    onEndReachedThreshold: 2,
    scrollEventThrottle: 50,
    updateCellsBatchingPeriod: 50,
    windowSize: 21
  };
  VirtualizedList.contextTypes = {
    virtualizedCell: PropTypes.shape({
      cellKey: PropTypes.string
    }),
    virtualizedList: PropTypes.shape({
      getScrollMetrics: PropTypes.func,
      horizontal: PropTypes.bool,
      getOutermostParentListRef: PropTypes.func,
      getNestedChildState: PropTypes.func,
      registerAsNestedChild: PropTypes.func,
      unregisterAsNestedChild: PropTypes.func
    })
  };
  VirtualizedList.childContextTypes = {
    virtualizedList: PropTypes.shape({
      getScrollMetrics: PropTypes.func,
      horizontal: PropTypes.bool,
      getOutermostParentListRef: PropTypes.func,
      getNestedChildState: PropTypes.func,
      registerAsNestedChild: PropTypes.func,
      unregisterAsNestedChild: PropTypes.func
    })
  };

  var CellRenderer = function (_React$Component) {
    _inherits(CellRenderer, _React$Component);

    function CellRenderer() {
      var _getPrototypeOf2;

      var _this6;

      _classCallCheck(this, CellRenderer);

      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
        args[_key] = arguments[_key];
      }

      _this6 = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(CellRenderer)).call.apply(_getPrototypeOf2, [this].concat(args)));
      _this6.state = {
        separatorProps: {
          highlighted: false,
          leadingItem: _this6.props.item
        }
      };
      _this6._separators = {
        highlight: function highlight() {
          var _this6$props = _this6.props,
              cellKey = _this6$props.cellKey,
              prevCellKey = _this6$props.prevCellKey;

          _this6.props.onUpdateSeparators([cellKey, prevCellKey], {
            highlighted: true
          });
        },
        unhighlight: function unhighlight() {
          var _this6$props2 = _this6.props,
              cellKey = _this6$props2.cellKey,
              prevCellKey = _this6$props2.prevCellKey;

          _this6.props.onUpdateSeparators([cellKey, prevCellKey], {
            highlighted: false
          });
        },
        updateProps: function updateProps(select, newProps) {
          var _this6$props3 = _this6.props,
              cellKey = _this6$props3.cellKey,
              prevCellKey = _this6$props3.prevCellKey;

          _this6.props.onUpdateSeparators([select === 'leading' ? prevCellKey : cellKey], newProps);
        }
      };
      return _this6;
    }

    _createClass(CellRenderer, [{
      key: "getChildContext",
      value: function getChildContext() {
        return {
          virtualizedCell: {
            cellKey: this.props.cellKey
          }
        };
      }
    }, {
      key: "updateSeparatorProps",
      value: function updateSeparatorProps(newProps) {
        this.setState(function (state) {
          return {
            separatorProps: _objectSpread({}, state.separatorProps, {}, newProps)
          };
        });
      }
    }, {
      key: "componentWillUnmount",
      value: function componentWillUnmount() {
        this.props.onUnmount(this.props.cellKey);
      }
    }, {
      key: "_renderElement",
      value: function _renderElement(renderItem, ListItemComponent, item, index) {
        if (renderItem && ListItemComponent) {
          console.warn('VirtualizedList: Both ListItemComponent and renderItem props are present. ListItemComponent will take' + ' precedence over renderItem.');
        }

        if (ListItemComponent) {
          return React.createElement(ListItemComponent, {
            item: item,
            index: index,
            separators: this._separators
          });
        }

        if (renderItem) {
          return renderItem({
            item: item,
            index: index,
            separators: this._separators
          });
        }

        invariant(false, 'VirtualizedList: Either ListItemComponent or renderItem props are required but none were found.');
      }
    }, {
      key: "render",
      value: function render() {
        var _this$props11 = this.props,
            CellRendererComponent = _this$props11.CellRendererComponent,
            ItemSeparatorComponent = _this$props11.ItemSeparatorComponent,
            fillRateHelper = _this$props11.fillRateHelper,
            horizontal = _this$props11.horizontal,
            item = _this$props11.item,
            index = _this$props11.index,
            inversionStyle = _this$props11.inversionStyle,
            parentProps = _this$props11.parentProps;
        var renderItem = parentProps.renderItem,
            getItemLayout = parentProps.getItemLayout,
            ListItemComponent = parentProps.ListItemComponent;

        var element = this._renderElement(renderItem, ListItemComponent, item, index);

        var onLayout = getItemLayout && !parentProps.debug && !fillRateHelper.enabled() ? undefined : this.props.onLayout;
        var itemSeparator = ItemSeparatorComponent && React.createElement(ItemSeparatorComponent, _extends({}, this.state.separatorProps, {
          __source: {
            fileName: _jsxFileName,
            lineNumber: 1911
          }
        }));
        var cellStyle = inversionStyle ? horizontal ? [styles.rowReverse, inversionStyle] : [styles.columnReverse, inversionStyle] : horizontal ? [styles.row, inversionStyle] : inversionStyle;

        if (!CellRendererComponent) {
          return React.createElement(View, {
            style: cellStyle,
            onLayout: onLayout,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 1925
            }
          }, element, itemSeparator);
        }

        return React.createElement(CellRendererComponent, _extends({}, this.props, {
          style: cellStyle,
          onLayout: onLayout,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 1932
          }
        }), element, itemSeparator);
      }
    }], [{
      key: "getDerivedStateFromProps",
      value: function getDerivedStateFromProps(props, prevState) {
        return {
          separatorProps: _objectSpread({}, prevState.separatorProps, {
            leadingItem: props.item
          })
        };
      }
    }]);

    return CellRenderer;
  }(React.Component);

  CellRenderer.childContextTypes = {
    virtualizedCell: PropTypes.shape({
      cellKey: PropTypes.string
    })
  };

  var VirtualizedCellWrapper = function (_React$Component2) {
    _inherits(VirtualizedCellWrapper, _React$Component2);

    function VirtualizedCellWrapper() {
      _classCallCheck(this, VirtualizedCellWrapper);

      return _possibleConstructorReturn(this, _getPrototypeOf(VirtualizedCellWrapper).apply(this, arguments));
    }

    _createClass(VirtualizedCellWrapper, [{
      key: "getChildContext",
      value: function getChildContext() {
        return {
          virtualizedCell: {
            cellKey: this.props.cellKey
          }
        };
      }
    }, {
      key: "render",
      value: function render() {
        return this.props.children;
      }
    }]);

    return VirtualizedCellWrapper;
  }(React.Component);

  VirtualizedCellWrapper.childContextTypes = {
    virtualizedCell: PropTypes.shape({
      cellKey: PropTypes.string
    })
  };
  var styles = StyleSheet.create({
    verticallyInverted: {
      transform: [{
        scaleY: -1
      }]
    },
    horizontallyInverted: {
      transform: [{
        scaleX: -1
      }]
    },
    row: {
      flexDirection: 'row'
    },
    rowReverse: {
      flexDirection: 'row-reverse'
    },
    columnReverse: {
      flexDirection: 'column-reverse'
    },
    debug: {
      flex: 1
    },
    debugOverlayBase: {
      position: 'absolute',
      top: 0,
      right: 0
    },
    debugOverlay: {
      bottom: 0,
      width: 20,
      borderColor: 'blue',
      borderWidth: 1
    },
    debugOverlayFrame: {
      left: 0,
      backgroundColor: 'orange'
    },
    debugOverlayFrameLast: {
      left: 0,
      borderColor: 'green',
      borderWidth: 2
    },
    debugOverlayFrameVis: {
      left: 0,
      borderColor: 'red',
      borderWidth: 2
    }
  });
  module.exports = VirtualizedList;
},294,[13,46,24,32,34,33,25,37,295,296,69,54,88,297,300,60,86,311,85,161,3,5,312],"node_modules/react-native/Libraries/Lists/VirtualizedList.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");

  var InteractionManager = _$$_REQUIRE(_dependencyMap[2], "./InteractionManager");

  var Batchinator = function () {
    function Batchinator(callback, delayMS) {
      _classCallCheck(this, Batchinator);

      this._delay = delayMS;
      this._callback = callback;
    }

    _createClass(Batchinator, [{
      key: "dispose",
      value: function dispose() {
        var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
          abort: false
        };

        if (this._taskHandle) {
          this._taskHandle.cancel();

          if (!options.abort) {
            this._callback();
          }

          this._taskHandle = null;
        }
      }
    }, {
      key: "schedule",
      value: function schedule() {
        var _this = this;

        if (this._taskHandle) {
          return;
        }

        var timeoutHandle = setTimeout(function () {
          _this._taskHandle = InteractionManager.runAfterInteractions(function () {
            _this._taskHandle = null;

            _this._callback();
          });
        }, this._delay);
        this._taskHandle = {
          cancel: function cancel() {
            return clearTimeout(timeoutHandle);
          }
        };
      }
    }]);

    return Batchinator;
  }();

  module.exports = Batchinator;
},295,[24,25,270],"node_modules/react-native/Libraries/Interaction/Batchinator.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");

  var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck");

  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

  var performanceNow = _$$_REQUIRE(_dependencyMap[3], "fbjs/lib/performanceNow");

  var warning = _$$_REQUIRE(_dependencyMap[4], "fbjs/lib/warning");

  var Info = function Info() {
    _classCallCheck(this, Info);

    this.any_blank_count = 0;
    this.any_blank_ms = 0;
    this.any_blank_speed_sum = 0;
    this.mostly_blank_count = 0;
    this.mostly_blank_ms = 0;
    this.pixels_blank = 0;
    this.pixels_sampled = 0;
    this.pixels_scrolled = 0;
    this.total_time_spent = 0;
    this.sample_count = 0;
  };

  var DEBUG = false;
  var _listeners = [];
  var _minSampleCount = 10;

  var _sampleRate = DEBUG ? 1 : null;

  var FillRateHelper = function () {
    _createClass(FillRateHelper, null, [{
      key: "addListener",
      value: function addListener(callback) {
        warning(_sampleRate !== null, 'Call `FillRateHelper.setSampleRate` before `addListener`.');

        _listeners.push(callback);

        return {
          remove: function remove() {
            _listeners = _listeners.filter(function (listener) {
              return callback !== listener;
            });
          }
        };
      }
    }, {
      key: "setSampleRate",
      value: function setSampleRate(sampleRate) {
        _sampleRate = sampleRate;
      }
    }, {
      key: "setMinSampleCount",
      value: function setMinSampleCount(minSampleCount) {
        _minSampleCount = minSampleCount;
      }
    }]);

    function FillRateHelper(getFrameMetrics) {
      _classCallCheck(this, FillRateHelper);

      this._anyBlankStartTime = null;
      this._enabled = false;
      this._info = new Info();
      this._mostlyBlankStartTime = null;
      this._samplesStartTime = null;
      this._getFrameMetrics = getFrameMetrics;
      this._enabled = (_sampleRate || 0) > Math.random();

      this._resetData();
    }

    _createClass(FillRateHelper, [{
      key: "activate",
      value: function activate() {
        if (this._enabled && this._samplesStartTime == null) {
          DEBUG && console.debug('FillRateHelper: activate');
          this._samplesStartTime = performanceNow();
        }
      }
    }, {
      key: "deactivateAndFlush",
      value: function deactivateAndFlush() {
        if (!this._enabled) {
          return;
        }

        var start = this._samplesStartTime;

        if (start == null) {
          DEBUG && console.debug('FillRateHelper: bail on deactivate with no start time');
          return;
        }

        if (this._info.sample_count < _minSampleCount) {
          this._resetData();

          return;
        }

        var total_time_spent = performanceNow() - start;

        var info = _objectSpread({}, this._info, {
          total_time_spent: total_time_spent
        });

        if (DEBUG) {
          var derived = {
            avg_blankness: this._info.pixels_blank / this._info.pixels_sampled,
            avg_speed: this._info.pixels_scrolled / (total_time_spent / 1000),
            avg_speed_when_any_blank: this._info.any_blank_speed_sum / this._info.any_blank_count,
            any_blank_per_min: this._info.any_blank_count / (total_time_spent / 1000 / 60),
            any_blank_time_frac: this._info.any_blank_ms / total_time_spent,
            mostly_blank_per_min: this._info.mostly_blank_count / (total_time_spent / 1000 / 60),
            mostly_blank_time_frac: this._info.mostly_blank_ms / total_time_spent
          };

          for (var key in derived) {
            derived[key] = Math.round(1000 * derived[key]) / 1000;
          }

          console.debug('FillRateHelper deactivateAndFlush: ', {
            derived: derived,
            info: info
          });
        }

        _listeners.forEach(function (listener) {
          return listener(info);
        });

        this._resetData();
      }
    }, {
      key: "computeBlankness",
      value: function computeBlankness(props, state, scrollMetrics) {
        if (!this._enabled || props.getItemCount(props.data) === 0 || this._samplesStartTime == null) {
          return 0;
        }

        var dOffset = scrollMetrics.dOffset,
            offset = scrollMetrics.offset,
            velocity = scrollMetrics.velocity,
            visibleLength = scrollMetrics.visibleLength;
        this._info.sample_count++;
        this._info.pixels_sampled += Math.round(visibleLength);
        this._info.pixels_scrolled += Math.round(Math.abs(dOffset));
        var scrollSpeed = Math.round(Math.abs(velocity) * 1000);
        var now = performanceNow();

        if (this._anyBlankStartTime != null) {
          this._info.any_blank_ms += now - this._anyBlankStartTime;
        }

        this._anyBlankStartTime = null;

        if (this._mostlyBlankStartTime != null) {
          this._info.mostly_blank_ms += now - this._mostlyBlankStartTime;
        }

        this._mostlyBlankStartTime = null;
        var blankTop = 0;
        var first = state.first;

        var firstFrame = this._getFrameMetrics(first);

        while (first <= state.last && (!firstFrame || !firstFrame.inLayout)) {
          firstFrame = this._getFrameMetrics(first);
          first++;
        }

        if (firstFrame && first > 0) {
          blankTop = Math.min(visibleLength, Math.max(0, firstFrame.offset - offset));
        }

        var blankBottom = 0;
        var last = state.last;

        var lastFrame = this._getFrameMetrics(last);

        while (last >= state.first && (!lastFrame || !lastFrame.inLayout)) {
          lastFrame = this._getFrameMetrics(last);
          last--;
        }

        if (lastFrame && last < props.getItemCount(props.data) - 1) {
          var bottomEdge = lastFrame.offset + lastFrame.length;
          blankBottom = Math.min(visibleLength, Math.max(0, offset + visibleLength - bottomEdge));
        }

        var pixels_blank = Math.round(blankTop + blankBottom);
        var blankness = pixels_blank / visibleLength;

        if (blankness > 0) {
          this._anyBlankStartTime = now;
          this._info.any_blank_speed_sum += scrollSpeed;
          this._info.any_blank_count++;
          this._info.pixels_blank += pixels_blank;

          if (blankness > 0.5) {
            this._mostlyBlankStartTime = now;
            this._info.mostly_blank_count++;
          }
        } else if (scrollSpeed < 0.01 || Math.abs(dOffset) < 1) {
          this.deactivateAndFlush();
        }

        return blankness;
      }
    }, {
      key: "enabled",
      value: function enabled() {
        return this._enabled;
      }
    }, {
      key: "_resetData",
      value: function _resetData() {
        this._anyBlankStartTime = null;
        this._info = new Info();
        this._mostlyBlankStartTime = null;
        this._samplesStartTime = null;
      }
    }]);

    return FillRateHelper;
  }();

  module.exports = FillRateHelper;
},296,[46,25,24,122,5],"node_modules/react-native/Libraries/Lists/FillRateHelper.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _extends2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/extends"));

  var _objectWithoutProperties2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/objectWithoutProperties"));

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf3 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "@babel/runtime/helpers/inherits"));

  var _AndroidSwipeRefreshLayoutNativeComponent = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "./AndroidSwipeRefreshLayoutNativeComponent"));

  var _PullToRefreshViewNativeComponent = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "./PullToRefreshViewNativeComponent"));

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native/Libraries/Components/RefreshControl/RefreshControl.js";

  var Platform = _$$_REQUIRE(_dependencyMap[10], "../../Utilities/Platform");

  var React = _$$_REQUIRE(_dependencyMap[11], "react");

  var nullthrows = _$$_REQUIRE(_dependencyMap[12], "nullthrows");

  var RefreshLayoutConsts;

  if ("android" === 'android') {
    var AndroidSwipeRefreshLayout = _$$_REQUIRE(_dependencyMap[13], "../../ReactNative/UIManager").getViewManagerConfig('AndroidSwipeRefreshLayout');

    RefreshLayoutConsts = AndroidSwipeRefreshLayout ? AndroidSwipeRefreshLayout.Constants : {
      SIZE: {}
    };
  } else {
    RefreshLayoutConsts = {
      SIZE: {}
    };
  }

  var RefreshControl = function (_React$Component) {
    (0, _inherits2.default)(RefreshControl, _React$Component);

    function RefreshControl() {
      var _getPrototypeOf2;

      var _this;

      (0, _classCallCheck2.default)(this, RefreshControl);

      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
        args[_key] = arguments[_key];
      }

      _this = (0, _possibleConstructorReturn2.default)(this, (_getPrototypeOf2 = (0, _getPrototypeOf3.default)(RefreshControl)).call.apply(_getPrototypeOf2, [this].concat(args)));
      _this._lastNativeRefreshing = false;

      _this._onRefresh = function () {
        _this._lastNativeRefreshing = true;
        _this.props.onRefresh && _this.props.onRefresh();

        _this.forceUpdate();
      };

      return _this;
    }

    (0, _createClass2.default)(RefreshControl, [{
      key: "componentDidMount",
      value: function componentDidMount() {
        this._lastNativeRefreshing = this.props.refreshing;
      }
    }, {
      key: "componentDidUpdate",
      value: function componentDidUpdate(prevProps) {
        if (this.props.refreshing !== prevProps.refreshing) {
          this._lastNativeRefreshing = this.props.refreshing;
        } else if (this.props.refreshing !== this._lastNativeRefreshing && this._setNativePropsOnRef) {
          this._setNativePropsOnRef({
            refreshing: this.props.refreshing
          });

          this._lastNativeRefreshing = this.props.refreshing;
        }
      }
    }, {
      key: "render",
      value: function render() {
        var _this2 = this;

        var setRef = function setRef(ref) {
          return _this2._setNativePropsOnRef = ref ? ref.setNativeProps.bind(ref) : null;
        };

        if ("android" === 'ios') {
          var _this$props = this.props,
              enabled = _this$props.enabled,
              colors = _this$props.colors,
              progressBackgroundColor = _this$props.progressBackgroundColor,
              size = _this$props.size,
              progressViewOffset = _this$props.progressViewOffset,
              props = (0, _objectWithoutProperties2.default)(_this$props, ["enabled", "colors", "progressBackgroundColor", "size", "progressViewOffset"]);
          return React.createElement(_PullToRefreshViewNativeComponent.default, (0, _extends2.default)({}, props, {
            ref: setRef,
            onRefresh: this._onRefresh,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 177
            }
          }));
        } else {
          var _this$props2 = this.props,
              tintColor = _this$props2.tintColor,
              titleColor = _this$props2.titleColor,
              title = _this$props2.title,
              _props = (0, _objectWithoutProperties2.default)(_this$props2, ["tintColor", "titleColor", "title"]);

          return React.createElement(_AndroidSwipeRefreshLayoutNativeComponent.default, (0, _extends2.default)({}, _props, {
            ref: setRef,
            onRefresh: this._onRefresh,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 186
            }
          }));
        }
      }
    }]);
    return RefreshControl;
  }(React.Component);

  RefreshControl.SIZE = RefreshLayoutConsts.SIZE;
  module.exports = RefreshControl;
},297,[1,13,52,24,25,32,34,37,298,299,48,54,249,43],"node_modules/react-native/Libraries/Components/RefreshControl/RefreshControl.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _codegenNativeComponent = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../../Utilities/codegenNativeComponent"));

  var _default = (0, _codegenNativeComponent.default)('AndroidSwipeRefreshLayout');

  exports.default = _default;
},298,[1,222],"node_modules/react-native/Libraries/Components/RefreshControl/AndroidSwipeRefreshLayoutNativeComponent.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _codegenNativeComponent = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../../Utilities/codegenNativeComponent"));

  var _default = (0, _codegenNativeComponent.default)('PullToRefreshView', {
    paperComponentName: 'RCTRefreshControl'
  });

  exports.default = _default;
},299,[1,222],"node_modules/react-native/Libraries/Components/RefreshControl/PullToRefreshViewNativeComponent.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass");

  var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn");

  var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf");

  var _assertThisInitialized = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/assertThisInitialized");

  var _inherits = _$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits");

  var _defineProperty = _$$_REQUIRE(_dependencyMap[7], "@babel/runtime/helpers/defineProperty");

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native/Libraries/Components/ScrollView/ScrollView.js";

  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

  var AnimatedImplementation = _$$_REQUIRE(_dependencyMap[8], "../../Animated/src/AnimatedImplementation");

  var Platform = _$$_REQUIRE(_dependencyMap[9], "../../Utilities/Platform");

  var React = _$$_REQUIRE(_dependencyMap[10], "react");

  var ReactNative = _$$_REQUIRE(_dependencyMap[11], "../../Renderer/shims/ReactNative");

  var ScrollResponder = _$$_REQUIRE(_dependencyMap[12], "../ScrollResponder");

  var ScrollViewStickyHeader = _$$_REQUIRE(_dependencyMap[13], "./ScrollViewStickyHeader");

  var StyleSheet = _$$_REQUIRE(_dependencyMap[14], "../../StyleSheet/StyleSheet");

  var View = _$$_REQUIRE(_dependencyMap[15], "../View/View");

  var dismissKeyboard = _$$_REQUIRE(_dependencyMap[16], "../../Utilities/dismissKeyboard");

  var flattenStyle = _$$_REQUIRE(_dependencyMap[17], "../../StyleSheet/flattenStyle");

  var invariant = _$$_REQUIRE(_dependencyMap[18], "invariant");

  var processDecelerationRate = _$$_REQUIRE(_dependencyMap[19], "./processDecelerationRate");

  var requireNativeComponent = _$$_REQUIRE(_dependencyMap[20], "../../ReactNative/requireNativeComponent");

  var resolveAssetSource = _$$_REQUIRE(_dependencyMap[21], "../../Image/resolveAssetSource");

  var splitLayoutProps = _$$_REQUIRE(_dependencyMap[22], "../../StyleSheet/splitLayoutProps");

  var AndroidScrollView;
  var AndroidHorizontalScrollContentView;
  var AndroidHorizontalScrollView;
  var RCTScrollView;
  var RCTScrollContentView;

  if ("android" === 'android') {
    AndroidScrollView = requireNativeComponent('RCTScrollView');
    AndroidHorizontalScrollView = requireNativeComponent('AndroidHorizontalScrollView');
    AndroidHorizontalScrollContentView = requireNativeComponent('AndroidHorizontalScrollContentView');
  } else if ("android" === 'ios') {
    RCTScrollView = requireNativeComponent('RCTScrollView');
    RCTScrollContentView = requireNativeComponent('RCTScrollContentView');
  } else {
    RCTScrollView = requireNativeComponent('RCTScrollView');
    RCTScrollContentView = requireNativeComponent('RCTScrollContentView');
  }

  function createScrollResponder(node) {
    var scrollResponder = _objectSpread({}, ScrollResponder.Mixin);

    for (var _key in scrollResponder) {
      if (typeof scrollResponder[_key] === 'function') {
        scrollResponder[_key] = scrollResponder[_key].bind(node);
      }
    }

    return scrollResponder;
  }

  var Context = React.createContext(null);
  var standardHorizontalContext = Object.freeze({
    horizontal: true
  });
  var standardVerticalContext = Object.freeze({
    horizontal: false
  });

  var ScrollView = function (_React$Component) {
    _inherits(ScrollView, _React$Component);

    function ScrollView(props) {
      var _this;

      _classCallCheck(this, ScrollView);

      _this = _possibleConstructorReturn(this, _getPrototypeOf(ScrollView).call(this, props));
      _this._scrollResponder = createScrollResponder(_assertThisInitialized(_this));
      _this._scrollAnimatedValue = new AnimatedImplementation.Value(0);
      _this._scrollAnimatedValueAttachment = null;
      _this._stickyHeaderRefs = new Map();
      _this._headerLayoutYs = new Map();
      _this.state = _objectSpread({
        layoutHeight: null
      }, ScrollResponder.Mixin.scrollResponderMixinGetInitialState());

      _this._handleScroll = function (e) {
        if (__DEV__) {
          if (_this.props.onScroll && _this.props.scrollEventThrottle == null && "android" === 'ios') {
            console.log('You specified `onScroll` on a <ScrollView> but not ' + '`scrollEventThrottle`. You will only receive one event. ' + 'Using `16` you get all the events but be aware that it may ' + "cause frame drops, use a bigger number if you don't need as " + 'much precision.');
          }
        }

        if ("android" === 'android') {
          if (_this.props.keyboardDismissMode === 'on-drag' && _this.state.isTouching) {
            dismissKeyboard();
          }
        }

        _this._scrollResponder.scrollResponderHandleScroll(e);
      };

      _this._handleLayout = function (e) {
        if (_this.props.invertStickyHeaders === true) {
          _this.setState({
            layoutHeight: e.nativeEvent.layout.height
          });
        }

        if (_this.props.onLayout) {
          _this.props.onLayout(e);
        }
      };

      _this._handleContentOnLayout = function (e) {
        var _e$nativeEvent$layout = e.nativeEvent.layout,
            width = _e$nativeEvent$layout.width,
            height = _e$nativeEvent$layout.height;
        _this.props.onContentSizeChange && _this.props.onContentSizeChange(width, height);
      };

      _this._scrollViewRef = null;

      _this._setScrollViewRef = function (ref) {
        _this._scrollViewRef = ref;
      };

      _this._innerViewRef = null;

      _this._setInnerViewRef = function (ref) {
        _this._innerViewRef = ref;
      };

      for (var _key2 in ScrollResponder.Mixin) {
        if (typeof ScrollResponder.Mixin[_key2] === 'function' && _key2.startsWith('scrollResponder')) {
          _assertThisInitialized(_this)[_key2] = ScrollResponder.Mixin[_key2].bind(_assertThisInitialized(_this));
        }
      }

      Object.keys(ScrollResponder.Mixin).filter(function (key) {
        return typeof ScrollResponder.Mixin[key] !== 'function';
      }).forEach(function (key) {
        _assertThisInitialized(_this)[key] = ScrollResponder.Mixin[key];
      });
      return _this;
    }

    _createClass(ScrollView, [{
      key: "UNSAFE_componentWillMount",
      value: function UNSAFE_componentWillMount() {
        this._scrollResponder.UNSAFE_componentWillMount();

        this._scrollAnimatedValue = new AnimatedImplementation.Value(this.props.contentOffset ? this.props.contentOffset.y : 0);

        this._scrollAnimatedValue.setOffset(this.props.contentInset ? this.props.contentInset.top || 0 : 0);

        this._stickyHeaderRefs = new Map();
        this._headerLayoutYs = new Map();
      }
    }, {
      key: "UNSAFE_componentWillReceiveProps",
      value: function UNSAFE_componentWillReceiveProps(nextProps) {
        var currentContentInsetTop = this.props.contentInset ? this.props.contentInset.top : 0;
        var nextContentInsetTop = nextProps.contentInset ? nextProps.contentInset.top : 0;

        if (currentContentInsetTop !== nextContentInsetTop) {
          this._scrollAnimatedValue.setOffset(nextContentInsetTop || 0);
        }
      }
    }, {
      key: "componentDidMount",
      value: function componentDidMount() {
        this._updateAnimatedNodeAttachment();
      }
    }, {
      key: "componentDidUpdate",
      value: function componentDidUpdate() {
        this._updateAnimatedNodeAttachment();
      }
    }, {
      key: "componentWillUnmount",
      value: function componentWillUnmount() {
        this._scrollResponder.componentWillUnmount();

        if (this._scrollAnimatedValueAttachment) {
          this._scrollAnimatedValueAttachment.detach();
        }
      }
    }, {
      key: "setNativeProps",
      value: function setNativeProps(props) {
        this._scrollViewRef && this._scrollViewRef.setNativeProps(props);
      }
    }, {
      key: "getScrollResponder",
      value: function getScrollResponder() {
        return this;
      }
    }, {
      key: "getScrollableNode",
      value: function getScrollableNode() {
        return ReactNative.findNodeHandle(this._scrollViewRef);
      }
    }, {
      key: "getInnerViewNode",
      value: function getInnerViewNode() {
        return ReactNative.findNodeHandle(this._innerViewRef);
      }
    }, {
      key: "getNativeScrollRef",
      value: function getNativeScrollRef() {
        return this._scrollViewRef;
      }
    }, {
      key: "scrollTo",
      value: function scrollTo(options, deprecatedX, deprecatedAnimated) {
        var x, y, animated;

        if (typeof options === 'number') {
          console.warn('`scrollTo(y, x, animated)` is deprecated. Use `scrollTo({x: 5, y: 5, ' + 'animated: true})` instead.');
          y = options;
          x = deprecatedX;
          animated = deprecatedAnimated;
        } else if (options) {
          y = options.y;
          x = options.x;
          animated = options.animated;
        }

        this._scrollResponder.scrollResponderScrollTo({
          x: x || 0,
          y: y || 0,
          animated: animated !== false
        });
      }
    }, {
      key: "scrollToEnd",
      value: function scrollToEnd(options) {
        var animated = (options && options.animated) !== false;

        this._scrollResponder.scrollResponderScrollToEnd({
          animated: animated
        });
      }
    }, {
      key: "scrollWithoutAnimationTo",
      value: function scrollWithoutAnimationTo() {
        var y = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
        var x = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
        console.warn('`scrollWithoutAnimationTo` is deprecated. Use `scrollTo` instead');
        this.scrollTo({
          x: x,
          y: y,
          animated: false
        });
      }
    }, {
      key: "flashScrollIndicators",
      value: function flashScrollIndicators() {
        this._scrollResponder.scrollResponderFlashScrollIndicators();
      }
    }, {
      key: "_getKeyForIndex",
      value: function _getKeyForIndex(index, childArray) {
        var child = childArray[index];
        return child && child.key;
      }
    }, {
      key: "_updateAnimatedNodeAttachment",
      value: function _updateAnimatedNodeAttachment() {
        if (this._scrollAnimatedValueAttachment) {
          this._scrollAnimatedValueAttachment.detach();
        }

        if (this.props.stickyHeaderIndices && this.props.stickyHeaderIndices.length > 0) {
          this._scrollAnimatedValueAttachment = AnimatedImplementation.attachNativeEvent(this._scrollViewRef, 'onScroll', [{
            nativeEvent: {
              contentOffset: {
                y: this._scrollAnimatedValue
              }
            }
          }]);
        }
      }
    }, {
      key: "_setStickyHeaderRef",
      value: function _setStickyHeaderRef(key, ref) {
        if (ref) {
          this._stickyHeaderRefs.set(key, ref);
        } else {
          this._stickyHeaderRefs.delete(key);
        }
      }
    }, {
      key: "_onStickyHeaderLayout",
      value: function _onStickyHeaderLayout(index, event, key) {
        var stickyHeaderIndices = this.props.stickyHeaderIndices;

        if (!stickyHeaderIndices) {
          return;
        }

        var childArray = React.Children.toArray(this.props.children);

        if (key !== this._getKeyForIndex(index, childArray)) {
          return;
        }

        var layoutY = event.nativeEvent.layout.y;

        this._headerLayoutYs.set(key, layoutY);

        var indexOfIndex = stickyHeaderIndices.indexOf(index);
        var previousHeaderIndex = stickyHeaderIndices[indexOfIndex - 1];

        if (previousHeaderIndex != null) {
          var previousHeader = this._stickyHeaderRefs.get(this._getKeyForIndex(previousHeaderIndex, childArray));

          previousHeader && previousHeader.setNextHeaderY && previousHeader.setNextHeaderY(layoutY);
        }
      }
    }, {
      key: "render",
      value: function render() {
        var _this2 = this;

        var ScrollViewClass;
        var ScrollContentContainerViewClass;

        if ("android" === 'android') {
          if (this.props.horizontal === true) {
            ScrollViewClass = AndroidHorizontalScrollView;
            ScrollContentContainerViewClass = AndroidHorizontalScrollContentView;
          } else {
            ScrollViewClass = AndroidScrollView;
            ScrollContentContainerViewClass = View;
          }
        } else {
          ScrollViewClass = RCTScrollView;
          ScrollContentContainerViewClass = RCTScrollContentView;
        }

        invariant(ScrollViewClass !== undefined, 'ScrollViewClass must not be undefined');
        invariant(ScrollContentContainerViewClass !== undefined, 'ScrollContentContainerViewClass must not be undefined');
        var contentContainerStyle = [this.props.horizontal === true && styles.contentContainerHorizontal, this.props.contentContainerStyle];

        if (__DEV__ && this.props.style !== undefined) {
          var style = flattenStyle(this.props.style);
          var childLayoutProps = ['alignItems', 'justifyContent'].filter(function (prop) {
            return style && style[prop] !== undefined;
          });
          invariant(childLayoutProps.length === 0, 'ScrollView child layout (' + JSON.stringify(childLayoutProps) + ') must be applied through the contentContainerStyle prop.');
        }

        var contentSizeChangeProps = {};

        if (this.props.onContentSizeChange) {
          contentSizeChangeProps = {
            onLayout: this._handleContentOnLayout
          };
        }

        var stickyHeaderIndices = this.props.stickyHeaderIndices;
        var children = this.props.children;

        if (stickyHeaderIndices != null && stickyHeaderIndices.length > 0) {
          var childArray = React.Children.toArray(this.props.children);
          children = childArray.map(function (child, index) {
            var indexOfIndex = child ? stickyHeaderIndices.indexOf(index) : -1;

            if (indexOfIndex > -1) {
              var _key3 = child.key;
              var nextIndex = stickyHeaderIndices[indexOfIndex + 1];
              var StickyHeaderComponent = _this2.props.StickyHeaderComponent || ScrollViewStickyHeader;
              return React.createElement(StickyHeaderComponent, {
                key: _key3,
                ref: function ref(_ref) {
                  return _this2._setStickyHeaderRef(_key3, _ref);
                },
                nextHeaderLayoutY: _this2._headerLayoutYs.get(_this2._getKeyForIndex(nextIndex, childArray)),
                onLayout: function onLayout(event) {
                  return _this2._onStickyHeaderLayout(index, event, _key3);
                },
                scrollAnimatedValue: _this2._scrollAnimatedValue,
                inverted: _this2.props.invertStickyHeaders,
                scrollViewHeight: _this2.state.layoutHeight,
                __source: {
                  fileName: _jsxFileName,
                  lineNumber: 1004
                }
              }, child);
            } else {
              return child;
            }
          });
        }

        children = React.createElement(Context.Provider, {
          value: this.props.horizontal === true ? standardHorizontalContext : standardVerticalContext,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 1024
          }
        }, children);
        var hasStickyHeaders = Array.isArray(stickyHeaderIndices) && stickyHeaderIndices.length > 0;
        var contentContainer = React.createElement(ScrollContentContainerViewClass, _extends({}, contentSizeChangeProps, {
          ref: this._setInnerViewRef,
          style: contentContainerStyle,
          removeClippedSubviews: "android" === 'android' && hasStickyHeaders ? false : this.props.removeClippedSubviews,
          collapsable: false,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 1038
          }
        }), children);
        var alwaysBounceHorizontal = this.props.alwaysBounceHorizontal !== undefined ? this.props.alwaysBounceHorizontal : this.props.horizontal;
        var alwaysBounceVertical = this.props.alwaysBounceVertical !== undefined ? this.props.alwaysBounceVertical : !this.props.horizontal;
        var DEPRECATED_sendUpdatedChildFrames = !!this.props.DEPRECATED_sendUpdatedChildFrames;
        var baseStyle = this.props.horizontal === true ? styles.baseHorizontal : styles.baseVertical;

        var props = _objectSpread({}, this.props, {
          alwaysBounceHorizontal: alwaysBounceHorizontal,
          alwaysBounceVertical: alwaysBounceVertical,
          style: [baseStyle, this.props.style],
          onContentSizeChange: null,
          onLayout: this._handleLayout,
          onMomentumScrollBegin: this._scrollResponder.scrollResponderHandleMomentumScrollBegin,
          onMomentumScrollEnd: this._scrollResponder.scrollResponderHandleMomentumScrollEnd,
          onResponderGrant: this._scrollResponder.scrollResponderHandleResponderGrant,
          onResponderReject: this._scrollResponder.scrollResponderHandleResponderReject,
          onResponderRelease: this._scrollResponder.scrollResponderHandleResponderRelease,
          onResponderTerminate: this._scrollResponder.scrollResponderHandleTerminate,
          onResponderTerminationRequest: this._scrollResponder.scrollResponderHandleTerminationRequest,
          onScrollBeginDrag: this._scrollResponder.scrollResponderHandleScrollBeginDrag,
          onScrollEndDrag: this._scrollResponder.scrollResponderHandleScrollEndDrag,
          onScrollShouldSetResponder: this._scrollResponder.scrollResponderHandleScrollShouldSetResponder,
          onStartShouldSetResponder: this._scrollResponder.scrollResponderHandleStartShouldSetResponder,
          onStartShouldSetResponderCapture: this._scrollResponder.scrollResponderHandleStartShouldSetResponderCapture,
          onTouchEnd: this._scrollResponder.scrollResponderHandleTouchEnd,
          onTouchMove: this._scrollResponder.scrollResponderHandleTouchMove,
          onTouchStart: this._scrollResponder.scrollResponderHandleTouchStart,
          onTouchCancel: this._scrollResponder.scrollResponderHandleTouchCancel,
          onScroll: this._handleScroll,
          scrollBarThumbImage: resolveAssetSource(this.props.scrollBarThumbImage),
          scrollEventThrottle: hasStickyHeaders ? 1 : this.props.scrollEventThrottle,
          sendMomentumEvents: this.props.onMomentumScrollBegin || this.props.onMomentumScrollEnd ? true : false,
          DEPRECATED_sendUpdatedChildFrames: DEPRECATED_sendUpdatedChildFrames,
          snapToStart: this.props.snapToStart !== false,
          snapToEnd: this.props.snapToEnd !== false,
          pagingEnabled: this.props.pagingEnabled === true || this.props.snapToInterval != null || this.props.snapToOffsets != null
        });

        var decelerationRate = this.props.decelerationRate;

        if (decelerationRate != null) {
          props.decelerationRate = processDecelerationRate(decelerationRate);
        }

        var refreshControl = this.props.refreshControl;

        if (refreshControl) {
          if ("android" === 'ios') {
            return React.createElement(ScrollViewClass, _extends({}, props, {
              ref: this._setScrollViewRef,
              __source: {
                fileName: _jsxFileName,
                lineNumber: 1151
              }
            }), Platform.isTV ? null : refreshControl, contentContainer);
          } else if ("android" === 'android') {
            var _splitLayoutProps = splitLayoutProps(flattenStyle(props.style)),
                outer = _splitLayoutProps.outer,
                inner = _splitLayoutProps.inner;

            return React.cloneElement(refreshControl, {
              style: [baseStyle, outer]
            }, React.createElement(ScrollViewClass, _extends({}, props, {
              style: [baseStyle, inner],
              ref: this._setScrollViewRef,
              __source: {
                fileName: _jsxFileName,
                lineNumber: 1166
              }
            }), contentContainer));
          }
        }

        return React.createElement(ScrollViewClass, _extends({}, props, {
          ref: this._setScrollViewRef,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 1178
          }
        }), contentContainer);
      }
    }]);

    return ScrollView;
  }(React.Component);

  ScrollView.Context = Context;
  var styles = StyleSheet.create({
    baseVertical: {
      flexGrow: 1,
      flexShrink: 1,
      flexDirection: 'column',
      overflow: 'scroll'
    },
    baseHorizontal: {
      flexGrow: 1,
      flexShrink: 1,
      flexDirection: 'row',
      overflow: 'scroll'
    },
    contentContainerHorizontal: {
      flexDirection: 'row'
    }
  });
  module.exports = ScrollView;
},300,[13,24,25,32,34,33,37,46,272,48,54,88,301,308,60,86,307,85,3,309,218,214,310],"node_modules/react-native/Libraries/Components/ScrollView/ScrollView.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var Dimensions = _$$_REQUIRE(_dependencyMap[0], "../Utilities/Dimensions");

  var FrameRateLogger = _$$_REQUIRE(_dependencyMap[1], "../Interaction/FrameRateLogger");

  var Keyboard = _$$_REQUIRE(_dependencyMap[2], "./Keyboard/Keyboard");

  var ReactNative = _$$_REQUIRE(_dependencyMap[3], "../Renderer/shims/ReactNative");

  var TextInputState = _$$_REQUIRE(_dependencyMap[4], "./TextInput/TextInputState");

  var UIManager = _$$_REQUIRE(_dependencyMap[5], "../ReactNative/UIManager");

  var invariant = _$$_REQUIRE(_dependencyMap[6], "invariant");

  var nullthrows = _$$_REQUIRE(_dependencyMap[7], "nullthrows");

  var performanceNow = _$$_REQUIRE(_dependencyMap[8], "fbjs/lib/performanceNow");

  var warning = _$$_REQUIRE(_dependencyMap[9], "fbjs/lib/warning");

  var _require = _$$_REQUIRE(_dependencyMap[10], "../BatchedBridge/NativeModules"),
      ScrollViewManager = _require.ScrollViewManager;

  var IS_ANIMATING_TOUCH_START_THRESHOLD_MS = 16;
  var ScrollResponderMixin = {
    _subscriptionKeyboardWillShow: null,
    _subscriptionKeyboardWillHide: null,
    _subscriptionKeyboardDidShow: null,
    _subscriptionKeyboardDidHide: null,
    scrollResponderMixinGetInitialState: function scrollResponderMixinGetInitialState() {
      return {
        isTouching: false,
        lastMomentumScrollBeginTime: 0,
        lastMomentumScrollEndTime: 0,
        observedScrollSinceBecomingResponder: false,
        becameResponderWhileAnimating: false
      };
    },
    scrollResponderHandleScrollShouldSetResponder: function scrollResponderHandleScrollShouldSetResponder() {
      if (this.props.disableScrollViewPanResponder === true) {
        return false;
      }

      return this.state.isTouching;
    },
    scrollResponderHandleStartShouldSetResponder: function scrollResponderHandleStartShouldSetResponder(e) {
      if (this.props.disableScrollViewPanResponder === true) {
        return false;
      }

      var currentlyFocusedTextInput = TextInputState.currentlyFocusedField();

      if (this.props.keyboardShouldPersistTaps === 'handled' && currentlyFocusedTextInput != null && e.target !== currentlyFocusedTextInput) {
        return true;
      }

      return false;
    },
    scrollResponderHandleStartShouldSetResponderCapture: function scrollResponderHandleStartShouldSetResponderCapture(e) {
      if (this.scrollResponderIsAnimating()) {
        return true;
      }

      if (this.props.disableScrollViewPanResponder === true) {
        return false;
      }

      var currentlyFocusedTextInput = TextInputState.currentlyFocusedField();
      var keyboardShouldPersistTaps = this.props.keyboardShouldPersistTaps;
      var keyboardNeverPersistTaps = !keyboardShouldPersistTaps || keyboardShouldPersistTaps === 'never';

      if (keyboardNeverPersistTaps && currentlyFocusedTextInput != null && e.target && !TextInputState.isTextInput(e.target)) {
        return true;
      }

      return false;
    },
    scrollResponderHandleResponderReject: function scrollResponderHandleResponderReject() {},
    scrollResponderHandleTerminationRequest: function scrollResponderHandleTerminationRequest() {
      return !this.state.observedScrollSinceBecomingResponder;
    },
    scrollResponderHandleTouchEnd: function scrollResponderHandleTouchEnd(e) {
      var nativeEvent = e.nativeEvent;
      this.state.isTouching = nativeEvent.touches.length !== 0;
      this.props.onTouchEnd && this.props.onTouchEnd(e);
    },
    scrollResponderHandleTouchCancel: function scrollResponderHandleTouchCancel(e) {
      this.state.isTouching = false;
      this.props.onTouchCancel && this.props.onTouchCancel(e);
    },
    scrollResponderHandleResponderRelease: function scrollResponderHandleResponderRelease(e) {
      this.props.onResponderRelease && this.props.onResponderRelease(e);
      var currentlyFocusedTextInput = TextInputState.currentlyFocusedField();

      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 scrollResponderHandleScroll(e) {
      this.state.observedScrollSinceBecomingResponder = true;
      this.props.onScroll && this.props.onScroll(e);
    },
    scrollResponderHandleResponderGrant: function scrollResponderHandleResponderGrant(e) {
      this.state.observedScrollSinceBecomingResponder = false;
      this.props.onResponderGrant && this.props.onResponderGrant(e);
      this.state.becameResponderWhileAnimating = this.scrollResponderIsAnimating();
    },
    scrollResponderHandleScrollBeginDrag: function scrollResponderHandleScrollBeginDrag(e) {
      FrameRateLogger.beginScroll();
      this.props.onScrollBeginDrag && this.props.onScrollBeginDrag(e);
    },
    scrollResponderHandleScrollEndDrag: function scrollResponderHandleScrollEndDrag(e) {
      var velocity = e.nativeEvent.velocity;

      if (!this.scrollResponderIsAnimating() && (!velocity || velocity.x === 0 && velocity.y === 0)) {
        FrameRateLogger.endScroll();
      }

      this.props.onScrollEndDrag && this.props.onScrollEndDrag(e);
    },
    scrollResponderHandleMomentumScrollBegin: function scrollResponderHandleMomentumScrollBegin(e) {
      this.state.lastMomentumScrollBeginTime = performanceNow();
      this.props.onMomentumScrollBegin && this.props.onMomentumScrollBegin(e);
    },
    scrollResponderHandleMomentumScrollEnd: function scrollResponderHandleMomentumScrollEnd(e) {
      FrameRateLogger.endScroll();
      this.state.lastMomentumScrollEndTime = performanceNow();
      this.props.onMomentumScrollEnd && this.props.onMomentumScrollEnd(e);
    },
    scrollResponderHandleTouchStart: function scrollResponderHandleTouchStart(e) {
      this.state.isTouching = true;
      this.props.onTouchStart && this.props.onTouchStart(e);
    },
    scrollResponderHandleTouchMove: function scrollResponderHandleTouchMove(e) {
      this.props.onTouchMove && this.props.onTouchMove(e);
    },
    scrollResponderIsAnimating: function scrollResponderIsAnimating() {
      var now = performanceNow();
      var timeSinceLastMomentumScrollEnd = now - this.state.lastMomentumScrollEndTime;
      var isAnimating = timeSinceLastMomentumScrollEnd < IS_ANIMATING_TOUCH_START_THRESHOLD_MS || this.state.lastMomentumScrollEndTime < this.state.lastMomentumScrollBeginTime;
      return isAnimating;
    },
    scrollResponderGetScrollableNode: function scrollResponderGetScrollableNode() {
      return this.getScrollableNode ? this.getScrollableNode() : ReactNative.findNodeHandle(this);
    },
    scrollResponderScrollTo: function scrollResponderScrollTo(x, y, animated) {
      if (typeof x === 'number') {
        console.warn('`scrollResponderScrollTo(x, y, animated)` is deprecated. Use `scrollResponderScrollTo({x: 5, y: 5, animated: true})` instead.');
      } else {
        var _ref = x || {};

        x = _ref.x;
        y = _ref.y;
        animated = _ref.animated;
      }

      UIManager.dispatchViewManagerCommand(nullthrows(this.scrollResponderGetScrollableNode()), UIManager.getViewManagerConfig('RCTScrollView').Commands.scrollTo, [x || 0, y || 0, animated !== false]);
    },
    scrollResponderScrollToEnd: function scrollResponderScrollToEnd(options) {
      var animated = (options && options.animated) !== false;
      UIManager.dispatchViewManagerCommand(this.scrollResponderGetScrollableNode(), UIManager.getViewManagerConfig('RCTScrollView').Commands.scrollToEnd, [animated]);
    },
    scrollResponderScrollWithoutAnimationTo: function scrollResponderScrollWithoutAnimationTo(offsetX, offsetY) {
      console.warn('`scrollResponderScrollWithoutAnimationTo` is deprecated. Use `scrollResponderScrollTo` instead');
      this.scrollResponderScrollTo({
        x: offsetX,
        y: offsetY,
        animated: false
      });
    },
    scrollResponderZoomTo: function scrollResponderZoomTo(rect, animated) {
      invariant(ScrollViewManager && ScrollViewManager.zoomToRect, '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');
      }

      ScrollViewManager.zoomToRect(this.scrollResponderGetScrollableNode(), rect, animated !== false);
    },
    scrollResponderFlashScrollIndicators: function scrollResponderFlashScrollIndicators() {
      UIManager.dispatchViewManagerCommand(this.scrollResponderGetScrollableNode(), UIManager.getViewManagerConfig('RCTScrollView').Commands.flashScrollIndicators, []);
    },
    scrollResponderScrollNativeHandleToKeyboard: function scrollResponderScrollNativeHandleToKeyboard(nodeHandle, additionalOffset, preventNegativeScrollOffset) {
      this.additionalScrollOffset = additionalOffset || 0;
      this.preventNegativeScrollOffset = !!preventNegativeScrollOffset;
      UIManager.measureLayout(nodeHandle, ReactNative.findNodeHandle(this.getInnerViewNode()), this.scrollResponderTextInputFocusError, this.scrollResponderInputMeasureAndScrollToKeyboard);
    },
    scrollResponderInputMeasureAndScrollToKeyboard: function scrollResponderInputMeasureAndScrollToKeyboard(left, top, width, height) {
      var keyboardScreenY = Dimensions.get('window').height;

      if (this.keyboardWillOpenTo) {
        keyboardScreenY = this.keyboardWillOpenTo.endCoordinates.screenY;
      }

      var scrollOffsetY = top - keyboardScreenY + height + this.additionalScrollOffset;

      if (this.preventNegativeScrollOffset) {
        scrollOffsetY = Math.max(0, scrollOffsetY);
      }

      this.scrollResponderScrollTo({
        x: 0,
        y: scrollOffsetY,
        animated: true
      });
      this.additionalOffset = 0;
      this.preventNegativeScrollOffset = false;
    },
    scrollResponderTextInputFocusError: function scrollResponderTextInputFocusError(msg) {
      console.error('Error measuring text field: ', msg);
    },
    UNSAFE_componentWillMount: function UNSAFE_componentWillMount() {
      var keyboardShouldPersistTaps = this.props.keyboardShouldPersistTaps;
      warning(typeof keyboardShouldPersistTaps !== 'boolean', "'keyboardShouldPersistTaps={" + keyboardShouldPersistTaps + "}' is deprecated. " + ("Use 'keyboardShouldPersistTaps=\"" + (keyboardShouldPersistTaps ? 'always' : 'never') + "\"' instead"));
      this.keyboardWillOpenTo = null;
      this.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 componentWillUnmount() {
      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();
      }
    },
    scrollResponderKeyboardWillShow: function scrollResponderKeyboardWillShow(e) {
      this.keyboardWillOpenTo = e;
      this.props.onKeyboardWillShow && this.props.onKeyboardWillShow(e);
    },
    scrollResponderKeyboardWillHide: function scrollResponderKeyboardWillHide(e) {
      this.keyboardWillOpenTo = null;
      this.props.onKeyboardWillHide && this.props.onKeyboardWillHide(e);
    },
    scrollResponderKeyboardDidShow: function scrollResponderKeyboardDidShow(e) {
      if (e) {
        this.keyboardWillOpenTo = e;
      }

      this.props.onKeyboardDidShow && this.props.onKeyboardDidShow(e);
    },
    scrollResponderKeyboardDidHide: function scrollResponderKeyboardDidHide(e) {
      this.keyboardWillOpenTo = null;
      this.props.onKeyboardDidHide && this.props.onKeyboardDidHide(e);
    }
  };
  var ScrollResponder = {
    Mixin: ScrollResponderMixin
  };
  module.exports = ScrollResponder;
},301,[62,302,304,88,195,43,3,249,122,5,12],"node_modules/react-native/Libraries/Components/ScrollResponder.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _NativeFrameRateLogger = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./NativeFrameRateLogger"));

  var invariant = _$$_REQUIRE(_dependencyMap[2], "invariant");

  var FrameRateLogger = {
    setGlobalOptions: function setGlobalOptions(options) {
      if (options.debug !== undefined) {
        invariant(_NativeFrameRateLogger.default, 'Trying to debug FrameRateLogger without the native module!');
      }

      if (_NativeFrameRateLogger.default) {
        var optionsClone = {
          debug: !!options.debug,
          reportStackTraces: !!options.reportStackTraces
        };

        _NativeFrameRateLogger.default.setGlobalOptions(optionsClone);
      }
    },
    setContext: function setContext(context) {
      _NativeFrameRateLogger.default && _NativeFrameRateLogger.default.setContext(context);
    },
    beginScroll: function beginScroll() {
      _NativeFrameRateLogger.default && _NativeFrameRateLogger.default.beginScroll();
    },
    endScroll: function endScroll() {
      _NativeFrameRateLogger.default && _NativeFrameRateLogger.default.endScroll();
    }
  };
  module.exports = FrameRateLogger;
},302,[1,303,3],"node_modules/react-native/Libraries/Interaction/FrameRateLogger.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireWildcard");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[1], "../TurboModule/TurboModuleRegistry"));

  var _default = TurboModuleRegistry.get('FrameRateLogger');

  exports.default = _default;
},303,[9,11],"node_modules/react-native/Libraries/Interaction/NativeFrameRateLogger.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _NativeKeyboardObserver = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./NativeKeyboardObserver"));

  var LayoutAnimation = _$$_REQUIRE(_dependencyMap[2], "../../LayoutAnimation/LayoutAnimation");

  var NativeEventEmitter = _$$_REQUIRE(_dependencyMap[3], "../../EventEmitter/NativeEventEmitter");

  var dismissKeyboard = _$$_REQUIRE(_dependencyMap[4], "../../Utilities/dismissKeyboard");

  var invariant = _$$_REQUIRE(_dependencyMap[5], "invariant");

  var KeyboardEventEmitter = new NativeEventEmitter(_NativeKeyboardObserver.default);
  var Keyboard = {
    addListener: function addListener(eventName, callback) {
      invariant(false, 'Dummy method used for documentation');
    },
    removeListener: function removeListener(eventName, callback) {
      invariant(false, 'Dummy method used for documentation');
    },
    removeAllListeners: function removeAllListeners(eventName) {
      invariant(false, 'Dummy method used for documentation');
    },
    dismiss: function dismiss() {
      invariant(false, 'Dummy method used for documentation');
    },
    scheduleLayoutAnimation: function scheduleLayoutAnimation(event) {
      invariant(false, 'Dummy method used for documentation');
    }
  };
  Keyboard = KeyboardEventEmitter;
  Keyboard.dismiss = dismissKeyboard;

  Keyboard.scheduleLayoutAnimation = function (event) {
    var duration = event.duration,
        easing = event.easing;

    if (duration != null && duration !== 0) {
      LayoutAnimation.configureNext({
        duration: duration,
        update: {
          duration: duration,
          type: easing != null && LayoutAnimation.Types[easing] || 'keyboard'
        }
      });
    }
  };

  module.exports = Keyboard;
},304,[1,305,306,134,307,3],"node_modules/react-native/Libraries/Components/Keyboard/Keyboard.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireWildcard");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[1], "../../TurboModule/TurboModuleRegistry"));

  var _default = TurboModuleRegistry.get('KeyboardObserver');

  exports.default = _default;
},305,[9,11],"node_modules/react-native/Libraries/Components/Keyboard/NativeKeyboardObserver.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _Platform = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../Utilities/Platform"));

  var UIManager = _$$_REQUIRE(_dependencyMap[2], "../ReactNative/UIManager");

  function configureNext(config, onAnimationDidEnd) {
    if (!_Platform.default.isTesting) {
      UIManager.configureNextLayoutAnimation(config, onAnimationDidEnd != null ? onAnimationDidEnd : function () {}, function () {});
    }
  }

  function create(duration, type, property) {
    return {
      duration: duration,
      create: {
        type: type,
        property: property
      },
      update: {
        type: type
      },
      delete: {
        type: type,
        property: property
      }
    };
  }

  var Presets = {
    easeInEaseOut: create(300, 'easeInEaseOut', 'opacity'),
    linear: create(500, 'linear', 'opacity'),
    spring: {
      duration: 700,
      create: {
        type: 'linear',
        property: 'opacity'
      },
      update: {
        type: 'spring',
        springDamping: 0.4
      },
      delete: {
        type: 'linear',
        property: 'opacity'
      }
    }
  };
  var LayoutAnimation = {
    configureNext: configureNext,
    create: create,
    Types: Object.freeze({
      spring: 'spring',
      linear: 'linear',
      easeInEaseOut: 'easeInEaseOut',
      easeIn: 'easeIn',
      easeOut: 'easeOut',
      keyboard: 'keyboard'
    }),
    Properties: Object.freeze({
      opacity: 'opacity',
      scaleX: 'scaleX',
      scaleY: 'scaleY',
      scaleXY: 'scaleXY'
    }),
    checkConfig: function checkConfig() {
      console.error('LayoutAnimation.checkConfig(...) has been disabled.');
    },
    Presets: Presets,
    easeInEaseOut: configureNext.bind(null, Presets.easeInEaseOut),
    linear: configureNext.bind(null, Presets.linear),
    spring: configureNext.bind(null, Presets.spring)
  };
  module.exports = LayoutAnimation;
},306,[1,48,43],"node_modules/react-native/Libraries/LayoutAnimation/LayoutAnimation.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var TextInputState = _$$_REQUIRE(_dependencyMap[0], "../Components/TextInput/TextInputState");

  function dismissKeyboard() {
    TextInputState.blurTextInput(TextInputState.currentlyFocusedField());
  }

  module.exports = dismissKeyboard;
},307,[195],"node_modules/react-native/Libraries/Utilities/dismissKeyboard.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");

  var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");

  var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");

  var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native/Libraries/Components/ScrollView/ScrollViewStickyHeader.js";

  var AnimatedImplementation = _$$_REQUIRE(_dependencyMap[5], "../../Animated/src/AnimatedImplementation");

  var React = _$$_REQUIRE(_dependencyMap[6], "react");

  var StyleSheet = _$$_REQUIRE(_dependencyMap[7], "../../StyleSheet/StyleSheet");

  var View = _$$_REQUIRE(_dependencyMap[8], "../View/View");

  var AnimatedView = AnimatedImplementation.createAnimatedComponent(View);

  var ScrollViewStickyHeader = function (_React$Component) {
    _inherits(ScrollViewStickyHeader, _React$Component);

    function ScrollViewStickyHeader() {
      var _getPrototypeOf2;

      var _this;

      _classCallCheck(this, ScrollViewStickyHeader);

      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
        args[_key] = arguments[_key];
      }

      _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(ScrollViewStickyHeader)).call.apply(_getPrototypeOf2, [this].concat(args)));
      _this.state = {
        measured: false,
        layoutY: 0,
        layoutHeight: 0,
        nextHeaderLayoutY: _this.props.nextHeaderLayoutY
      };

      _this._onLayout = function (event) {
        _this.setState({
          measured: true,
          layoutY: event.nativeEvent.layout.y,
          layoutHeight: event.nativeEvent.layout.height
        });

        _this.props.onLayout(event);

        var child = React.Children.only(_this.props.children);

        if (child.props.onLayout) {
          child.props.onLayout(event);
        }
      };

      return _this;
    }

    _createClass(ScrollViewStickyHeader, [{
      key: "setNextHeaderY",
      value: function setNextHeaderY(y) {
        this.setState({
          nextHeaderLayoutY: y
        });
      }
    }, {
      key: "render",
      value: function render() {
        var _this$props = this.props,
            inverted = _this$props.inverted,
            scrollViewHeight = _this$props.scrollViewHeight;
        var _this$state = this.state,
            measured = _this$state.measured,
            layoutHeight = _this$state.layoutHeight,
            layoutY = _this$state.layoutY,
            nextHeaderLayoutY = _this$state.nextHeaderLayoutY;
        var inputRange = [-1, 0];
        var outputRange = [0, 0];

        if (measured) {
          if (inverted) {
            if (scrollViewHeight != null) {
              var stickStartPoint = layoutY + layoutHeight - scrollViewHeight;

              if (stickStartPoint > 0) {
                inputRange.push(stickStartPoint);
                outputRange.push(0);
                inputRange.push(stickStartPoint + 1);
                outputRange.push(1);
                var collisionPoint = (nextHeaderLayoutY || 0) - layoutHeight - scrollViewHeight;

                if (collisionPoint > stickStartPoint) {
                  inputRange.push(collisionPoint, collisionPoint + 1);
                  outputRange.push(collisionPoint - stickStartPoint, collisionPoint - stickStartPoint);
                }
              }
            }
          } else {
            inputRange.push(layoutY);
            outputRange.push(0);

            var _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);
            }
          }
        }

        var translateY = this.props.scrollAnimatedValue.interpolate({
          inputRange: inputRange,
          outputRange: outputRange
        });
        var child = React.Children.only(this.props.children);
        return React.createElement(AnimatedView, {
          collapsable: false,
          onLayout: this._onLayout,
          style: [child.props.style, styles.header, {
            transform: [{
              translateY: translateY
            }]
          }],
          __source: {
            fileName: _jsxFileName,
            lineNumber: 141
          }
        }, React.cloneElement(child, {
          style: styles.fill,
          onLayout: undefined
        }));
      }
    }]);

    return ScrollViewStickyHeader;
  }(React.Component);

  var styles = StyleSheet.create({
    header: {
      zIndex: 10
    },
    fill: {
      flex: 1
    }
  });
  module.exports = ScrollViewStickyHeader;
},308,[24,25,32,34,37,272,54,60,86],"node_modules/react-native/Libraries/Components/ScrollView/ScrollViewStickyHeader.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var Platform = _$$_REQUIRE(_dependencyMap[0], "../../Utilities/Platform");

  function processDecelerationRate(decelerationRate) {
    if (decelerationRate === 'normal') {
      return 0.985;
    } else if (decelerationRate === 'fast') {
      return 0.9;
    }

    return decelerationRate;
  }

  module.exports = processDecelerationRate;
},309,[48],"node_modules/react-native/Libraries/Components/ScrollView/processDecelerationRate.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");

  var OUTER_PROPS = _extends(Object.create(null), {
    margin: true,
    marginHorizontal: true,
    marginVertical: true,
    marginBottom: true,
    marginTop: true,
    marginLeft: true,
    marginRight: true,
    flex: true,
    flexGrow: true,
    flexShrink: true,
    flexBasis: true,
    alignSelf: true,
    height: true,
    minHeight: true,
    maxHeight: true,
    width: true,
    minWidth: true,
    maxWidth: true,
    position: true,
    left: true,
    right: true,
    bottom: true,
    top: true,
    transform: true
  });

  function splitLayoutProps(props) {
    var inner = {};
    var outer = {};

    if (props) {
      Object.keys(props).forEach(function (k) {
        var value = props[k];

        if (OUTER_PROPS[k]) {
          outer[k] = value;
        } else {
          inner[k] = value;
        }
      });
    }

    return {
      outer: outer,
      inner: inner
    };
  }

  module.exports = splitLayoutProps;
},310,[13],"node_modules/react-native/Libraries/StyleSheet/splitLayoutProps.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");

  var _slicedToArray = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/slicedToArray");

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass");

  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

  var invariant = _$$_REQUIRE(_dependencyMap[4], "invariant");

  var ViewabilityHelper = function () {
    function ViewabilityHelper() {
      var config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
        viewAreaCoveragePercentThreshold: 0
      };

      _classCallCheck(this, ViewabilityHelper);

      this._hasInteracted = false;
      this._timers = new Set();
      this._viewableIndices = [];
      this._viewableItems = new Map();
      this._config = config;
    }

    _createClass(ViewabilityHelper, [{
      key: "dispose",
      value: function dispose() {
        this._timers.forEach(clearTimeout);
      }
    }, {
      key: "computeViewableItems",
      value: function computeViewableItems(itemCount, scrollOffset, viewportHeight, getFrameMetrics, renderRange) {
        var _this$_config = this._config,
            itemVisiblePercentThreshold = _this$_config.itemVisiblePercentThreshold,
            viewAreaCoveragePercentThreshold = _this$_config.viewAreaCoveragePercentThreshold;
        var viewAreaMode = viewAreaCoveragePercentThreshold != null;
        var viewablePercentThreshold = viewAreaMode ? viewAreaCoveragePercentThreshold : itemVisiblePercentThreshold;
        invariant(viewablePercentThreshold != null && itemVisiblePercentThreshold != null !== (viewAreaCoveragePercentThreshold != null), 'Must set exactly one of itemVisiblePercentThreshold or viewAreaCoveragePercentThreshold');
        var viewableIndices = [];

        if (itemCount === 0) {
          return viewableIndices;
        }

        var firstVisible = -1;

        var _ref = renderRange || {
          first: 0,
          last: itemCount - 1
        },
            first = _ref.first,
            last = _ref.last;

        if (last >= itemCount) {
          console.warn('Invalid render range computing viewability ' + JSON.stringify({
            renderRange: renderRange,
            itemCount: itemCount
          }));
          return [];
        }

        for (var idx = first; idx <= last; idx++) {
          var metrics = getFrameMetrics(idx);

          if (!metrics) {
            continue;
          }

          var top = metrics.offset - scrollOffset;
          var bottom = top + metrics.length;

          if (top < viewportHeight && bottom > 0) {
            firstVisible = idx;

            if (_isViewable(viewAreaMode, viewablePercentThreshold, top, bottom, viewportHeight, metrics.length)) {
              viewableIndices.push(idx);
            }
          } else if (firstVisible >= 0) {
            break;
          }
        }

        return viewableIndices;
      }
    }, {
      key: "onUpdate",
      value: function onUpdate(itemCount, scrollOffset, viewportHeight, getFrameMetrics, createViewToken, onViewableItemsChanged, renderRange) {
        var _this = this;

        if (this._config.waitForInteraction && !this._hasInteracted || itemCount === 0 || !getFrameMetrics(0)) {
          return;
        }

        var viewableIndices = [];

        if (itemCount) {
          viewableIndices = this.computeViewableItems(itemCount, scrollOffset, viewportHeight, getFrameMetrics, renderRange);
        }

        if (this._viewableIndices.length === viewableIndices.length && this._viewableIndices.every(function (v, ii) {
          return v === viewableIndices[ii];
        })) {
          return;
        }

        this._viewableIndices = viewableIndices;

        if (this._config.minimumViewTime) {
          var handle = setTimeout(function () {
            _this._timers.delete(handle);

            _this._onUpdateSync(viewableIndices, onViewableItemsChanged, createViewToken);
          }, this._config.minimumViewTime);

          this._timers.add(handle);
        } else {
          this._onUpdateSync(viewableIndices, onViewableItemsChanged, createViewToken);
        }
      }
    }, {
      key: "resetViewableIndices",
      value: function resetViewableIndices() {
        this._viewableIndices = [];
      }
    }, {
      key: "recordInteraction",
      value: function recordInteraction() {
        this._hasInteracted = true;
      }
    }, {
      key: "_onUpdateSync",
      value: function _onUpdateSync(viewableIndicesToCheck, onViewableItemsChanged, createViewToken) {
        var _this2 = this;

        viewableIndicesToCheck = viewableIndicesToCheck.filter(function (ii) {
          return _this2._viewableIndices.includes(ii);
        });
        var prevItems = this._viewableItems;
        var nextItems = new Map(viewableIndicesToCheck.map(function (ii) {
          var viewable = createViewToken(ii, true);
          return [viewable.key, viewable];
        }));
        var changed = [];

        for (var _iterator = nextItems, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"]();;) {
          var _ref4;

          if (_isArray) {
            if (_i >= _iterator.length) break;
            _ref4 = _iterator[_i++];
          } else {
            _i = _iterator.next();
            if (_i.done) break;
            _ref4 = _i.value;
          }

          var _ref8 = _ref4;

          var _ref3 = _slicedToArray(_ref8, 2);

          var _key2 = _ref3[0];
          var _viewable2 = _ref3[1];

          if (!prevItems.has(_key2)) {
            changed.push(_viewable2);
          }
        }

        for (var _iterator2 = prevItems, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"]();;) {
          var _ref7;

          if (_isArray2) {
            if (_i2 >= _iterator2.length) break;
            _ref7 = _iterator2[_i2++];
          } else {
            _i2 = _iterator2.next();
            if (_i2.done) break;
            _ref7 = _i2.value;
          }

          var _ref9 = _ref7;

          var _ref6 = _slicedToArray(_ref9, 2);

          var _key3 = _ref6[0];
          var _viewable3 = _ref6[1];

          if (!nextItems.has(_key3)) {
            changed.push(_objectSpread({}, _viewable3, {
              isViewable: false
            }));
          }
        }

        if (changed.length > 0) {
          this._viewableItems = nextItems;
          onViewableItemsChanged({
            viewableItems: Array.from(nextItems.values()),
            changed: changed,
            viewabilityConfig: this._config
          });
        }
      }
    }]);

    return ViewabilityHelper;
  }();

  function _isViewable(viewAreaMode, viewablePercentThreshold, top, bottom, viewportHeight, itemLength) {
    if (_isEntirelyVisible(top, bottom, viewportHeight)) {
      return true;
    } else {
      var pixels = _getPixelsVisible(top, bottom, viewportHeight);

      var percent = 100 * (viewAreaMode ? pixels / viewportHeight : pixels / itemLength);
      return percent >= viewablePercentThreshold;
    }
  }

  function _getPixelsVisible(top, bottom, viewportHeight) {
    var visibleHeight = Math.min(bottom, viewportHeight) - Math.max(top, 0);
    return Math.max(0, visibleHeight);
  }

  function _isEntirelyVisible(top, bottom, viewportHeight) {
    return top >= 0 && bottom <= viewportHeight && bottom > top;
  }

  module.exports = ViewabilityHelper;
},311,[46,14,24,25,3],"node_modules/react-native/Libraries/Lists/ViewabilityHelper.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _slicedToArray = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/slicedToArray");

  var invariant = _$$_REQUIRE(_dependencyMap[1], "invariant");

  function elementsThatOverlapOffsets(offsets, itemCount, getFrameMetrics) {
    var out = [];
    var outLength = 0;

    for (var ii = 0; ii < itemCount; ii++) {
      var frame = getFrameMetrics(ii);
      var trailingOffset = frame.offset + frame.length;

      for (var kk = 0; kk < offsets.length; kk++) {
        if (out[kk] == null && trailingOffset >= offsets[kk]) {
          out[kk] = ii;
          outLength++;

          if (kk === offsets.length - 1) {
            invariant(outLength === offsets.length, 'bad offsets input, should be in increasing order: %s', JSON.stringify(offsets));
            return out;
          }
        }
      }
    }

    return out;
  }

  function newRangeCount(prev, next) {
    return next.last - next.first + 1 - Math.max(0, 1 + Math.min(next.last, prev.last) - Math.max(next.first, prev.first));
  }

  function computeWindowedRenderLimits(props, prev, getFrameMetricsApprox, scrollMetrics) {
    var data = props.data,
        getItemCount = props.getItemCount,
        maxToRenderPerBatch = props.maxToRenderPerBatch,
        windowSize = props.windowSize;
    var itemCount = getItemCount(data);

    if (itemCount === 0) {
      return prev;
    }

    var offset = scrollMetrics.offset,
        velocity = scrollMetrics.velocity,
        visibleLength = scrollMetrics.visibleLength;
    var visibleBegin = Math.max(0, offset);
    var visibleEnd = visibleBegin + visibleLength;
    var overscanLength = (windowSize - 1) * visibleLength;
    var leadFactor = 0.5;
    var fillPreference = velocity > 1 ? 'after' : velocity < -1 ? 'before' : 'none';
    var overscanBegin = Math.max(0, visibleBegin - (1 - leadFactor) * overscanLength);
    var overscanEnd = Math.max(0, visibleEnd + leadFactor * overscanLength);
    var lastItemOffset = getFrameMetricsApprox(itemCount - 1).offset;

    if (lastItemOffset < overscanBegin) {
      return {
        first: Math.max(0, itemCount - 1 - maxToRenderPerBatch),
        last: itemCount - 1
      };
    }

    var _elementsThatOverlapO = elementsThatOverlapOffsets([overscanBegin, visibleBegin, visibleEnd, overscanEnd], props.getItemCount(props.data), getFrameMetricsApprox),
        _elementsThatOverlapO2 = _slicedToArray(_elementsThatOverlapO, 4),
        overscanFirst = _elementsThatOverlapO2[0],
        first = _elementsThatOverlapO2[1],
        last = _elementsThatOverlapO2[2],
        overscanLast = _elementsThatOverlapO2[3];

    overscanFirst = overscanFirst == null ? 0 : overscanFirst;
    first = first == null ? Math.max(0, overscanFirst) : first;
    overscanLast = overscanLast == null ? itemCount - 1 : overscanLast;
    last = last == null ? Math.min(overscanLast, first + maxToRenderPerBatch - 1) : last;
    var visible = {
      first: first,
      last: last
    };
    var newCellCount = newRangeCount(prev, visible);

    while (true) {
      if (first <= overscanFirst && last >= overscanLast) {
        break;
      }

      var maxNewCells = newCellCount >= maxToRenderPerBatch;
      var firstWillAddMore = first <= prev.first || first > prev.last;
      var firstShouldIncrement = first > overscanFirst && (!maxNewCells || !firstWillAddMore);
      var lastWillAddMore = last >= prev.last || last < prev.first;
      var lastShouldIncrement = last < overscanLast && (!maxNewCells || !lastWillAddMore);

      if (maxNewCells && !firstShouldIncrement && !lastShouldIncrement) {
        break;
      }

      if (firstShouldIncrement && !(fillPreference === 'after' && lastShouldIncrement && lastWillAddMore)) {
        if (firstWillAddMore) {
          newCellCount++;
        }

        first--;
      }

      if (lastShouldIncrement && !(fillPreference === 'before' && firstShouldIncrement && firstWillAddMore)) {
        if (lastWillAddMore) {
          newCellCount++;
        }

        last++;
      }
    }

    if (!(last >= first && first >= 0 && last < itemCount && first >= overscanFirst && last <= overscanLast && first <= visible.first && last >= visible.last)) {
      throw new Error('Bad window calculation ' + JSON.stringify({
        first: first,
        last: last,
        itemCount: itemCount,
        overscanFirst: overscanFirst,
        overscanLast: overscanLast,
        visible: visible
      }));
    }

    return {
      first: first,
      last: last
    };
  }

  var VirtualizeUtils = {
    computeWindowedRenderLimits: computeWindowedRenderLimits,
    elementsThatOverlapOffsets: elementsThatOverlapOffsets,
    newRangeCount: newRangeCount
  };
  module.exports = VirtualizeUtils;
},312,[14,3],"node_modules/react-native/Libraries/Lists/VirtualizeUtils.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var Image = _$$_REQUIRE(_dependencyMap[0], "../../../Image/Image");

  var createAnimatedComponent = _$$_REQUIRE(_dependencyMap[1], "../createAnimatedComponent");

  module.exports = createAnimatedComponent(Image);
},313,[314,291],"node_modules/react-native/Libraries/Animated/src/components/AnimatedImage.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");

  var _regeneratorRuntime = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/regenerator");

  var _defineProperty = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/defineProperty");

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native/Libraries/Image/Image.android.js";

  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

  var DeprecatedImageStylePropTypes = _$$_REQUIRE(_dependencyMap[3], "../DeprecatedPropTypes/DeprecatedImageStylePropTypes");

  var DeprecatedStyleSheetPropType = _$$_REQUIRE(_dependencyMap[4], "../DeprecatedPropTypes/DeprecatedStyleSheetPropType");

  var DeprecatedViewPropTypes = _$$_REQUIRE(_dependencyMap[5], "../DeprecatedPropTypes/DeprecatedViewPropTypes");

  var ImageViewNativeComponent = _$$_REQUIRE(_dependencyMap[6], "./ImageViewNativeComponent");

  var NativeModules = _$$_REQUIRE(_dependencyMap[7], "../BatchedBridge/NativeModules");

  var PropTypes = _$$_REQUIRE(_dependencyMap[8], "prop-types");

  var React = _$$_REQUIRE(_dependencyMap[9], "react");

  var ReactNative = _$$_REQUIRE(_dependencyMap[10], "../Renderer/shims/ReactNative");

  var StyleSheet = _$$_REQUIRE(_dependencyMap[11], "../StyleSheet/StyleSheet");

  var TextAncestor = _$$_REQUIRE(_dependencyMap[12], "../Text/TextAncestor");

  var flattenStyle = _$$_REQUIRE(_dependencyMap[13], "../StyleSheet/flattenStyle");

  var merge = _$$_REQUIRE(_dependencyMap[14], "../vendor/core/merge");

  var resolveAssetSource = _$$_REQUIRE(_dependencyMap[15], "./resolveAssetSource");

  var ImageLoader = NativeModules.ImageLoader;

  var TextInlineImageNativeComponent = _$$_REQUIRE(_dependencyMap[16], "./TextInlineImageNativeComponent");

  var _requestId = 1;

  function generateRequestId() {
    return _requestId++;
  }

  var ImageProps = _objectSpread({}, DeprecatedViewPropTypes, {
    style: DeprecatedStyleSheetPropType(DeprecatedImageStylePropTypes),
    source: PropTypes.oneOfType([PropTypes.shape({
      uri: PropTypes.string,
      headers: PropTypes.objectOf(PropTypes.string)
    }), PropTypes.number, PropTypes.arrayOf(PropTypes.shape({
      uri: PropTypes.string,
      width: PropTypes.number,
      height: PropTypes.number,
      headers: PropTypes.objectOf(PropTypes.string)
    }))]),
    blurRadius: PropTypes.number,
    defaultSource: PropTypes.number,
    loadingIndicatorSource: PropTypes.oneOfType([PropTypes.shape({
      uri: PropTypes.string
    }), PropTypes.number]),
    progressiveRenderingEnabled: PropTypes.bool,
    fadeDuration: PropTypes.number,
    onLoadStart: PropTypes.func,
    onError: PropTypes.func,
    onLoad: PropTypes.func,
    onLoadEnd: PropTypes.func,
    testID: PropTypes.string,
    resizeMethod: PropTypes.oneOf(['auto', 'resize', 'scale']),
    resizeMode: PropTypes.oneOf(['cover', 'contain', 'stretch', 'repeat', 'center'])
  });

  function getSize(url, success, failure) {
    return ImageLoader.getSize(url).then(function (sizes) {
      success(sizes.width, sizes.height);
    }).catch(failure || function () {
      console.warn('Failed to get size for image: ' + url);
    });
  }

  function getSizeWithHeaders(url, headers, success, failure) {
    return ImageLoader.getSizeWithHeaders(url, headers).then(function (sizes) {
      success(sizes.width, sizes.height);
    }).catch(failure || function () {
      console.warn('Failed to get size for image: ' + url);
    });
  }

  function prefetch(url, callback) {
    var requestId = generateRequestId();
    callback && callback(requestId);
    return ImageLoader.prefetchImage(url, requestId);
  }

  function abortPrefetch(requestId) {
    ImageLoader.abortRequest(requestId);
  }

  function queryCache(urls) {
    return _regeneratorRuntime.async(function queryCache$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            _context.next = 2;
            return _regeneratorRuntime.awrap(ImageLoader.queryCache(urls));

          case 2:
            return _context.abrupt("return", _context.sent);

          case 3:
          case "end":
            return _context.stop();
        }
      }
    });
  }

  var Image = function Image(props, forwardedRef) {
    var _source, _source3;

    var source = resolveAssetSource(props.source);
    var defaultSource = resolveAssetSource(props.defaultSource);
    var loadingIndicatorSource = resolveAssetSource(props.loadingIndicatorSource);

    if (source && source.uri === '') {
      console.warn('source.uri should not be an empty string');
    }

    if (props.src) {
      console.warn('The <Image> component requires a `source` property rather than `src`.');
    }

    if (props.children) {
      throw new Error('The <Image> component cannot contain children. If you want to render content on top of the image, consider using the <ImageBackground> component or absolute positioning.');
    }

    if (props.defaultSource && props.loadingIndicatorSource) {
      throw new Error('The <Image> component cannot have defaultSource and loadingIndicatorSource at the same time. Please use either defaultSource or loadingIndicatorSource.');
    }

    if (source && !source.uri && !Array.isArray(source)) {
      source = null;
    }

    var style;
    var sources;

    if (((_source = source) == null ? void 0 : _source.uri) != null) {
      var _source2 = source,
          _width = _source2.width,
          _height = _source2.height;
      style = flattenStyle([{
        width: _width,
        height: _height
      }, styles.base, props.style]);
      sources = [{
        uri: source.uri
      }];
    } else {
      style = flattenStyle([styles.base, props.style]);
      sources = source;
    }

    var onLoadStart = props.onLoadStart,
        onLoad = props.onLoad,
        onLoadEnd = props.onLoadEnd,
        onError = props.onError;
    var nativeProps = merge(props, {
      style: style,
      shouldNotifyLoadEvents: !!(onLoadStart || onLoad || onLoadEnd || onError),
      src: sources,
      headers: (_source3 = source) == null ? void 0 : _source3.headers,
      defaultSrc: defaultSource ? defaultSource.uri : null,
      loadingIndicatorSrc: loadingIndicatorSource ? loadingIndicatorSource.uri : null,
      ref: forwardedRef
    });
    return React.createElement(TextAncestor.Consumer, {
      __source: {
        fileName: _jsxFileName,
        lineNumber: 277
      }
    }, function (hasTextAncestor) {
      return hasTextAncestor ? React.createElement(TextInlineImageNativeComponent, _extends({}, nativeProps, {
        __source: {
          fileName: _jsxFileName,
          lineNumber: 280
        }
      })) : React.createElement(ImageViewNativeComponent, _extends({}, nativeProps, {
        __source: {
          fileName: _jsxFileName,
          lineNumber: 282
        }
      }));
    });
  };

  Image = React.forwardRef(Image);
  Image.displayName = 'Image';
  Image.getSize = getSize;
  Image.getSizeWithHeaders = getSizeWithHeaders;
  Image.prefetch = prefetch;
  Image.abortPrefetch = abortPrefetch;
  Image.queryCache = queryCache;
  Image.resolveAssetSource = resolveAssetSource;
  Image.propTypes = ImageProps;
  var styles = StyleSheet.create({
    base: {
      overflow: 'hidden'
    }
  });
  module.exports = Image;
},314,[13,103,46,65,238,315,317,12,69,54,88,60,240,85,231,214,318],"node_modules/react-native/Libraries/Image/Image.android.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");

  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

  var DeprecatedEdgeInsetsPropType = _$$_REQUIRE(_dependencyMap[1], "./DeprecatedEdgeInsetsPropType");

  var DeprecatedStyleSheetPropType = _$$_REQUIRE(_dependencyMap[2], "./DeprecatedStyleSheetPropType");

  var DeprecatedViewStylePropTypes = _$$_REQUIRE(_dependencyMap[3], "./DeprecatedViewStylePropTypes");

  var PlatformViewPropTypes = _$$_REQUIRE(_dependencyMap[4], "../Components/View/PlatformViewPropTypes");

  var PropTypes = _$$_REQUIRE(_dependencyMap[5], "prop-types");

  var _require = _$$_REQUIRE(_dependencyMap[6], "./DeprecatedViewAccessibility"),
      DeprecatedAccessibilityRoles = _require.DeprecatedAccessibilityRoles,
      DeprecatedAccessibilityStates = _require.DeprecatedAccessibilityStates;

  var stylePropType = DeprecatedStyleSheetPropType(DeprecatedViewStylePropTypes);
  module.exports = _objectSpread({
    accessible: PropTypes.bool,
    accessibilityLabel: PropTypes.node,
    accessibilityHint: PropTypes.string,
    accessibilityActions: PropTypes.arrayOf(PropTypes.string),
    accessibilityIgnoresInvertColors: PropTypes.bool,
    accessibilityRole: PropTypes.oneOf(DeprecatedAccessibilityRoles),
    accessibilityStates: PropTypes.arrayOf(PropTypes.oneOf(DeprecatedAccessibilityStates)),
    accessibilityState: PropTypes.object,
    accessibilityLiveRegion: PropTypes.oneOf(['none', 'polite', 'assertive']),
    importantForAccessibility: PropTypes.oneOf(['auto', 'yes', 'no', 'no-hide-descendants']),
    accessibilityViewIsModal: PropTypes.bool,
    accessibilityElementsHidden: PropTypes.bool,
    onAccessibilityAction: PropTypes.func,
    onAccessibilityTap: PropTypes.func,
    onMagicTap: PropTypes.func,
    testID: PropTypes.string,
    nativeID: PropTypes.string,
    onResponderGrant: PropTypes.func,
    onResponderMove: PropTypes.func,
    onResponderReject: PropTypes.func,
    onResponderRelease: PropTypes.func,
    onResponderTerminate: PropTypes.func,
    onResponderTerminationRequest: PropTypes.func,
    onStartShouldSetResponder: PropTypes.func,
    onStartShouldSetResponderCapture: PropTypes.func,
    onMoveShouldSetResponder: PropTypes.func,
    onMoveShouldSetResponderCapture: PropTypes.func,
    hitSlop: DeprecatedEdgeInsetsPropType,
    onLayout: PropTypes.func,
    pointerEvents: PropTypes.oneOf(['box-none', 'none', 'box-only', 'auto']),
    style: stylePropType,
    removeClippedSubviews: PropTypes.bool,
    renderToHardwareTextureAndroid: PropTypes.bool,
    shouldRasterizeIOS: PropTypes.bool,
    collapsable: PropTypes.bool,
    needsOffscreenAlphaCompositing: PropTypes.bool
  }, PlatformViewPropTypes);
},315,[46,237,238,79,316,69,259],"node_modules/react-native/Libraries/DeprecatedPropTypes/DeprecatedViewPropTypes.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';
},316,[],"node_modules/react-native/Libraries/Components/View/PlatformViewPropTypes.android.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var requireNativeComponent = _$$_REQUIRE(_dependencyMap[0], "../ReactNative/requireNativeComponent");

  var ImageViewNativeComponent = requireNativeComponent('RCTImageView');
  module.exports = ImageViewNativeComponent;
},317,[218],"node_modules/react-native/Libraries/Image/ImageViewNativeComponent.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var requireNativeComponent = _$$_REQUIRE(_dependencyMap[0], "../ReactNative/requireNativeComponent");

  var TextInlineImage = requireNativeComponent('RCTTextInlineImage');
  module.exports = TextInlineImage;
},318,[218],"node_modules/react-native/Libraries/Image/TextInlineImageNativeComponent.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var ScrollView = _$$_REQUIRE(_dependencyMap[0], "../../../Components/ScrollView/ScrollView");

  var createAnimatedComponent = _$$_REQUIRE(_dependencyMap[1], "../createAnimatedComponent");

  module.exports = createAnimatedComponent(ScrollView, {
    scrollEventThrottle: 0.0001
  });
},319,[300,291],"node_modules/react-native/Libraries/Animated/src/components/AnimatedScrollView.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var SectionList = _$$_REQUIRE(_dependencyMap[0], "../../../Lists/SectionList");

  var createAnimatedComponent = _$$_REQUIRE(_dependencyMap[1], "../createAnimatedComponent");

  module.exports = createAnimatedComponent(SectionList, {
    scrollEventThrottle: 0.0001
  });
},320,[321,291],"node_modules/react-native/Libraries/Animated/src/components/AnimatedSectionList.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass");

  var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn");

  var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf");

  var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");

  var _defineProperty = _$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/defineProperty");

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native/Libraries/Lists/SectionList.js";

  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

  var Platform = _$$_REQUIRE(_dependencyMap[7], "../Utilities/Platform");

  var React = _$$_REQUIRE(_dependencyMap[8], "react");

  var ScrollView = _$$_REQUIRE(_dependencyMap[9], "../Components/ScrollView/ScrollView");

  var VirtualizedSectionList = _$$_REQUIRE(_dependencyMap[10], "./VirtualizedSectionList");

  var defaultProps = _objectSpread({}, VirtualizedSectionList.defaultProps, {
    stickySectionHeadersEnabled: "android" === 'ios'
  });

  var SectionList = function (_React$PureComponent) {
    _inherits(SectionList, _React$PureComponent);

    function SectionList() {
      var _getPrototypeOf2;

      var _this;

      _classCallCheck(this, SectionList);

      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
        args[_key] = arguments[_key];
      }

      _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(SectionList)).call.apply(_getPrototypeOf2, [this].concat(args)));

      _this._captureRef = function (ref) {
        _this._wrapperListRef = ref;
      };

      return _this;
    }

    _createClass(SectionList, [{
      key: "scrollToLocation",
      value: function scrollToLocation(params) {
        if (this._wrapperListRef != null) {
          this._wrapperListRef.scrollToLocation(params);
        }
      }
    }, {
      key: "recordInteraction",
      value: function recordInteraction() {
        var listRef = this._wrapperListRef && this._wrapperListRef.getListRef();

        listRef && listRef.recordInteraction();
      }
    }, {
      key: "flashScrollIndicators",
      value: function flashScrollIndicators() {
        var listRef = this._wrapperListRef && this._wrapperListRef.getListRef();

        listRef && listRef.flashScrollIndicators();
      }
    }, {
      key: "getScrollResponder",
      value: function getScrollResponder() {
        var listRef = this._wrapperListRef && this._wrapperListRef.getListRef();

        if (listRef) {
          return listRef.getScrollResponder();
        }
      }
    }, {
      key: "getScrollableNode",
      value: function getScrollableNode() {
        var listRef = this._wrapperListRef && this._wrapperListRef.getListRef();

        if (listRef) {
          return listRef.getScrollableNode();
        }
      }
    }, {
      key: "setNativeProps",
      value: function setNativeProps(props) {
        var listRef = this._wrapperListRef && this._wrapperListRef.getListRef();

        if (listRef) {
          listRef.setNativeProps(props);
        }
      }
    }, {
      key: "render",
      value: function render() {
        return React.createElement(VirtualizedSectionList, _extends({}, this.props, {
          ref: this._captureRef,
          getItemCount: function getItemCount(items) {
            return items.length;
          },
          getItem: function getItem(items, index) {
            return items[index];
          },
          __source: {
            fileName: _jsxFileName,
            lineNumber: 301
          }
        }));
      }
    }]);

    return SectionList;
  }(React.PureComponent);

  SectionList.defaultProps = defaultProps;
  module.exports = SectionList;
},321,[13,24,25,32,34,37,46,48,54,300,322],"node_modules/react-native/Libraries/Lists/SectionList.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");

  var _defineProperty = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/defineProperty");

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck");

  var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn");

  var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf");

  var _assertThisInitialized = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/assertThisInitialized");

  var _createClass = _$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/createClass");

  var _inherits = _$$_REQUIRE(_dependencyMap[7], "@babel/runtime/helpers/inherits");

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native/Libraries/Lists/VirtualizedSectionList.js";

  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

  var React = _$$_REQUIRE(_dependencyMap[8], "react");

  var View = _$$_REQUIRE(_dependencyMap[9], "../Components/View/View");

  var VirtualizedList = _$$_REQUIRE(_dependencyMap[10], "./VirtualizedList");

  var invariant = _$$_REQUIRE(_dependencyMap[11], "invariant");

  var VirtualizedSectionList = function (_React$PureComponent) {
    _inherits(VirtualizedSectionList, _React$PureComponent);

    _createClass(VirtualizedSectionList, [{
      key: "scrollToLocation",
      value: function scrollToLocation(params) {
        var index = params.itemIndex;

        for (var i = 0; i < params.sectionIndex; i++) {
          index += this.props.getItemCount(this.props.sections[i].data) + 2;
        }

        var viewOffset = params.viewOffset || 0;

        if (params.itemIndex > 0 && this.props.stickySectionHeadersEnabled) {
          var frame = this._listRef._getFrameMetricsApprox(index - params.itemIndex);

          viewOffset += frame.length;
        }

        var toIndexParams = _objectSpread({}, params, {
          viewOffset: viewOffset,
          index: index
        });

        this._listRef.scrollToIndex(toIndexParams);
      }
    }, {
      key: "getListRef",
      value: function getListRef() {
        return this._listRef;
      }
    }]);

    function VirtualizedSectionList(props, context) {
      var _this;

      _classCallCheck(this, VirtualizedSectionList);

      _this = _possibleConstructorReturn(this, _getPrototypeOf(VirtualizedSectionList).call(this, props, context));

      _this._keyExtractor = function (item, index) {
        var info = _this._subExtractor(index);

        return info && info.key || String(index);
      };

      _this._convertViewable = function (viewable) {
        invariant(viewable.index != null, 'Received a broken ViewToken');

        var info = _this._subExtractor(viewable.index);

        if (!info) {
          return null;
        }

        var keyExtractor = info.section.keyExtractor || _this.props.keyExtractor;
        return _objectSpread({}, viewable, {
          index: info.index,
          key: keyExtractor(viewable.item, info.index),
          section: info.section
        });
      };

      _this._onViewableItemsChanged = function (_ref) {
        var viewableItems = _ref.viewableItems,
            changed = _ref.changed;

        if (_this.props.onViewableItemsChanged) {
          _this.props.onViewableItemsChanged({
            viewableItems: viewableItems.map(_this._convertViewable, _assertThisInitialized(_this)).filter(Boolean),
            changed: changed.map(_this._convertViewable, _assertThisInitialized(_this)).filter(Boolean)
          });
        }
      };

      _this._renderItem = function (_ref2) {
        var item = _ref2.item,
            index = _ref2.index;

        var info = _this._subExtractor(index);

        if (!info) {
          return null;
        }

        var infoIndex = info.index;

        if (infoIndex == null) {
          var section = info.section;

          if (info.header === true) {
            var renderSectionHeader = _this.props.renderSectionHeader;
            return renderSectionHeader ? renderSectionHeader({
              section: section
            }) : null;
          } else {
            var renderSectionFooter = _this.props.renderSectionFooter;
            return renderSectionFooter ? renderSectionFooter({
              section: section
            }) : null;
          }
        } else {
          var renderItem = info.section.renderItem || _this.props.renderItem;

          var SeparatorComponent = _this._getSeparatorComponent(index, info);

          invariant(renderItem, 'no renderItem!');
          return React.createElement(ItemWithSeparator, {
            SeparatorComponent: SeparatorComponent,
            LeadingSeparatorComponent: infoIndex === 0 ? _this.props.SectionSeparatorComponent : undefined,
            cellKey: info.key,
            index: infoIndex,
            item: item,
            leadingItem: info.leadingItem,
            leadingSection: info.leadingSection,
            onUpdateSeparator: _this._onUpdateSeparator,
            prevCellKey: (_this._subExtractor(index - 1) || {}).key,
            ref: function ref(_ref3) {
              _this._cellRefs[info.key] = _ref3;
            },
            renderItem: renderItem,
            section: info.section,
            trailingItem: info.trailingItem,
            trailingSection: info.trailingSection,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 332
            }
          });
        }
      };

      _this._onUpdateSeparator = function (key, newProps) {
        var ref = _this._cellRefs[key];
        ref && ref.updateSeparatorProps(newProps);
      };

      _this._cellRefs = {};

      _this._captureRef = function (ref) {
        _this._listRef = ref;
      };

      _this.state = _this._computeState(props);
      return _this;
    }

    _createClass(VirtualizedSectionList, [{
      key: "UNSAFE_componentWillReceiveProps",
      value: function UNSAFE_componentWillReceiveProps(nextProps) {
        this.setState(this._computeState(nextProps));
      }
    }, {
      key: "_computeState",
      value: function _computeState(props) {
        var offset = props.ListHeaderComponent ? 1 : 0;
        var stickyHeaderIndices = [];
        var itemCount = props.sections ? props.sections.reduce(function (v, section) {
          stickyHeaderIndices.push(v + offset);
          return v + props.getItemCount(section.data) + 2;
        }, 0) : 0;
        return {
          childProps: _objectSpread({}, props, {
            renderItem: this._renderItem,
            ItemSeparatorComponent: undefined,
            data: props.sections,
            getItemCount: function getItemCount() {
              return itemCount;
            },
            getItem: function getItem(sections, index) {
              return _getItem(props, sections, index);
            },
            keyExtractor: this._keyExtractor,
            onViewableItemsChanged: props.onViewableItemsChanged ? this._onViewableItemsChanged : undefined,
            stickyHeaderIndices: props.stickySectionHeadersEnabled ? stickyHeaderIndices : undefined
          })
        };
      }
    }, {
      key: "render",
      value: function render() {
        return React.createElement(VirtualizedList, _extends({}, this.state.childProps, {
          ref: this._captureRef,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 215
          }
        }));
      }
    }, {
      key: "_subExtractor",
      value: function _subExtractor(index) {
        var itemIndex = index;
        var _this$props = this.props,
            getItem = _this$props.getItem,
            getItemCount = _this$props.getItemCount,
            keyExtractor = _this$props.keyExtractor,
            sections = _this$props.sections;

        for (var i = 0; i < sections.length; i++) {
          var section = sections[i];
          var sectionData = section.data;
          var key = section.key || String(i);
          itemIndex -= 1;

          if (itemIndex >= getItemCount(sectionData) + 1) {
            itemIndex -= getItemCount(sectionData) + 1;
          } else if (itemIndex === -1) {
            return {
              section: section,
              key: key + ':header',
              index: null,
              header: true,
              trailingSection: sections[i + 1]
            };
          } else if (itemIndex === getItemCount(sectionData)) {
            return {
              section: section,
              key: key + ':footer',
              index: null,
              header: false,
              trailingSection: sections[i + 1]
            };
          } else {
            var extractor = section.keyExtractor || keyExtractor;
            return {
              section: section,
              key: key + ':' + extractor(getItem(sectionData, itemIndex), itemIndex),
              index: itemIndex,
              leadingItem: getItem(sectionData, itemIndex - 1),
              leadingSection: sections[i - 1],
              trailingItem: getItem(sectionData, itemIndex + 1),
              trailingSection: sections[i + 1]
            };
          }
        }
      }
    }, {
      key: "_getSeparatorComponent",
      value: function _getSeparatorComponent(index, info) {
        info = info || this._subExtractor(index);

        if (!info) {
          return null;
        }

        var ItemSeparatorComponent = info.section.ItemSeparatorComponent || this.props.ItemSeparatorComponent;
        var SectionSeparatorComponent = this.props.SectionSeparatorComponent;
        var isLastItemInList = index === this.state.childProps.getItemCount() - 1;
        var isLastItemInSection = info.index === this.props.getItemCount(info.section.data) - 1;

        if (SectionSeparatorComponent && isLastItemInSection) {
          return SectionSeparatorComponent;
        }

        if (ItemSeparatorComponent && !isLastItemInSection && !isLastItemInList) {
          return ItemSeparatorComponent;
        }

        return null;
      }
    }]);

    return VirtualizedSectionList;
  }(React.PureComponent);

  VirtualizedSectionList.defaultProps = _objectSpread({}, VirtualizedList.defaultProps, {
    data: []
  });

  var ItemWithSeparator = function (_React$Component) {
    _inherits(ItemWithSeparator, _React$Component);

    function ItemWithSeparator() {
      var _getPrototypeOf2;

      var _this2;

      _classCallCheck(this, ItemWithSeparator);

      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
        args[_key] = arguments[_key];
      }

      _this2 = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(ItemWithSeparator)).call.apply(_getPrototypeOf2, [this].concat(args)));
      _this2.state = {
        separatorProps: {
          highlighted: false,
          leadingItem: _this2.props.item,
          leadingSection: _this2.props.leadingSection,
          section: _this2.props.section,
          trailingItem: _this2.props.trailingItem,
          trailingSection: _this2.props.trailingSection
        },
        leadingSeparatorProps: {
          highlighted: false,
          leadingItem: _this2.props.leadingItem,
          leadingSection: _this2.props.leadingSection,
          section: _this2.props.section,
          trailingItem: _this2.props.item,
          trailingSection: _this2.props.trailingSection
        }
      };
      _this2._separators = {
        highlight: function highlight() {
          ['leading', 'trailing'].forEach(function (s) {
            return _this2._separators.updateProps(s, {
              highlighted: true
            });
          });
        },
        unhighlight: function unhighlight() {
          ['leading', 'trailing'].forEach(function (s) {
            return _this2._separators.updateProps(s, {
              highlighted: false
            });
          });
        },
        updateProps: function updateProps(select, newProps) {
          var _this2$props = _this2.props,
              LeadingSeparatorComponent = _this2$props.LeadingSeparatorComponent,
              cellKey = _this2$props.cellKey,
              prevCellKey = _this2$props.prevCellKey;

          if (select === 'leading' && LeadingSeparatorComponent != null) {
            _this2.setState(function (state) {
              return {
                leadingSeparatorProps: _objectSpread({}, state.leadingSeparatorProps, {}, newProps)
              };
            });
          } else {
            _this2.props.onUpdateSeparator(select === 'leading' && prevCellKey || cellKey, newProps);
          }
        }
      };
      return _this2;
    }

    _createClass(ItemWithSeparator, [{
      key: "updateSeparatorProps",
      value: function updateSeparatorProps(newProps) {
        this.setState(function (state) {
          return {
            separatorProps: _objectSpread({}, state.separatorProps, {}, newProps)
          };
        });
      }
    }, {
      key: "render",
      value: function render() {
        var _this$props2 = this.props,
            LeadingSeparatorComponent = _this$props2.LeadingSeparatorComponent,
            SeparatorComponent = _this$props2.SeparatorComponent,
            item = _this$props2.item,
            index = _this$props2.index,
            section = _this$props2.section;
        var element = this.props.renderItem({
          item: item,
          index: index,
          section: section,
          separators: this._separators
        });
        var leadingSeparator = LeadingSeparatorComponent && React.createElement(LeadingSeparatorComponent, _extends({}, this.state.leadingSeparatorProps, {
          __source: {
            fileName: _jsxFileName,
            lineNumber: 519
          }
        }));
        var separator = SeparatorComponent && React.createElement(SeparatorComponent, _extends({}, this.state.separatorProps, {
          __source: {
            fileName: _jsxFileName,
            lineNumber: 522
          }
        }));
        return leadingSeparator || separator ? React.createElement(View, {
          __source: {
            fileName: _jsxFileName,
            lineNumber: 528
          }
        }, leadingSeparator, element, separator) : element;
      }
    }], [{
      key: "getDerivedStateFromProps",
      value: function getDerivedStateFromProps(props, prevState) {
        return {
          separatorProps: _objectSpread({}, prevState.separatorProps, {
            leadingItem: props.item,
            leadingSection: props.leadingSection,
            section: props.section,
            trailingItem: props.trailingItem,
            trailingSection: props.trailingSection
          }),
          leadingSeparatorProps: _objectSpread({}, prevState.leadingSeparatorProps, {
            leadingItem: props.leadingItem,
            leadingSection: props.leadingSection,
            section: props.section,
            trailingItem: props.item,
            trailingSection: props.trailingSection
          })
        };
      }
    }]);

    return ItemWithSeparator;
  }(React.Component);

  function _getItem(props, sections, index) {
    if (!sections) {
      return null;
    }

    var itemIdx = index - 1;

    for (var i = 0; i < sections.length; i++) {
      var section = sections[i];
      var sectionData = section.data;
      var itemCount = props.getItemCount(sectionData);

      if (itemIdx === -1 || itemIdx === itemCount) {
        return section;
      } else if (itemIdx < itemCount) {
        return props.getItem(sectionData, itemIdx);
      } else {
        itemIdx -= itemCount + 2;
      }
    }

    return null;
  }

  module.exports = VirtualizedSectionList;
},322,[13,46,24,32,34,33,25,37,54,86,294,3],"node_modules/react-native/Libraries/Lists/VirtualizedSectionList.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var Text = _$$_REQUIRE(_dependencyMap[0], "../../../Text/Text");

  var createAnimatedComponent = _$$_REQUIRE(_dependencyMap[1], "../createAnimatedComponent");

  module.exports = createAnimatedComponent(Text);
},323,[235,291],"node_modules/react-native/Libraries/Animated/src/components/AnimatedText.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var View = _$$_REQUIRE(_dependencyMap[0], "../../../Components/View/View");

  var createAnimatedComponent = _$$_REQUIRE(_dependencyMap[1], "../createAnimatedComponent");

  module.exports = createAnimatedComponent(View);
},324,[86,291],"node_modules/react-native/Libraries/Animated/src/components/AnimatedView.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _require = _$$_REQUIRE(_dependencyMap[0], "./ReactNative"),
      __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = _require.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;

  var NativeMethodsMixin = __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.NativeMethodsMixin;
  module.exports = NativeMethodsMixin;
},325,[88],"node_modules/react-native/Libraries/Renderer/shims/NativeMethodsMixin.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");

  var _defineProperty = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/defineProperty");

  var _objectWithoutProperties = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/objectWithoutProperties");

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/createClass");

  var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/possibleConstructorReturn");

  var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/getPrototypeOf");

  var _inherits = _$$_REQUIRE(_dependencyMap[7], "@babel/runtime/helpers/inherits");

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native/Libraries/Components/CheckBox/CheckBox.android.js";

  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

  var React = _$$_REQUIRE(_dependencyMap[8], "react");

  var StyleSheet = _$$_REQUIRE(_dependencyMap[9], "../../StyleSheet/StyleSheet");

  var processColor = _$$_REQUIRE(_dependencyMap[10], "../../StyleSheet/processColor");

  var AndroidCheckBoxNativeComponent = _$$_REQUIRE(_dependencyMap[11], "./AndroidCheckBoxNativeComponent");

  var nullthrows = _$$_REQUIRE(_dependencyMap[12], "nullthrows");

  var setAndForwardRef = _$$_REQUIRE(_dependencyMap[13], "../../Utilities/setAndForwardRef");

  var CheckBox = function (_React$Component) {
    _inherits(CheckBox, _React$Component);

    function CheckBox() {
      var _getPrototypeOf2;

      var _this;

      _classCallCheck(this, CheckBox);

      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
        args[_key] = arguments[_key];
      }

      _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(CheckBox)).call.apply(_getPrototypeOf2, [this].concat(args)));
      _this._nativeRef = null;
      _this._setNativeRef = setAndForwardRef({
        getForwardedRef: function getForwardedRef() {
          return _this.props.forwardedRef;
        },
        setLocalRef: function setLocalRef(ref) {
          _this._nativeRef = ref;
        }
      });

      _this._onChange = function (event) {
        var _this$props$value;

        var value = (_this$props$value = _this.props.value) != null ? _this$props$value : false;
        nullthrows(_this._nativeRef).setNativeProps({
          value: value
        });
        _this.props.onChange && _this.props.onChange(event);
        _this.props.onValueChange && _this.props.onValueChange(event.nativeEvent.value);
      };

      return _this;
    }

    _createClass(CheckBox, [{
      key: "getTintColors",
      value: function getTintColors(tintColors) {
        return tintColors ? {
          true: processColor(tintColors.true),
          false: processColor(tintColors.false)
        } : undefined;
      }
    }, {
      key: "render",
      value: function render() {
        var _this$props$disabled, _this$props$value2;

        var _this$props = this.props,
            _ = _this$props.disabled,
            __ = _this$props.value,
            tintColors = _this$props.tintColors,
            style = _this$props.style,
            forwardedRef = _this$props.forwardedRef,
            props = _objectWithoutProperties(_this$props, ["disabled", "value", "tintColors", "style", "forwardedRef"]);

        var disabled = (_this$props$disabled = this.props.disabled) != null ? _this$props$disabled : false;
        var value = (_this$props$value2 = this.props.value) != null ? _this$props$value2 : false;

        var nativeProps = _objectSpread({}, props, {
          onStartShouldSetResponder: function onStartShouldSetResponder() {
            return true;
          },
          onResponderTerminationRequest: function onResponderTerminationRequest() {
            return false;
          },
          enabled: !disabled,
          on: value,
          tintColors: this.getTintColors(tintColors),
          style: [styles.rctCheckBox, style]
        });

        return React.createElement(AndroidCheckBoxNativeComponent, _extends({}, nativeProps, {
          ref: this._setNativeRef,
          onChange: this._onChange,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 192
          }
        }));
      }
    }]);

    return CheckBox;
  }(React.Component);

  var styles = StyleSheet.create({
    rctCheckBox: {
      height: 32,
      width: 32
    }
  });
  var CheckBoxWithRef = React.forwardRef(function CheckBoxWithRef(props, ref) {
    return React.createElement(CheckBox, _extends({}, props, {
      forwardedRef: ref,
      __source: {
        fileName: _jsxFileName,
        lineNumber: 214
      }
    }));
  });
  module.exports = CheckBoxWithRef;
},326,[13,46,52,24,25,32,34,37,54,60,80,327,249,328],"node_modules/react-native/Libraries/Components/CheckBox/CheckBox.android.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var requireNativeComponent = _$$_REQUIRE(_dependencyMap[0], "../../ReactNative/requireNativeComponent");

  module.exports = requireNativeComponent('AndroidCheckBox');
},327,[218],"node_modules/react-native/Libraries/Components/CheckBox/AndroidCheckBoxNativeComponent.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  function setAndForwardRef(_ref) {
    var getForwardedRef = _ref.getForwardedRef,
        setLocalRef = _ref.setLocalRef;
    return function forwardRef(ref) {
      var forwardedRef = getForwardedRef();
      setLocalRef(ref);

      if (typeof forwardedRef === 'function') {
        forwardedRef(ref);
      } else if (typeof forwardedRef === 'object' && forwardedRef != null) {
        forwardedRef.current = ref;
      }
    };
  }

  module.exports = setAndForwardRef;
},328,[],"node_modules/react-native/Libraries/Utilities/setAndForwardRef.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");

  var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");

  var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");

  var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native/Libraries/Components/DatePicker/DatePickerIOS.android.js";

  var React = _$$_REQUIRE(_dependencyMap[5], "react");

  var StyleSheet = _$$_REQUIRE(_dependencyMap[6], "../../StyleSheet/StyleSheet");

  var Text = _$$_REQUIRE(_dependencyMap[7], "../../Text/Text");

  var View = _$$_REQUIRE(_dependencyMap[8], "../View/View");

  var DummyDatePickerIOS = function (_React$Component) {
    _inherits(DummyDatePickerIOS, _React$Component);

    function DummyDatePickerIOS() {
      _classCallCheck(this, DummyDatePickerIOS);

      return _possibleConstructorReturn(this, _getPrototypeOf(DummyDatePickerIOS).apply(this, arguments));
    }

    _createClass(DummyDatePickerIOS, [{
      key: "render",
      value: function render() {
        return React.createElement(View, {
          style: [styles.dummyDatePickerIOS, this.props.style],
          __source: {
            fileName: _jsxFileName,
            lineNumber: 20
          }
        }, React.createElement(Text, {
          style: styles.datePickerText,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 21
          }
        }, "DatePickerIOS is not supported on this platform!"));
      }
    }]);

    return DummyDatePickerIOS;
  }(React.Component);

  var 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;
},329,[24,25,32,34,37,54,60,235,86],"node_modules/react-native/Libraries/Components/DatePicker/DatePickerIOS.android.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/interopRequireWildcard");

  var _extends2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/extends"));

  var _objectWithoutProperties2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/objectWithoutProperties"));

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf3 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "@babel/runtime/helpers/inherits"));

  var _AndroidDrawerLayoutNativeComponent = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[9], "./AndroidDrawerLayoutNativeComponent"));

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native/Libraries/Components/DrawerAndroid/DrawerLayoutAndroid.android.js";

  var Platform = _$$_REQUIRE(_dependencyMap[10], "../../Utilities/Platform");

  var React = _$$_REQUIRE(_dependencyMap[11], "react");

  var StatusBar = _$$_REQUIRE(_dependencyMap[12], "../StatusBar/StatusBar");

  var StyleSheet = _$$_REQUIRE(_dependencyMap[13], "../../StyleSheet/StyleSheet");

  var View = _$$_REQUIRE(_dependencyMap[14], "../View/View");

  var nullthrows = _$$_REQUIRE(_dependencyMap[15], "nullthrows");

  var dismissKeyboard = _$$_REQUIRE(_dependencyMap[16], "../../Utilities/dismissKeyboard");

  var DRAWER_STATES = ['Idle', 'Dragging', 'Settling'];

  var DrawerLayoutAndroid = function (_React$Component) {
    (0, _inherits2.default)(DrawerLayoutAndroid, _React$Component);

    function DrawerLayoutAndroid() {
      var _getPrototypeOf2;

      var _this;

      (0, _classCallCheck2.default)(this, DrawerLayoutAndroid);

      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
        args[_key] = arguments[_key];
      }

      _this = (0, _possibleConstructorReturn2.default)(this, (_getPrototypeOf2 = (0, _getPrototypeOf3.default)(DrawerLayoutAndroid)).call.apply(_getPrototypeOf2, [this].concat(args)));
      _this._nativeRef = React.createRef();
      _this.state = {
        statusBarBackgroundColor: null
      };

      _this._onDrawerSlide = function (event) {
        if (_this.props.onDrawerSlide) {
          _this.props.onDrawerSlide(event);
        }

        if (_this.props.keyboardDismissMode === 'on-drag') {
          dismissKeyboard();
        }
      };

      _this._onDrawerOpen = function () {
        if (_this.props.onDrawerOpen) {
          _this.props.onDrawerOpen();
        }
      };

      _this._onDrawerClose = function () {
        if (_this.props.onDrawerClose) {
          _this.props.onDrawerClose();
        }
      };

      _this._onDrawerStateChanged = function (event) {
        if (_this.props.onDrawerStateChanged) {
          _this.props.onDrawerStateChanged(DRAWER_STATES[event.nativeEvent.drawerState]);
        }
      };

      return _this;
    }

    (0, _createClass2.default)(DrawerLayoutAndroid, [{
      key: "render",
      value: function render() {
        var _this$props = this.props,
            onDrawerStateChanged = _this$props.onDrawerStateChanged,
            renderNavigationView = _this$props.renderNavigationView,
            onDrawerOpen = _this$props.onDrawerOpen,
            onDrawerClose = _this$props.onDrawerClose,
            props = (0, _objectWithoutProperties2.default)(_this$props, ["onDrawerStateChanged", "renderNavigationView", "onDrawerOpen", "onDrawerClose"]);
        var drawStatusBar = Platform.Version >= 21 && this.props.statusBarBackgroundColor;
        var drawerViewWrapper = React.createElement(View, {
          style: [styles.drawerSubview, {
            width: this.props.drawerWidth,
            backgroundColor: this.props.drawerBackgroundColor
          }],
          collapsable: false,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 185
          }
        }, renderNavigationView(), drawStatusBar && React.createElement(View, {
          style: styles.drawerStatusBar,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 195
          }
        }));
        var childrenWrapper = React.createElement(View, {
          style: styles.mainSubview,
          collapsable: false,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 199
          }
        }, drawStatusBar && React.createElement(StatusBar, {
          translucent: true,
          backgroundColor: this.props.statusBarBackgroundColor,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 201
          }
        }), drawStatusBar && React.createElement(View, {
          style: [styles.statusBar, {
            backgroundColor: this.props.statusBarBackgroundColor
          }],
          __source: {
            fileName: _jsxFileName,
            lineNumber: 207
          }
        }), this.props.children);
        return React.createElement(_AndroidDrawerLayoutNativeComponent.default, (0, _extends2.default)({}, 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,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 218
          }
        }), childrenWrapper, drawerViewWrapper);
      }
    }, {
      key: "openDrawer",
      value: function openDrawer() {
        _AndroidDrawerLayoutNativeComponent.Commands.openDrawer(nullthrows(this._nativeRef.current));
      }
    }, {
      key: "closeDrawer",
      value: function closeDrawer() {
        _AndroidDrawerLayoutNativeComponent.Commands.closeDrawer(nullthrows(this._nativeRef.current));
      }
    }, {
      key: "blur",
      value: function blur() {
        nullthrows(this._nativeRef.current).blur();
      }
    }, {
      key: "focus",
      value: function focus() {
        nullthrows(this._nativeRef.current).focus();
      }
    }, {
      key: "measure",
      value: function measure(callback) {
        nullthrows(this._nativeRef.current).measure(callback);
      }
    }, {
      key: "measureInWindow",
      value: function measureInWindow(callback) {
        nullthrows(this._nativeRef.current).measureInWindow(callback);
      }
    }, {
      key: "measureLayout",
      value: function measureLayout(relativeToNativeNode, onSuccess, onFail) {
        nullthrows(this._nativeRef.current).measureLayout(relativeToNativeNode, onSuccess, onFail);
      }
    }, {
      key: "setNativeProps",
      value: function setNativeProps(nativeProps) {
        nullthrows(this._nativeRef.current).setNativeProps(nativeProps);
      }
    }], [{
      key: "positions",
      get: function get() {
        console.warn('Setting DrawerLayoutAndroid drawerPosition using `DrawerLayoutAndroid.positions` is deprecated. Instead pass the string value "left" or "right"');
        return {
          Left: 'left',
          Right: 'right'
        };
      }
    }]);
    return DrawerLayoutAndroid;
  }(React.Component);

  DrawerLayoutAndroid.defaultProps = {
    drawerBackgroundColor: 'white'
  };
  var 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;
},330,[1,9,13,52,24,25,32,34,37,331,48,54,333,60,86,249,307],"node_modules/react-native/Libraries/Components/DrawerAndroid/DrawerLayoutAndroid.android.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireWildcard");

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = exports.Commands = void 0;

  var _codegenNativeCommands = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/Utilities/codegenNativeCommands"));

  var _codegenNativeComponent = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "react-native/Libraries/Utilities/codegenNativeComponent"));

  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[4], "react"));

  var Commands = (0, _codegenNativeCommands.default)({
    supportedCommands: ['openDrawer', 'closeDrawer']
  });
  exports.Commands = Commands;

  var _default = (0, _codegenNativeComponent.default)('AndroidDrawerLayout');

  exports.default = _default;
},331,[9,1,332,222,54],"node_modules/react-native/Libraries/Components/DrawerAndroid/AndroidDrawerLayoutNativeComponent.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _ReactNative = _$$_REQUIRE(_dependencyMap[0], "../../Libraries/Renderer/shims/ReactNative");

  function codegenNativeCommands(options) {
    var commandObj = {};
    options.supportedCommands.forEach(function (command) {
      commandObj[command] = function (ref) {
        for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
          args[_key - 1] = arguments[_key];
        }

        (0, _ReactNative.dispatchCommand)(ref, command, args);
      };
    });
    return commandObj;
  }

  var _default = codegenNativeCommands;
  exports.default = _default;
},332,[88],"node_modules/react-native/Libraries/Utilities/codegenNativeCommands.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf3 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits"));

  var _extends2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/extends"));

  var _NativeStatusBarManager = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "./NativeStatusBarManager"));

  var _NativeStatusBarManag;

  var Platform = _$$_REQUIRE(_dependencyMap[8], "../../Utilities/Platform");

  var React = _$$_REQUIRE(_dependencyMap[9], "react");

  var processColor = _$$_REQUIRE(_dependencyMap[10], "../../StyleSheet/processColor");

  function mergePropsStack(propsStack, defaultValues) {
    return propsStack.reduce(function (prev, cur) {
      for (var prop in cur) {
        if (cur[prop] != null) {
          prev[prop] = cur[prop];
        }
      }

      return prev;
    }, (0, _extends2.default)({}, defaultValues));
  }

  function createStackEntry(props) {
    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
    };
  }

  var StatusBar = function (_React$Component) {
    (0, _inherits2.default)(StatusBar, _React$Component);

    function StatusBar() {
      var _getPrototypeOf2;

      var _this;

      (0, _classCallCheck2.default)(this, StatusBar);

      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
        args[_key] = arguments[_key];
      }

      _this = (0, _possibleConstructorReturn2.default)(this, (_getPrototypeOf2 = (0, _getPrototypeOf3.default)(StatusBar)).call.apply(_getPrototypeOf2, [this].concat(args)));
      _this._stackEntry = null;
      return _this;
    }

    (0, _createClass2.default)(StatusBar, [{
      key: "componentDidMount",
      value: function componentDidMount() {
        this._stackEntry = StatusBar.pushStackEntry(this.props);
      }
    }, {
      key: "componentWillUnmount",
      value: function componentWillUnmount() {
        StatusBar.popStackEntry(this._stackEntry);
      }
    }, {
      key: "componentDidUpdate",
      value: function componentDidUpdate() {
        this._stackEntry = StatusBar.replaceStackEntry(this._stackEntry, this.props);
      }
    }, {
      key: "render",
      value: function render() {
        return null;
      }
    }], [{
      key: "setHidden",
      value: function setHidden(hidden, animation) {
        animation = animation || 'none';
        StatusBar._defaultProps.hidden.value = hidden;

        if ("android" === 'ios') {
          _NativeStatusBarManager.default.setHidden(hidden, animation);
        } else if ("android" === 'android') {
          _NativeStatusBarManager.default.setHidden(hidden);
        }
      }
    }, {
      key: "setBarStyle",
      value: function setBarStyle(style, animated) {
        animated = animated || false;
        StatusBar._defaultProps.barStyle.value = style;

        if ("android" === 'ios') {
          _NativeStatusBarManager.default.setStyle(style, animated);
        } else if ("android" === 'android') {
          _NativeStatusBarManager.default.setStyle(style);
        }
      }
    }, {
      key: "setNetworkActivityIndicatorVisible",
      value: function setNetworkActivityIndicatorVisible(visible) {
        if ("android" !== 'ios') {
          console.warn('`setNetworkActivityIndicatorVisible` is only available on iOS');
          return;
        }

        StatusBar._defaultProps.networkActivityIndicatorVisible = visible;

        _NativeStatusBarManager.default.setNetworkActivityIndicatorVisible(visible);
      }
    }, {
      key: "setBackgroundColor",
      value: function setBackgroundColor(color, animated) {
        if ("android" !== 'android') {
          console.warn('`setBackgroundColor` is only available on Android');
          return;
        }

        animated = animated || false;
        StatusBar._defaultProps.backgroundColor.value = color;
        var processedColor = processColor(color);

        if (processedColor == null) {
          console.warn("`StatusBar.setBackgroundColor`: Color " + color + " parsed to null or undefined");
          return;
        }

        _NativeStatusBarManager.default.setColor(processedColor, animated);
      }
    }, {
      key: "setTranslucent",
      value: function setTranslucent(translucent) {
        if ("android" !== 'android') {
          console.warn('`setTranslucent` is only available on Android');
          return;
        }

        StatusBar._defaultProps.translucent = translucent;

        _NativeStatusBarManager.default.setTranslucent(translucent);
      }
    }, {
      key: "pushStackEntry",
      value: function pushStackEntry(props) {
        var entry = createStackEntry(props);

        StatusBar._propsStack.push(entry);

        StatusBar._updatePropsStack();

        return entry;
      }
    }, {
      key: "popStackEntry",
      value: function popStackEntry(entry) {
        var index = StatusBar._propsStack.indexOf(entry);

        if (index !== -1) {
          StatusBar._propsStack.splice(index, 1);
        }

        StatusBar._updatePropsStack();
      }
    }, {
      key: "replaceStackEntry",
      value: function replaceStackEntry(entry, props) {
        var newEntry = createStackEntry(props);

        var index = StatusBar._propsStack.indexOf(entry);

        if (index !== -1) {
          StatusBar._propsStack[index] = newEntry;
        }

        StatusBar._updatePropsStack();

        return newEntry;
      }
    }]);
    return StatusBar;
  }(React.Component);

  StatusBar._propsStack = [];
  StatusBar._defaultProps = createStackEntry({
    animated: false,
    showHideTransition: 'fade',
    backgroundColor: (_NativeStatusBarManag = _NativeStatusBarManager.default.getConstants().DEFAULT_BACKGROUND_COLOR) != null ? _NativeStatusBarManag : 'black',
    barStyle: 'default',
    translucent: false,
    hidden: false,
    networkActivityIndicatorVisible: false
  });
  StatusBar._updateImmediate = null;
  StatusBar._currentValues = null;
  StatusBar.currentHeight = _NativeStatusBarManager.default.getConstants().HEIGHT;
  StatusBar.defaultProps = {
    animated: false,
    showHideTransition: 'fade'
  };

  StatusBar._updatePropsStack = function () {
    clearImmediate(StatusBar._updateImmediate);
    StatusBar._updateImmediate = setImmediate(function () {
      var oldProps = StatusBar._currentValues;
      var mergedProps = mergePropsStack(StatusBar._propsStack, StatusBar._defaultProps);

      if ("android" === 'ios') {
        if (!oldProps || oldProps.barStyle.value !== mergedProps.barStyle.value) {
          _NativeStatusBarManager.default.setStyle(mergedProps.barStyle.value, mergedProps.barStyle.animated || false);
        }

        if (!oldProps || oldProps.hidden.value !== mergedProps.hidden.value) {
          _NativeStatusBarManager.default.setHidden(mergedProps.hidden.value, mergedProps.hidden.animated ? mergedProps.hidden.transition : 'none');
        }

        if (!oldProps || oldProps.networkActivityIndicatorVisible !== mergedProps.networkActivityIndicatorVisible) {
          _NativeStatusBarManager.default.setNetworkActivityIndicatorVisible(mergedProps.networkActivityIndicatorVisible);
        }
      } else if ("android" === 'android') {
        if (!oldProps || oldProps.barStyle.value !== mergedProps.barStyle.value) {
          _NativeStatusBarManager.default.setStyle(mergedProps.barStyle.value);
        }

        if (!oldProps || oldProps.backgroundColor.value !== mergedProps.backgroundColor.value) {
          var processedColor = processColor(mergedProps.backgroundColor.value);

          if (processedColor == null) {
            console.warn("`StatusBar._updatePropsStack`: Color " + mergedProps.backgroundColor.value + " parsed to null or undefined");
          } else {
            _NativeStatusBarManager.default.setColor(processedColor, mergedProps.backgroundColor.animated);
          }
        }

        if (!oldProps || oldProps.hidden.value !== mergedProps.hidden.value) {
          _NativeStatusBarManager.default.setHidden(mergedProps.hidden.value);
        }

        if (!oldProps || oldProps.translucent !== mergedProps.translucent) {
          _NativeStatusBarManager.default.setTranslucent(mergedProps.translucent);
        }
      }

      StatusBar._currentValues = mergedProps;
    });
  };

  module.exports = StatusBar;
},333,[1,24,25,32,34,37,13,334,48,54,80],"node_modules/react-native/Libraries/Components/StatusBar/StatusBar.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireWildcard");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[1], "../../TurboModule/TurboModuleRegistry"));

  var _default = TurboModuleRegistry.getEnforcing('StatusBarManager');

  exports.default = _default;
},334,[9,11],"node_modules/react-native/Libraries/Components/StatusBar/NativeStatusBarManager.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");

  var _objectWithoutProperties = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/objectWithoutProperties");

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass");

  var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/possibleConstructorReturn");

  var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/getPrototypeOf");

  var _inherits = _$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits");

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native/Libraries/Image/ImageBackground.js";

  var Image = _$$_REQUIRE(_dependencyMap[7], "./Image");

  var React = _$$_REQUIRE(_dependencyMap[8], "react");

  var StyleSheet = _$$_REQUIRE(_dependencyMap[9], "../StyleSheet/StyleSheet");

  var View = _$$_REQUIRE(_dependencyMap[10], "../Components/View/View");

  var ImageBackground = function (_React$Component) {
    _inherits(ImageBackground, _React$Component);

    function ImageBackground() {
      var _getPrototypeOf2;

      var _this;

      _classCallCheck(this, ImageBackground);

      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
        args[_key] = arguments[_key];
      }

      _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(ImageBackground)).call.apply(_getPrototypeOf2, [this].concat(args)));
      _this._viewRef = null;

      _this._captureRef = function (ref) {
        _this._viewRef = ref;
      };

      return _this;
    }

    _createClass(ImageBackground, [{
      key: "setNativeProps",
      value: function setNativeProps(props) {
        var viewRef = this._viewRef;

        if (viewRef) {
          viewRef.setNativeProps(props);
        }
      }
    }, {
      key: "render",
      value: function render() {
        var _this$props = this.props,
            children = _this$props.children,
            style = _this$props.style,
            imageStyle = _this$props.imageStyle,
            imageRef = _this$props.imageRef,
            props = _objectWithoutProperties(_this$props, ["children", "style", "imageStyle", "imageRef"]);

        return React.createElement(View, {
          accessibilityIgnoresInvertColors: true,
          style: style,
          ref: this._captureRef,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 60
          }
        }, React.createElement(Image, _extends({}, props, {
          style: [StyleSheet.absoluteFill, {
            width: style.width,
            height: style.height
          }, imageStyle],
          ref: imageRef,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 64
          }
        })), children);
      }
    }]);

    return ImageBackground;
  }(React.Component);

  module.exports = ImageBackground;
},335,[13,52,24,25,32,34,37,314,54,60,86],"node_modules/react-native/Libraries/Image/ImageBackground.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits"));

  var _RCTInputAccessoryViewNativeComponent = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "./RCTInputAccessoryViewNativeComponent"));

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native/Libraries/Components/TextInput/InputAccessoryView.js";

  var DeprecatedColorPropType = _$$_REQUIRE(_dependencyMap[7], "../../DeprecatedPropTypes/DeprecatedColorPropType");

  var Platform = _$$_REQUIRE(_dependencyMap[8], "../../Utilities/Platform");

  var React = _$$_REQUIRE(_dependencyMap[9], "react");

  var StyleSheet = _$$_REQUIRE(_dependencyMap[10], "../../StyleSheet/StyleSheet");

  var InputAccessoryView = function (_React$Component) {
    (0, _inherits2.default)(InputAccessoryView, _React$Component);

    function InputAccessoryView() {
      (0, _classCallCheck2.default)(this, InputAccessoryView);
      return (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(InputAccessoryView).apply(this, arguments));
    }

    (0, _createClass2.default)(InputAccessoryView, [{
      key: "render",
      value: function render() {
        if ("android" !== 'ios') {
          console.warn('<InputAccessoryView> is only supported on iOS.');
        }

        if (React.Children.count(this.props.children) === 0) {
          return null;
        }

        return React.createElement(_RCTInputAccessoryViewNativeComponent.default, {
          style: [this.props.style, styles.container],
          nativeID: this.props.nativeID,
          backgroundColor: this.props.backgroundColor,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 101
          }
        }, this.props.children);
      }
    }]);
    return InputAccessoryView;
  }(React.Component);

  var styles = StyleSheet.create({
    container: {
      position: 'absolute'
    }
  });
  module.exports = InputAccessoryView;
},336,[1,24,25,32,34,37,337,66,48,54,60],"node_modules/react-native/Libraries/Components/TextInput/InputAccessoryView.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _codegenNativeComponent = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../../Utilities/codegenNativeComponent"));

  var _default = (0, _codegenNativeComponent.default)('RCTInputAccessoryView');

  exports.default = _default;
},337,[1,222],"node_modules/react-native/Libraries/Components/TextInput/RCTInputAccessoryViewNativeComponent.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");

  var _objectWithoutProperties = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/objectWithoutProperties");

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass");

  var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/possibleConstructorReturn");

  var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/getPrototypeOf");

  var _inherits = _$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits");

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native/Libraries/Components/Keyboard/KeyboardAvoidingView.js";

  var Keyboard = _$$_REQUIRE(_dependencyMap[7], "./Keyboard");

  var LayoutAnimation = _$$_REQUIRE(_dependencyMap[8], "../../LayoutAnimation/LayoutAnimation");

  var Platform = _$$_REQUIRE(_dependencyMap[9], "../../Utilities/Platform");

  var React = _$$_REQUIRE(_dependencyMap[10], "react");

  var StyleSheet = _$$_REQUIRE(_dependencyMap[11], "../../StyleSheet/StyleSheet");

  var View = _$$_REQUIRE(_dependencyMap[12], "../View/View");

  var KeyboardAvoidingView = function (_React$Component) {
    _inherits(KeyboardAvoidingView, _React$Component);

    function KeyboardAvoidingView(props) {
      var _this;

      _classCallCheck(this, KeyboardAvoidingView);

      _this = _possibleConstructorReturn(this, _getPrototypeOf(KeyboardAvoidingView).call(this, props));
      _this._frame = null;
      _this._subscriptions = [];
      _this._initialFrameHeight = 0;

      _this._onKeyboardChange = function (event) {
        if (event == null) {
          _this.setState({
            bottom: 0
          });

          return;
        }

        var duration = event.duration,
            easing = event.easing,
            endCoordinates = event.endCoordinates;

        var height = _this._relativeKeyboardHeight(endCoordinates);

        if (_this.state.bottom === height) {
          return;
        }

        if (duration && easing) {
          LayoutAnimation.configureNext({
            duration: duration > 10 ? duration : 10,
            update: {
              duration: duration > 10 ? duration : 10,
              type: LayoutAnimation.Types[easing] || 'keyboard'
            }
          });
        }

        _this.setState({
          bottom: height
        });
      };

      _this._onLayout = function (event) {
        _this._frame = event.nativeEvent.layout;

        if (!_this._initialFrameHeight) {
          _this._initialFrameHeight = _this._frame.height;
        }
      };

      _this.state = {
        bottom: 0
      };
      _this.viewRef = React.createRef();
      return _this;
    }

    _createClass(KeyboardAvoidingView, [{
      key: "_relativeKeyboardHeight",
      value: function _relativeKeyboardHeight(keyboardFrame) {
        var frame = this._frame;

        if (!frame || !keyboardFrame) {
          return 0;
        }

        var keyboardY = keyboardFrame.screenY - this.props.keyboardVerticalOffset;
        return Math.max(frame.y + frame.height - keyboardY, 0);
      }
    }, {
      key: "componentDidMount",
      value: function componentDidMount() {
        if ("android" === 'ios') {
          this._subscriptions = [Keyboard.addListener('keyboardWillChangeFrame', this._onKeyboardChange)];
        } else {
          this._subscriptions = [Keyboard.addListener('keyboardDidHide', this._onKeyboardChange), Keyboard.addListener('keyboardDidShow', this._onKeyboardChange)];
        }
      }
    }, {
      key: "componentWillUnmount",
      value: function componentWillUnmount() {
        this._subscriptions.forEach(function (subscription) {
          subscription.remove();
        });
      }
    }, {
      key: "render",
      value: function render() {
        var _this$props = this.props,
            behavior = _this$props.behavior,
            children = _this$props.children,
            contentContainerStyle = _this$props.contentContainerStyle,
            enabled = _this$props.enabled,
            keyboardVerticalOffset = _this$props.keyboardVerticalOffset,
            style = _this$props.style,
            props = _objectWithoutProperties(_this$props, ["behavior", "children", "contentContainerStyle", "enabled", "keyboardVerticalOffset", "style"]);

        var bottomHeight = enabled ? this.state.bottom : 0;

        switch (behavior) {
          case 'height':
            var heightStyle;

            if (this._frame != null && this.state.bottom > 0) {
              heightStyle = {
                height: this._initialFrameHeight - bottomHeight,
                flex: 0
              };
            }

            return React.createElement(View, _extends({
              ref: this.viewRef,
              style: StyleSheet.compose(style, heightStyle),
              onLayout: this._onLayout
            }, props, {
              __source: {
                fileName: _jsxFileName,
                lineNumber: 174
              }
            }), children);

          case 'position':
            return React.createElement(View, _extends({
              ref: this.viewRef,
              style: style,
              onLayout: this._onLayout
            }, props, {
              __source: {
                fileName: _jsxFileName,
                lineNumber: 188
              }
            }), React.createElement(View, {
              style: StyleSheet.compose(contentContainerStyle, {
                bottom: bottomHeight
              }),
              __source: {
                fileName: _jsxFileName,
                lineNumber: 193
              }
            }, children));

          case 'padding':
            return React.createElement(View, _extends({
              ref: this.viewRef,
              style: StyleSheet.compose(style, {
                paddingBottom: bottomHeight
              }),
              onLayout: this._onLayout
            }, props, {
              __source: {
                fileName: _jsxFileName,
                lineNumber: 207
              }
            }), children);

          default:
            return React.createElement(View, _extends({
              ref: this.viewRef,
              onLayout: this._onLayout,
              style: style
            }, props, {
              __source: {
                fileName: _jsxFileName,
                lineNumber: 221
              }
            }), children);
        }
      }
    }]);

    return KeyboardAvoidingView;
  }(React.Component);

  KeyboardAvoidingView.defaultProps = {
    enabled: true,
    keyboardVerticalOffset: 0
  };
  module.exports = KeyboardAvoidingView;
},338,[13,52,24,25,32,34,37,304,306,48,54,60,86],"node_modules/react-native/Libraries/Components/Keyboard/KeyboardAvoidingView.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  module.exports = _$$_REQUIRE(_dependencyMap[0], "../UnimplementedViews/UnimplementedView");
},339,[340],"node_modules/react-native/Libraries/Components/MaskedView/MaskedViewIOS.android.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");

  var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");

  var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");

  var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native/Libraries/Components/UnimplementedViews/UnimplementedView.js";

  var React = _$$_REQUIRE(_dependencyMap[5], "react");

  var StyleSheet = _$$_REQUIRE(_dependencyMap[6], "../../StyleSheet/StyleSheet");

  var UnimplementedView = function (_React$Component) {
    _inherits(UnimplementedView, _React$Component);

    function UnimplementedView() {
      _classCallCheck(this, UnimplementedView);

      return _possibleConstructorReturn(this, _getPrototypeOf(UnimplementedView).apply(this, arguments));
    }

    _createClass(UnimplementedView, [{
      key: "render",
      value: function render() {
        var View = _$$_REQUIRE(_dependencyMap[7], "../View/View");

        return React.createElement(View, {
          style: [styles.unimplementedView, this.props.style],
          __source: {
            fileName: _jsxFileName,
            lineNumber: 24
          }
        }, this.props.children);
      }
    }]);

    return UnimplementedView;
  }(React.Component);

  var styles = StyleSheet.create({
    unimplementedView: __DEV__ ? {
      alignSelf: 'flex-start',
      borderColor: 'red',
      borderWidth: 1
    } : {}
  });
  module.exports = UnimplementedView;
},340,[24,25,32,34,37,54,60,86],"node_modules/react-native/Libraries/Components/UnimplementedViews/UnimplementedView.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _defineProperty2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/defineProperty"));

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits"));

  var _NativeModalManager = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "./NativeModalManager"));

  var _RCTModalHostViewNativeComponent = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "./RCTModalHostViewNativeComponent"));

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native/Libraries/Modal/Modal.js",
      _container;

  var AppContainer = _$$_REQUIRE(_dependencyMap[9], "../ReactNative/AppContainer");

  var I18nManager = _$$_REQUIRE(_dependencyMap[10], "../ReactNative/I18nManager");

  var NativeEventEmitter = _$$_REQUIRE(_dependencyMap[11], "../EventEmitter/NativeEventEmitter");

  var Platform = _$$_REQUIRE(_dependencyMap[12], "../Utilities/Platform");

  var React = _$$_REQUIRE(_dependencyMap[13], "react");

  var PropTypes = _$$_REQUIRE(_dependencyMap[14], "prop-types");

  var ScrollView = _$$_REQUIRE(_dependencyMap[15], "../Components/ScrollView/ScrollView");

  var StyleSheet = _$$_REQUIRE(_dependencyMap[16], "../StyleSheet/StyleSheet");

  var View = _$$_REQUIRE(_dependencyMap[17], "../Components/View/View");

  var ModalEventEmitter = "android" === 'ios' && _NativeModalManager.default != null ? new NativeEventEmitter(_NativeModalManager.default) : null;
  var uniqueModalIdentifier = 0;

  var Modal = function (_React$Component) {
    (0, _inherits2.default)(Modal, _React$Component);

    function Modal(props) {
      var _this;

      (0, _classCallCheck2.default)(this, Modal);
      _this = (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(Modal).call(this, props));

      Modal._confirmProps(props);

      _this._identifier = uniqueModalIdentifier++;
      return _this;
    }

    (0, _createClass2.default)(Modal, [{
      key: "getChildContext",
      value: function getChildContext() {
        return {
          virtualizedList: null
        };
      }
    }, {
      key: "componentDidMount",
      value: function componentDidMount() {
        var _this2 = this;

        if (ModalEventEmitter) {
          this._eventSubscription = ModalEventEmitter.addListener('modalDismissed', function (event) {
            if (event.modalID === _this2._identifier && _this2.props.onDismiss) {
              _this2.props.onDismiss();
            }
          });
        }
      }
    }, {
      key: "componentWillUnmount",
      value: function componentWillUnmount() {
        if (this._eventSubscription) {
          this._eventSubscription.remove();
        }
      }
    }, {
      key: "UNSAFE_componentWillReceiveProps",
      value: function UNSAFE_componentWillReceiveProps(nextProps) {
        Modal._confirmProps(nextProps);
      }
    }, {
      key: "render",
      value: function render() {
        if (this.props.visible !== true) {
          return null;
        }

        var containerStyles = {
          backgroundColor: this.props.transparent ? 'transparent' : 'white'
        };
        var animationType = this.props.animationType;

        if (!animationType) {
          animationType = 'none';

          if (this.props.animated) {
            animationType = 'slide';
          }
        }

        var presentationStyle = this.props.presentationStyle;

        if (!presentationStyle) {
          presentationStyle = 'fullScreen';

          if (this.props.transparent) {
            presentationStyle = 'overFullScreen';
          }
        }

        var innerChildren = __DEV__ ? React.createElement(AppContainer, {
          rootTag: this.context.rootTag,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 250
          }
        }, this.props.children) : this.props.children;
        return React.createElement(_RCTModalHostViewNativeComponent.default, {
          animationType: animationType,
          presentationStyle: presentationStyle,
          transparent: this.props.transparent,
          hardwareAccelerated: this.props.hardwareAccelerated,
          onRequestClose: this.props.onRequestClose,
          onShow: this.props.onShow,
          identifier: this._identifier,
          style: styles.modal,
          onStartShouldSetResponder: this._shouldSetResponder,
          supportedOrientations: this.props.supportedOrientations,
          onOrientationChange: this.props.onOrientationChange,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 258
          }
        }, React.createElement(ScrollView.Context.Provider, {
          value: null,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 270
          }
        }, React.createElement(View, {
          style: [styles.container, containerStyles],
          __source: {
            fileName: _jsxFileName,
            lineNumber: 271
          }
        }, innerChildren)));
      }
    }, {
      key: "_shouldSetResponder",
      value: function _shouldSetResponder() {
        return true;
      }
    }], [{
      key: "_confirmProps",
      value: function _confirmProps(props) {
        if (props.presentationStyle && props.presentationStyle !== 'overFullScreen' && props.transparent) {
          console.warn("Modal with '" + props.presentationStyle + "' presentation style and 'transparent' value is not supported.");
        }
      }
    }]);
    return Modal;
  }(React.Component);

  Modal.defaultProps = {
    visible: true,
    hardwareAccelerated: false
  };
  Modal.contextTypes = {
    rootTag: PropTypes.number
  };
  Modal.childContextTypes = {
    virtualizedList: PropTypes.object
  };
  var side = I18nManager.getConstants().isRTL ? 'right' : 'left';
  var styles = StyleSheet.create({
    modal: {
      position: 'absolute'
    },
    container: (_container = {}, (0, _defineProperty2.default)(_container, side, 0), (0, _defineProperty2.default)(_container, "top", 0), (0, _defineProperty2.default)(_container, "flex", 1), _container)
  });
  module.exports = Modal;
},341,[1,46,24,25,32,34,37,342,343,344,351,134,48,54,69,300,60,86],"node_modules/react-native/Libraries/Modal/Modal.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireWildcard");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[1], "../TurboModule/TurboModuleRegistry"));

  var _default = TurboModuleRegistry.get('ModalManager');

  exports.default = _default;
},342,[9,11],"node_modules/react-native/Libraries/Modal/NativeModalManager.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _codegenNativeComponent = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../Utilities/codegenNativeComponent"));

  var _default = (0, _codegenNativeComponent.default)('ModalHostView', {
    interfaceOnly: true,
    paperComponentName: 'RCTModalHostView'
  });

  exports.default = _default;
},343,[1,222],"node_modules/react-native/Libraries/Modal/RCTModalHostViewNativeComponent.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");

  var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");

  var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");

  var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native/Libraries/ReactNative/AppContainer.js";

  var EmitterSubscription = _$$_REQUIRE(_dependencyMap[5], "../vendor/emitter/EmitterSubscription");

  var PropTypes = _$$_REQUIRE(_dependencyMap[6], "prop-types");

  var RCTDeviceEventEmitter = _$$_REQUIRE(_dependencyMap[7], "../EventEmitter/RCTDeviceEventEmitter");

  var React = _$$_REQUIRE(_dependencyMap[8], "react");

  var ReactNative = _$$_REQUIRE(_dependencyMap[9], "../Renderer/shims/ReactNative");

  var RootTagContext = _$$_REQUIRE(_dependencyMap[10], "./RootTagContext");

  var StyleSheet = _$$_REQUIRE(_dependencyMap[11], "../StyleSheet/StyleSheet");

  var View = _$$_REQUIRE(_dependencyMap[12], "../Components/View/View");

  var AppContainer = function (_React$Component) {
    _inherits(AppContainer, _React$Component);

    function AppContainer() {
      var _getPrototypeOf2;

      var _this;

      _classCallCheck(this, AppContainer);

      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
        args[_key] = arguments[_key];
      }

      _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(AppContainer)).call.apply(_getPrototypeOf2, [this].concat(args)));
      _this.state = {
        inspector: null,
        mainKey: 1
      };
      _this._subscription = null;
      return _this;
    }

    _createClass(AppContainer, [{
      key: "getChildContext",
      value: function getChildContext() {
        return {
          rootTag: this.props.rootTag
        };
      }
    }, {
      key: "componentDidMount",
      value: function componentDidMount() {
        var _this2 = this;

        if (__DEV__) {
          if (!global.__RCTProfileIsProfiling) {
            this._subscription = RCTDeviceEventEmitter.addListener('toggleElementInspector', function () {
              var Inspector = _$$_REQUIRE(_dependencyMap[13], "../Inspector/Inspector");

              var inspector = _this2.state.inspector ? null : React.createElement(Inspector, {
                inspectedViewTag: ReactNative.findNodeHandle(_this2._mainRef),
                onRequestRerenderApp: function onRequestRerenderApp(updateInspectedViewTag) {
                  _this2.setState(function (s) {
                    return {
                      mainKey: s.mainKey + 1
                    };
                  }, function () {
                    return updateInspectedViewTag(ReactNative.findNodeHandle(_this2._mainRef));
                  });
                },
                __source: {
                  fileName: _jsxFileName,
                  lineNumber: 65
                }
              });

              _this2.setState({
                inspector: inspector
              });
            });
          }
        }
      }
    }, {
      key: "componentWillUnmount",
      value: function componentWillUnmount() {
        if (this._subscription != null) {
          this._subscription.remove();
        }
      }
    }, {
      key: "render",
      value: function render() {
        var _this3 = this;

        var yellowBox = null;

        if (__DEV__) {
          if (!global.__RCTProfileIsProfiling) {
            var YellowBox = _$$_REQUIRE(_dependencyMap[14], "../YellowBox/YellowBox");

            yellowBox = React.createElement(YellowBox, {
              __source: {
                fileName: _jsxFileName,
                lineNumber: 96
              }
            });
          }
        }

        var innerView = React.createElement(View, {
          collapsable: !this.state.inspector,
          key: this.state.mainKey,
          pointerEvents: "box-none",
          style: styles.appContainer,
          ref: function ref(_ref) {
            _this3._mainRef = _ref;
          },
          __source: {
            fileName: _jsxFileName,
            lineNumber: 101
          }
        }, this.props.children);
        var Wrapper = this.props.WrapperComponent;

        if (Wrapper != null) {
          innerView = React.createElement(Wrapper, {
            __source: {
              fileName: _jsxFileName,
              lineNumber: 115
            }
          }, innerView);
        }

        return React.createElement(RootTagContext.Provider, {
          value: this.props.rootTag,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 118
          }
        }, React.createElement(View, {
          style: styles.appContainer,
          pointerEvents: "box-none",
          __source: {
            fileName: _jsxFileName,
            lineNumber: 119
          }
        }, innerView, yellowBox, this.state.inspector));
      }
    }]);

    return AppContainer;
  }(React.Component);

  AppContainer.childContextTypes = {
    rootTag: PropTypes.number
  };
  var styles = StyleSheet.create({
    appContainer: {
      flex: 1
    }
  });

  if (__DEV__) {
    if (!global.__RCTProfileIsProfiling) {
      var YellowBox = _$$_REQUIRE(_dependencyMap[14], "../YellowBox/YellowBox");

      YellowBox.install();
    }
  }

  module.exports = AppContainer;
},344,[24,25,32,34,37,40,69,31,54,88,345,60,86,346,364],"node_modules/react-native/Libraries/ReactNative/AppContainer.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var React = _$$_REQUIRE(_dependencyMap[0], "react");

  module.exports = React.createContext(0);
},345,[54],"node_modules/react-native/Libraries/ReactNative/RootTagContext.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");

  var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");

  var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");

  var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native/Libraries/Inspector/Inspector.js";

  var Dimensions = _$$_REQUIRE(_dependencyMap[5], "../Utilities/Dimensions");

  var InspectorOverlay = _$$_REQUIRE(_dependencyMap[6], "./InspectorOverlay");

  var InspectorPanel = _$$_REQUIRE(_dependencyMap[7], "./InspectorPanel");

  var Platform = _$$_REQUIRE(_dependencyMap[8], "../Utilities/Platform");

  var React = _$$_REQUIRE(_dependencyMap[9], "react");

  var ReactNative = _$$_REQUIRE(_dependencyMap[10], "../Renderer/shims/ReactNative");

  var StyleSheet = _$$_REQUIRE(_dependencyMap[11], "../StyleSheet/StyleSheet");

  var Touchable = _$$_REQUIRE(_dependencyMap[12], "../Components/Touchable/Touchable");

  var UIManager = _$$_REQUIRE(_dependencyMap[13], "../ReactNative/UIManager");

  var View = _$$_REQUIRE(_dependencyMap[14], "../Components/View/View");

  var invariant = _$$_REQUIRE(_dependencyMap[15], "invariant");

  var hook = window.__REACT_DEVTOOLS_GLOBAL_HOOK__;
  var renderers = findRenderers();
  hook.resolveRNStyle = _$$_REQUIRE(_dependencyMap[16], "../StyleSheet/flattenStyle");

  function findRenderers() {
    var allRenderers = Object.keys(hook._renderers).map(function (key) {
      return hook._renderers[key];
    });
    invariant(allRenderers.length >= 1, 'Expected to find at least one React Native renderer on DevTools hook.');
    return allRenderers;
  }

  function getInspectorDataForViewTag(touchedViewTag) {
    for (var i = 0; i < renderers.length; i++) {
      var renderer = renderers[i];

      if (Object.prototype.hasOwnProperty.call(renderer, 'getInspectorDataForViewTag')) {
        var inspectorData = renderer.getInspectorDataForViewTag(touchedViewTag);

        if (inspectorData.hierarchy.length > 0) {
          return inspectorData;
        }
      }
    }

    throw new Error('Expected to find at least one React renderer.');
  }

  var Inspector = function (_React$Component) {
    _inherits(Inspector, _React$Component);

    function Inspector(_props) {
      var _this;

      _classCallCheck(this, Inspector);

      _this = _possibleConstructorReturn(this, _getPrototypeOf(Inspector).call(this, _props));

      _this.attachToDevtools = function (agent) {
        var _hideWait = null;
        var hlSub = agent.sub('highlight', function (_ref) {
          var node = _ref.node,
              name = _ref.name,
              props = _ref.props;
          clearTimeout(_hideWait);

          if (typeof node !== 'number') {
            node = ReactNative.findNodeHandle(node);
          }

          UIManager.measure(node, function (x, y, width, height, left, top) {
            _this.setState({
              hierarchy: [],
              inspected: {
                frame: {
                  left: left,
                  top: top,
                  width: width,
                  height: height
                },
                style: props ? props.style : {}
              }
            });
          });
        });
        var hideSub = agent.sub('hideHighlight', function () {
          if (_this.state.inspected === null) {
            return;
          }

          _hideWait = setTimeout(function () {
            _this.setState({
              inspected: null
            });
          }, 100);
        });
        _this._subs = [hlSub, hideSub];
        agent.on('shutdown', function () {
          _this.setState({
            devtoolsAgent: null
          });

          _this._subs = null;
        });

        _this.setState({
          devtoolsAgent: agent
        });
      };

      _this.state = {
        devtoolsAgent: null,
        hierarchy: null,
        panelPos: 'bottom',
        inspecting: true,
        perfing: false,
        inspected: null,
        selection: null,
        inspectedViewTag: _this.props.inspectedViewTag,
        networking: false
      };
      return _this;
    }

    _createClass(Inspector, [{
      key: "componentDidMount",
      value: function componentDidMount() {
        hook.on('react-devtools', this.attachToDevtools);

        if (hook.reactDevtoolsAgent) {
          this.attachToDevtools(hook.reactDevtoolsAgent);
        }
      }
    }, {
      key: "componentWillUnmount",
      value: function componentWillUnmount() {
        if (this._subs) {
          this._subs.map(function (fn) {
            return fn();
          });
        }

        hook.off('react-devtools', this.attachToDevtools);
      }
    }, {
      key: "UNSAFE_componentWillReceiveProps",
      value: function UNSAFE_componentWillReceiveProps(newProps) {
        this.setState({
          inspectedViewTag: newProps.inspectedViewTag
        });
      }
    }, {
      key: "setSelection",
      value: function setSelection(i) {
        var _this2 = this;

        var hierarchyItem = this.state.hierarchy[i];

        var _hierarchyItem$getIns = hierarchyItem.getInspectorData(ReactNative.findNodeHandle),
            measure = _hierarchyItem$getIns.measure,
            props = _hierarchyItem$getIns.props,
            source = _hierarchyItem$getIns.source;

        measure(function (x, y, width, height, left, top) {
          _this2.setState({
            inspected: {
              frame: {
                left: left,
                top: top,
                width: width,
                height: height
              },
              style: props.style,
              source: source
            },
            selection: i
          });
        });
      }
    }, {
      key: "onTouchViewTag",
      value: function onTouchViewTag(touchedViewTag, frame, pointerY) {
        var _getInspectorDataForV = getInspectorDataForViewTag(touchedViewTag),
            hierarchy = _getInspectorDataForV.hierarchy,
            props = _getInspectorDataForV.props,
            selection = _getInspectorDataForV.selection,
            source = _getInspectorDataForV.source;

        if (this.state.devtoolsAgent) {
          var offsetFromLeaf = hierarchy.length - 1 - selection;
          this.state.devtoolsAgent.selectFromDOMNode(touchedViewTag, true, offsetFromLeaf);
        }

        this.setState({
          panelPos: pointerY > Dimensions.get('window').height / 2 ? 'top' : 'bottom',
          selection: selection,
          hierarchy: hierarchy,
          inspected: {
            style: props.style,
            frame: frame,
            source: source
          }
        });
      }
    }, {
      key: "setPerfing",
      value: function setPerfing(val) {
        this.setState({
          perfing: val,
          inspecting: false,
          inspected: null,
          networking: false
        });
      }
    }, {
      key: "setInspecting",
      value: function setInspecting(val) {
        this.setState({
          inspecting: val,
          inspected: null
        });
      }
    }, {
      key: "setTouchTargeting",
      value: function setTouchTargeting(val) {
        var _this3 = this;

        Touchable.TOUCH_TARGET_DEBUG = val;
        this.props.onRequestRerenderApp(function (inspectedViewTag) {
          _this3.setState({
            inspectedViewTag: inspectedViewTag
          });
        });
      }
    }, {
      key: "setNetworking",
      value: function setNetworking(val) {
        this.setState({
          networking: val,
          perfing: false,
          inspecting: false,
          inspected: null
        });
      }
    }, {
      key: "render",
      value: function render() {
        var panelContainerStyle = this.state.panelPos === 'bottom' ? {
          bottom: 0
        } : {
          top: "android" === 'ios' ? 20 : 0
        };
        return React.createElement(View, {
          style: styles.container,
          pointerEvents: "box-none",
          __source: {
            fileName: _jsxFileName,
            lineNumber: 248
          }
        }, this.state.inspecting && React.createElement(InspectorOverlay, {
          inspected: this.state.inspected,
          inspectedViewTag: this.state.inspectedViewTag,
          onTouchViewTag: this.onTouchViewTag.bind(this),
          __source: {
            fileName: _jsxFileName,
            lineNumber: 250
          }
        }), React.createElement(View, {
          style: [styles.panelContainer, panelContainerStyle],
          __source: {
            fileName: _jsxFileName,
            lineNumber: 256
          }
        }, React.createElement(InspectorPanel, {
          devtoolsIsOpen: !!this.state.devtoolsAgent,
          inspecting: this.state.inspecting,
          perfing: this.state.perfing,
          setPerfing: this.setPerfing.bind(this),
          setInspecting: this.setInspecting.bind(this),
          inspected: this.state.inspected,
          hierarchy: this.state.hierarchy,
          selection: this.state.selection,
          setSelection: this.setSelection.bind(this),
          touchTargeting: Touchable.TOUCH_TARGET_DEBUG,
          setTouchTargeting: this.setTouchTargeting.bind(this),
          networking: this.state.networking,
          setNetworking: this.setNetworking.bind(this),
          __source: {
            fileName: _jsxFileName,
            lineNumber: 257
          }
        })));
      }
    }]);

    return Inspector;
  }(React.Component);

  var styles = StyleSheet.create({
    container: {
      position: 'absolute',
      backgroundColor: 'transparent',
      top: 0,
      left: 0,
      right: 0,
      bottom: 0
    },
    panelContainer: {
      position: 'absolute',
      left: 0,
      right: 0
    }
  });
  module.exports = Inspector;
},346,[24,25,32,34,37,62,347,353,48,54,88,60,241,43,86,3,85],"node_modules/react-native/Libraries/Inspector/Inspector.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");

  var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");

  var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");

  var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native/Libraries/Inspector/InspectorOverlay.js";

  var Dimensions = _$$_REQUIRE(_dependencyMap[5], "../Utilities/Dimensions");

  var ElementBox = _$$_REQUIRE(_dependencyMap[6], "./ElementBox");

  var React = _$$_REQUIRE(_dependencyMap[7], "react");

  var StyleSheet = _$$_REQUIRE(_dependencyMap[8], "../StyleSheet/StyleSheet");

  var UIManager = _$$_REQUIRE(_dependencyMap[9], "../ReactNative/UIManager");

  var View = _$$_REQUIRE(_dependencyMap[10], "../Components/View/View");

  var InspectorOverlay = function (_React$Component) {
    _inherits(InspectorOverlay, _React$Component);

    function InspectorOverlay() {
      var _getPrototypeOf2;

      var _this;

      _classCallCheck(this, InspectorOverlay);

      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
        args[_key] = arguments[_key];
      }

      _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(InspectorOverlay)).call.apply(_getPrototypeOf2, [this].concat(args)));

      _this.findViewForTouchEvent = function (e) {
        var _e$nativeEvent$touche = e.nativeEvent.touches[0],
            locationX = _e$nativeEvent$touche.locationX,
            locationY = _e$nativeEvent$touche.locationY;
        UIManager.findSubviewIn(_this.props.inspectedViewTag, [locationX, locationY], function (nativeViewTag, left, top, width, height) {
          _this.props.onTouchViewTag(nativeViewTag, {
            left: left,
            top: top,
            width: width,
            height: height
          }, locationY);
        });
      };

      _this.shouldSetResponser = function (e) {
        _this.findViewForTouchEvent(e);

        return true;
      };

      return _this;
    }

    _createClass(InspectorOverlay, [{
      key: "render",
      value: function render() {
        var content = null;

        if (this.props.inspected) {
          content = React.createElement(ElementBox, {
            frame: this.props.inspected.frame,
            style: this.props.inspected.style,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 59
            }
          });
        }

        return React.createElement(View, {
          onStartShouldSetResponder: this.shouldSetResponser,
          onResponderMove: this.findViewForTouchEvent,
          style: [styles.inspector, {
            height: Dimensions.get('window').height
          }],
          __source: {
            fileName: _jsxFileName,
            lineNumber: 67
          }
        }, content);
      }
    }]);

    return InspectorOverlay;
  }(React.Component);

  var styles = StyleSheet.create({
    inspector: {
      backgroundColor: 'transparent',
      position: 'absolute',
      left: 0,
      top: 0,
      right: 0
    }
  });
  module.exports = InspectorOverlay;
},347,[24,25,32,34,37,62,348,54,60,43,86],"node_modules/react-native/Libraries/Inspector/InspectorOverlay.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");

  var _defineProperty = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/defineProperty");

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass");

  var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/possibleConstructorReturn");

  var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/getPrototypeOf");

  var _inherits = _$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits");

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native/Libraries/Inspector/ElementBox.js";

  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

  var BorderBox = _$$_REQUIRE(_dependencyMap[7], "./BorderBox");

  var Dimensions = _$$_REQUIRE(_dependencyMap[8], "../Utilities/Dimensions");

  var React = _$$_REQUIRE(_dependencyMap[9], "react");

  var StyleSheet = _$$_REQUIRE(_dependencyMap[10], "../StyleSheet/StyleSheet");

  var View = _$$_REQUIRE(_dependencyMap[11], "../Components/View/View");

  var flattenStyle = _$$_REQUIRE(_dependencyMap[12], "../StyleSheet/flattenStyle");

  var resolveBoxStyle = _$$_REQUIRE(_dependencyMap[13], "./resolveBoxStyle");

  var ElementBox = function (_React$Component) {
    _inherits(ElementBox, _React$Component);

    function ElementBox() {
      _classCallCheck(this, ElementBox);

      return _possibleConstructorReturn(this, _getPrototypeOf(ElementBox).apply(this, arguments));
    }

    _createClass(ElementBox, [{
      key: "render",
      value: function render() {
        var style = flattenStyle(this.props.style) || {};
        var margin = resolveBoxStyle('margin', style);
        var padding = resolveBoxStyle('padding', style);

        var frameStyle = _objectSpread({}, this.props.frame);

        var contentStyle = {
          width: this.props.frame.width,
          height: this.props.frame.height
        };

        if (margin != null) {
          margin = resolveRelativeSizes(margin);
          frameStyle.top -= margin.top;
          frameStyle.left -= margin.left;
          frameStyle.height += margin.top + margin.bottom;
          frameStyle.width += margin.left + margin.right;

          if (margin.top < 0) {
            contentStyle.height += margin.top;
          }

          if (margin.bottom < 0) {
            contentStyle.height += margin.bottom;
          }

          if (margin.left < 0) {
            contentStyle.width += margin.left;
          }

          if (margin.right < 0) {
            contentStyle.width += margin.right;
          }
        }

        if (padding != null) {
          padding = resolveRelativeSizes(padding);
          contentStyle.width -= padding.left + padding.right;
          contentStyle.height -= padding.top + padding.bottom;
        }

        return React.createElement(View, {
          style: [styles.frame, frameStyle],
          pointerEvents: "none",
          __source: {
            fileName: _jsxFileName,
            lineNumber: 64
          }
        }, React.createElement(BorderBox, {
          box: margin,
          style: styles.margin,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 65
          }
        }, React.createElement(BorderBox, {
          box: padding,
          style: styles.padding,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 66
          }
        }, React.createElement(View, {
          style: [styles.content, contentStyle],
          __source: {
            fileName: _jsxFileName,
            lineNumber: 67
          }
        }))));
      }
    }]);

    return ElementBox;
  }(React.Component);

  var styles = StyleSheet.create({
    frame: {
      position: 'absolute'
    },
    content: {
      backgroundColor: 'rgba(200, 230, 255, 0.8)'
    },
    padding: {
      borderColor: 'rgba(77, 255, 0, 0.3)'
    },
    margin: {
      borderColor: 'rgba(255, 132, 0, 0.3)'
    }
  });

  function resolveRelativeSizes(style) {
    var resolvedStyle = _extends({}, style);

    resolveSizeInPlace(resolvedStyle, 'top', 'height');
    resolveSizeInPlace(resolvedStyle, 'right', 'width');
    resolveSizeInPlace(resolvedStyle, 'bottom', 'height');
    resolveSizeInPlace(resolvedStyle, 'left', 'width');
    return resolvedStyle;
  }

  function resolveSizeInPlace(style, direction, dimension) {
    if (style[direction] !== null && typeof style[direction] === 'string') {
      if (style[direction].indexOf('%') !== -1) {
        style[direction] = parseFloat(style[direction]) / 100.0 * Dimensions.get('window')[dimension];
      }

      if (style[direction] === 'auto') {
        style[direction] = 0;
      }
    }
  }

  module.exports = ElementBox;
},348,[13,46,24,25,32,34,37,349,62,54,60,86,85,350],"node_modules/react-native/Libraries/Inspector/ElementBox.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");

  var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");

  var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");

  var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native/Libraries/Inspector/BorderBox.js";

  var React = _$$_REQUIRE(_dependencyMap[5], "react");

  var View = _$$_REQUIRE(_dependencyMap[6], "../Components/View/View");

  var BorderBox = function (_React$Component) {
    _inherits(BorderBox, _React$Component);

    function BorderBox() {
      _classCallCheck(this, BorderBox);

      return _possibleConstructorReturn(this, _getPrototypeOf(BorderBox).apply(this, arguments));
    }

    _createClass(BorderBox, [{
      key: "render",
      value: function render() {
        var box = this.props.box;

        if (!box) {
          return this.props.children;
        }

        var style = {
          borderTopWidth: box.top,
          borderBottomWidth: box.bottom,
          borderLeftWidth: box.left,
          borderRightWidth: box.right
        };
        return React.createElement(View, {
          style: [style, this.props.style],
          __source: {
            fileName: _jsxFileName,
            lineNumber: 28
          }
        }, this.props.children);
      }
    }]);

    return BorderBox;
  }(React.Component);

  module.exports = BorderBox;
},349,[24,25,32,34,37,54,86],"node_modules/react-native/Libraries/Inspector/BorderBox.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var I18nManager = _$$_REQUIRE(_dependencyMap[0], "../ReactNative/I18nManager");

  function resolveBoxStyle(prefix, style) {
    var hasParts = false;
    var result = {
      bottom: 0,
      left: 0,
      right: 0,
      top: 0
    };
    var styleForAll = style[prefix];

    if (styleForAll != null) {
      for (var _i = 0, _Object$keys = Object.keys(result); _i < _Object$keys.length; _i++) {
        var key = _Object$keys[_i];
        result[key] = styleForAll;
      }

      hasParts = true;
    }

    var styleForHorizontal = style[prefix + 'Horizontal'];

    if (styleForHorizontal != null) {
      result.left = styleForHorizontal;
      result.right = styleForHorizontal;
      hasParts = true;
    } else {
      var styleForLeft = style[prefix + 'Left'];

      if (styleForLeft != null) {
        result.left = styleForLeft;
        hasParts = true;
      }

      var styleForRight = style[prefix + 'Right'];

      if (styleForRight != null) {
        result.right = styleForRight;
        hasParts = true;
      }

      var styleForEnd = style[prefix + 'End'];

      if (styleForEnd != null) {
        var constants = I18nManager.getConstants();

        if (constants.isRTL && constants.doLeftAndRightSwapInRTL) {
          result.left = styleForEnd;
        } else {
          result.right = styleForEnd;
        }

        hasParts = true;
      }

      var styleForStart = style[prefix + 'Start'];

      if (styleForStart != null) {
        var _constants = I18nManager.getConstants();

        if (_constants.isRTL && _constants.doLeftAndRightSwapInRTL) {
          result.right = styleForStart;
        } else {
          result.left = styleForStart;
        }

        hasParts = true;
      }
    }

    var styleForVertical = style[prefix + 'Vertical'];

    if (styleForVertical != null) {
      result.bottom = styleForVertical;
      result.top = styleForVertical;
      hasParts = true;
    } else {
      var styleForBottom = style[prefix + 'Bottom'];

      if (styleForBottom != null) {
        result.bottom = styleForBottom;
        hasParts = true;
      }

      var styleForTop = style[prefix + 'Top'];

      if (styleForTop != null) {
        result.top = styleForTop;
        hasParts = true;
      }
    }

    return hasParts ? result : null;
  }

  module.exports = resolveBoxStyle;
},350,[351],"node_modules/react-native/Libraries/Inspector/resolveBoxStyle.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _NativeI18nManager = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./NativeI18nManager"));

  var i18nConstants = _NativeI18nManager.default ? _NativeI18nManager.default.getConstants() : {
    isRTL: false,
    doLeftAndRightSwapInRTL: true
  };
  module.exports = {
    getConstants: function getConstants() {
      return i18nConstants;
    },
    allowRTL: function allowRTL(shouldAllow) {
      if (!_NativeI18nManager.default) {
        return;
      }

      _NativeI18nManager.default.allowRTL(shouldAllow);
    },
    forceRTL: function forceRTL(shouldForce) {
      if (!_NativeI18nManager.default) {
        return;
      }

      _NativeI18nManager.default.forceRTL(shouldForce);
    },
    swapLeftAndRightInRTL: function swapLeftAndRightInRTL(flipStyles) {
      if (!_NativeI18nManager.default) {
        return;
      }

      _NativeI18nManager.default.swapLeftAndRightInRTL(flipStyles);
    },
    isRTL: i18nConstants.isRTL,
    doLeftAndRightSwapInRTL: i18nConstants.doLeftAndRightSwapInRTL
  };
},351,[1,352],"node_modules/react-native/Libraries/ReactNative/I18nManager.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireWildcard");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[1], "../TurboModule/TurboModuleRegistry"));

  var _default = TurboModuleRegistry.get('I18nManager');

  exports.default = _default;
},352,[9,11],"node_modules/react-native/Libraries/ReactNative/NativeI18nManager.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");

  var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");

  var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");

  var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native/Libraries/Inspector/InspectorPanel.js";

  var ElementProperties = _$$_REQUIRE(_dependencyMap[5], "./ElementProperties");

  var NetworkOverlay = _$$_REQUIRE(_dependencyMap[6], "./NetworkOverlay");

  var PerformanceOverlay = _$$_REQUIRE(_dependencyMap[7], "./PerformanceOverlay");

  var React = _$$_REQUIRE(_dependencyMap[8], "react");

  var ScrollView = _$$_REQUIRE(_dependencyMap[9], "../Components/ScrollView/ScrollView");

  var StyleSheet = _$$_REQUIRE(_dependencyMap[10], "../StyleSheet/StyleSheet");

  var Text = _$$_REQUIRE(_dependencyMap[11], "../Text/Text");

  var TouchableHighlight = _$$_REQUIRE(_dependencyMap[12], "../Components/Touchable/TouchableHighlight");

  var View = _$$_REQUIRE(_dependencyMap[13], "../Components/View/View");

  var InspectorPanel = function (_React$Component) {
    _inherits(InspectorPanel, _React$Component);

    function InspectorPanel() {
      _classCallCheck(this, InspectorPanel);

      return _possibleConstructorReturn(this, _getPrototypeOf(InspectorPanel).apply(this, arguments));
    }

    _createClass(InspectorPanel, [{
      key: "renderWaiting",
      value: function renderWaiting() {
        if (this.props.inspecting) {
          return React.createElement(Text, {
            style: styles.waitingText,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 57
            }
          }, "Tap something to inspect it");
        }

        return React.createElement(Text, {
          style: styles.waitingText,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 60
          }
        }, "Nothing is inspected");
      }
    }, {
      key: "render",
      value: function render() {
        var contents;

        if (this.props.inspected) {
          contents = React.createElement(ScrollView, {
            style: styles.properties,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 67
            }
          }, React.createElement(ElementProperties, {
            style: this.props.inspected.style,
            frame: this.props.inspected.frame,
            source: this.props.inspected.source,
            hierarchy: this.props.hierarchy,
            selection: this.props.selection,
            setSelection: this.props.setSelection,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 68
            }
          }));
        } else if (this.props.perfing) {
          contents = React.createElement(PerformanceOverlay, {
            __source: {
              fileName: _jsxFileName,
              lineNumber: 80
            }
          });
        } else if (this.props.networking) {
          contents = React.createElement(NetworkOverlay, {
            __source: {
              fileName: _jsxFileName,
              lineNumber: 82
            }
          });
        } else {
          contents = React.createElement(View, {
            style: styles.waiting,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 84
            }
          }, this.renderWaiting());
        }

        return React.createElement(View, {
          style: styles.container,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 87
          }
        }, !this.props.devtoolsIsOpen && contents, React.createElement(View, {
          style: styles.buttonRow,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 89
          }
        }, React.createElement(InspectorPanelButton, {
          title: 'Inspect',
          pressed: this.props.inspecting,
          onClick: this.props.setInspecting,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 90
          }
        }), React.createElement(InspectorPanelButton, {
          title: 'Perf',
          pressed: this.props.perfing,
          onClick: this.props.setPerfing,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 95
          }
        }), React.createElement(InspectorPanelButton, {
          title: 'Network',
          pressed: this.props.networking,
          onClick: this.props.setNetworking,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 100
          }
        }), React.createElement(InspectorPanelButton, {
          title: 'Touchables',
          pressed: this.props.touchTargeting,
          onClick: this.props.setTouchTargeting,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 105
          }
        })));
      }
    }]);

    return InspectorPanel;
  }(React.Component);

  var InspectorPanelButton = function (_React$Component2) {
    _inherits(InspectorPanelButton, _React$Component2);

    function InspectorPanelButton() {
      _classCallCheck(this, InspectorPanelButton);

      return _possibleConstructorReturn(this, _getPrototypeOf(InspectorPanelButton).apply(this, arguments));
    }

    _createClass(InspectorPanelButton, [{
      key: "render",
      value: function render() {
        var _this = this;

        return React.createElement(TouchableHighlight, {
          onPress: function onPress() {
            return _this.props.onClick(!_this.props.pressed);
          },
          style: [styles.button, this.props.pressed && styles.buttonPressed],
          __source: {
            fileName: _jsxFileName,
            lineNumber: 125
          }
        }, React.createElement(Text, {
          style: styles.buttonText,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 128
          }
        }, this.props.title));
      }
    }]);

    return InspectorPanelButton;
  }(React.Component);

  var styles = StyleSheet.create({
    buttonRow: {
      flexDirection: 'row'
    },
    button: {
      backgroundColor: 'rgba(0, 0, 0, 0.3)',
      margin: 2,
      height: 30,
      justifyContent: 'center',
      alignItems: 'center'
    },
    buttonPressed: {
      backgroundColor: 'rgba(255, 255, 255, 0.3)'
    },
    buttonText: {
      textAlign: 'center',
      color: 'white',
      margin: 5
    },
    container: {
      backgroundColor: 'rgba(0, 0, 0, 0.7)'
    },
    properties: {
      height: 200
    },
    waiting: {
      height: 100
    },
    waitingText: {
      fontSize: 20,
      textAlign: 'center',
      marginVertical: 20,
      color: 'white'
    }
  });
  module.exports = InspectorPanel;
},353,[24,25,32,34,37,354,360,363,54,300,60,235,357,86],"node_modules/react-native/Libraries/Inspector/InspectorPanel.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");

  var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");

  var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");

  var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native/Libraries/Inspector/ElementProperties.js";

  var BoxInspector = _$$_REQUIRE(_dependencyMap[5], "./BoxInspector");

  var React = _$$_REQUIRE(_dependencyMap[6], "react");

  var StyleInspector = _$$_REQUIRE(_dependencyMap[7], "./StyleInspector");

  var StyleSheet = _$$_REQUIRE(_dependencyMap[8], "../StyleSheet/StyleSheet");

  var Text = _$$_REQUIRE(_dependencyMap[9], "../Text/Text");

  var TouchableHighlight = _$$_REQUIRE(_dependencyMap[10], "../Components/Touchable/TouchableHighlight");

  var TouchableWithoutFeedback = _$$_REQUIRE(_dependencyMap[11], "../Components/Touchable/TouchableWithoutFeedback");

  var View = _$$_REQUIRE(_dependencyMap[12], "../Components/View/View");

  var flattenStyle = _$$_REQUIRE(_dependencyMap[13], "../StyleSheet/flattenStyle");

  var mapWithSeparator = _$$_REQUIRE(_dependencyMap[14], "../Utilities/mapWithSeparator");

  var openFileInEditor = _$$_REQUIRE(_dependencyMap[15], "../Core/Devtools/openFileInEditor");

  var ElementProperties = function (_React$Component) {
    _inherits(ElementProperties, _React$Component);

    function ElementProperties() {
      _classCallCheck(this, ElementProperties);

      return _possibleConstructorReturn(this, _getPrototypeOf(ElementProperties).apply(this, arguments));
    }

    _createClass(ElementProperties, [{
      key: "render",
      value: function render() {
        var _this = this;

        var style = flattenStyle(this.props.style);
        var selection = this.props.selection;
        var openFileButton;
        var source = this.props.source;

        var _ref = source || {},
            fileName = _ref.fileName,
            lineNumber = _ref.lineNumber;

        if (fileName && lineNumber) {
          var parts = fileName.split('/');
          var fileNameShort = parts[parts.length - 1];
          openFileButton = React.createElement(TouchableHighlight, {
            style: styles.openButton,
            onPress: openFileInEditor.bind(null, fileName, lineNumber),
            __source: {
              fileName: _jsxFileName,
              lineNumber: 51
            }
          }, React.createElement(Text, {
            style: styles.openButtonTitle,
            numberOfLines: 1,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 54
            }
          }, fileNameShort, ":", lineNumber));
        }

        return React.createElement(TouchableWithoutFeedback, {
          __source: {
            fileName: _jsxFileName,
            lineNumber: 63
          }
        }, React.createElement(View, {
          style: styles.info,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 64
          }
        }, React.createElement(View, {
          style: styles.breadcrumb,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 65
          }
        }, mapWithSeparator(this.props.hierarchy, function (hierarchyItem, i) {
          return React.createElement(TouchableHighlight, {
            key: 'item-' + i,
            style: [styles.breadItem, i === selection && styles.selected],
            onPress: function onPress() {
              return _this.props.setSelection(i);
            },
            __source: {
              fileName: _jsxFileName,
              lineNumber: 69
            }
          }, React.createElement(Text, {
            style: styles.breadItemText,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 74
            }
          }, hierarchyItem.name));
        }, function (i) {
          return React.createElement(Text, {
            key: 'sep-' + i,
            style: styles.breadSep,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 78
            }
          }, "\u25B8");
        })), React.createElement(View, {
          style: styles.row,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 84
          }
        }, React.createElement(View, {
          style: styles.col,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 85
          }
        }, React.createElement(StyleInspector, {
          style: style,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 86
          }
        }), openFileButton), React.createElement(BoxInspector, {
          style: style,
          frame: this.props.frame,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 89
          }
        }))));
      }
    }]);

    return ElementProperties;
  }(React.Component);

  var styles = StyleSheet.create({
    breadSep: {
      fontSize: 8,
      color: 'white'
    },
    breadcrumb: {
      flexDirection: 'row',
      flexWrap: 'wrap',
      alignItems: 'flex-start',
      marginBottom: 5
    },
    selected: {
      borderColor: 'white',
      borderRadius: 5
    },
    breadItem: {
      borderWidth: 1,
      borderColor: 'transparent',
      marginHorizontal: 2
    },
    breadItemText: {
      fontSize: 10,
      color: 'white',
      marginHorizontal: 5
    },
    row: {
      flexDirection: 'row',
      alignItems: 'center',
      justifyContent: 'space-between'
    },
    col: {
      flex: 1
    },
    info: {
      padding: 10
    },
    openButton: {
      padding: 10,
      backgroundColor: '#000',
      marginVertical: 5,
      marginRight: 5,
      borderRadius: 2
    },
    openButtonTitle: {
      color: 'white',
      fontSize: 8
    }
  });
  module.exports = ElementProperties;
},354,[24,25,32,34,37,355,54,356,60,235,357,251,86,85,358,359],"node_modules/react-native/Libraries/Inspector/ElementProperties.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");

  var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");

  var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");

  var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native/Libraries/Inspector/BoxInspector.js";

  var React = _$$_REQUIRE(_dependencyMap[5], "react");

  var StyleSheet = _$$_REQUIRE(_dependencyMap[6], "../StyleSheet/StyleSheet");

  var Text = _$$_REQUIRE(_dependencyMap[7], "../Text/Text");

  var View = _$$_REQUIRE(_dependencyMap[8], "../Components/View/View");

  var resolveBoxStyle = _$$_REQUIRE(_dependencyMap[9], "./resolveBoxStyle");

  var blank = {
    top: 0,
    left: 0,
    right: 0,
    bottom: 0
  };

  var BoxInspector = function (_React$Component) {
    _inherits(BoxInspector, _React$Component);

    function BoxInspector() {
      _classCallCheck(this, BoxInspector);

      return _possibleConstructorReturn(this, _getPrototypeOf(BoxInspector).apply(this, arguments));
    }

    _createClass(BoxInspector, [{
      key: "render",
      value: function render() {
        var frame = this.props.frame;
        var style = this.props.style;
        var margin = style && resolveBoxStyle('margin', style) || blank;
        var padding = style && resolveBoxStyle('padding', style) || blank;
        return React.createElement(BoxContainer, {
          title: "margin",
          titleStyle: styles.marginLabel,
          box: margin,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 34
          }
        }, React.createElement(BoxContainer, {
          title: "padding",
          box: padding,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 35
          }
        }, React.createElement(View, {
          __source: {
            fileName: _jsxFileName,
            lineNumber: 36
          }
        }, React.createElement(Text, {
          style: styles.innerText,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 37
          }
        }, "(", (frame.left || 0).toFixed(1), ", ", (frame.top || 0).toFixed(1), ")"), React.createElement(Text, {
          style: styles.innerText,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 40
          }
        }, (frame.width || 0).toFixed(1), " \xD7", ' ', (frame.height || 0).toFixed(1)))));
      }
    }]);

    return BoxInspector;
  }(React.Component);

  var BoxContainer = function (_React$Component2) {
    _inherits(BoxContainer, _React$Component2);

    function BoxContainer() {
      _classCallCheck(this, BoxContainer);

      return _possibleConstructorReturn(this, _getPrototypeOf(BoxContainer).apply(this, arguments));
    }

    _createClass(BoxContainer, [{
      key: "render",
      value: function render() {
        var box = this.props.box;
        return React.createElement(View, {
          style: styles.box,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 55
          }
        }, React.createElement(View, {
          style: styles.row,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 56
          }
        }, React.createElement(Text, {
          style: [this.props.titleStyle, styles.label],
          __source: {
            fileName: _jsxFileName,
            lineNumber: 58
          }
        }, this.props.title), React.createElement(Text, {
          style: styles.boxText,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 61
          }
        }, box.top)), React.createElement(View, {
          style: styles.row,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 63
          }
        }, React.createElement(Text, {
          style: styles.boxText,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 64
          }
        }, box.left), this.props.children, React.createElement(Text, {
          style: styles.boxText,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 66
          }
        }, box.right)), React.createElement(Text, {
          style: styles.boxText,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 68
          }
        }, box.bottom));
      }
    }]);

    return BoxContainer;
  }(React.Component);

  var styles = StyleSheet.create({
    row: {
      flexDirection: 'row',
      alignItems: 'center',
      justifyContent: 'space-around'
    },
    marginLabel: {
      width: 60
    },
    label: {
      fontSize: 10,
      color: 'rgb(255,100,0)',
      marginLeft: 5,
      flex: 1,
      textAlign: 'left',
      top: -3
    },
    innerText: {
      color: 'yellow',
      fontSize: 12,
      textAlign: 'center',
      width: 70
    },
    box: {
      borderWidth: 1,
      borderColor: 'grey'
    },
    boxText: {
      color: 'white',
      fontSize: 12,
      marginHorizontal: 3,
      marginVertical: 2,
      textAlign: 'center'
    }
  });
  module.exports = BoxInspector;
},355,[24,25,32,34,37,54,60,235,86,350],"node_modules/react-native/Libraries/Inspector/BoxInspector.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");

  var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");

  var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");

  var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native/Libraries/Inspector/StyleInspector.js";

  var React = _$$_REQUIRE(_dependencyMap[5], "react");

  var StyleSheet = _$$_REQUIRE(_dependencyMap[6], "../StyleSheet/StyleSheet");

  var Text = _$$_REQUIRE(_dependencyMap[7], "../Text/Text");

  var View = _$$_REQUIRE(_dependencyMap[8], "../Components/View/View");

  var StyleInspector = function (_React$Component) {
    _inherits(StyleInspector, _React$Component);

    function StyleInspector() {
      _classCallCheck(this, StyleInspector);

      return _possibleConstructorReturn(this, _getPrototypeOf(StyleInspector).apply(this, arguments));
    }

    _createClass(StyleInspector, [{
      key: "render",
      value: function render() {
        var _this = this;

        if (!this.props.style) {
          return React.createElement(Text, {
            style: styles.noStyle,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 21
            }
          }, "No style");
        }

        var names = Object.keys(this.props.style);
        return React.createElement(View, {
          style: styles.container,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 25
          }
        }, React.createElement(View, {
          __source: {
            fileName: _jsxFileName,
            lineNumber: 26
          }
        }, names.map(function (name) {
          return React.createElement(Text, {
            key: name,
            style: styles.attr,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 28
            }
          }, name, ":");
        })), React.createElement(View, {
          __source: {
            fileName: _jsxFileName,
            lineNumber: 34
          }
        }, names.map(function (name) {
          var value = typeof _this.props.style[name] === 'object' ? JSON.stringify(_this.props.style[name]) : _this.props.style[name];
          return React.createElement(Text, {
            key: name,
            style: styles.value,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 41
            }
          }, value);
        })));
      }
    }]);

    return StyleInspector;
  }(React.Component);

  var styles = StyleSheet.create({
    container: {
      flexDirection: 'row'
    },
    attr: {
      fontSize: 10,
      color: '#ccc'
    },
    value: {
      fontSize: 10,
      color: 'white',
      marginLeft: 10
    },
    noStyle: {
      color: 'white',
      fontSize: 10
    }
  });
  module.exports = StyleInspector;
},356,[24,25,32,34,37,54,60,235,86],"node_modules/react-native/Libraries/Inspector/StyleInspector.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native/Libraries/Components/Touchable/TouchableHighlight.js";

  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

  var DeprecatedColorPropType = _$$_REQUIRE(_dependencyMap[1], "../../DeprecatedPropTypes/DeprecatedColorPropType");

  var DeprecatedViewPropTypes = _$$_REQUIRE(_dependencyMap[2], "../../DeprecatedPropTypes/DeprecatedViewPropTypes");

  var NativeMethodsMixin = _$$_REQUIRE(_dependencyMap[3], "../../Renderer/shims/NativeMethodsMixin");

  var Platform = _$$_REQUIRE(_dependencyMap[4], "../../Utilities/Platform");

  var PropTypes = _$$_REQUIRE(_dependencyMap[5], "prop-types");

  var React = _$$_REQUIRE(_dependencyMap[6], "react");

  var ReactNativeViewAttributes = _$$_REQUIRE(_dependencyMap[7], "../View/ReactNativeViewAttributes");

  var StyleSheet = _$$_REQUIRE(_dependencyMap[8], "../../StyleSheet/StyleSheet");

  var Touchable = _$$_REQUIRE(_dependencyMap[9], "./Touchable");

  var TouchableWithoutFeedback = _$$_REQUIRE(_dependencyMap[10], "./TouchableWithoutFeedback");

  var View = _$$_REQUIRE(_dependencyMap[11], "../View/View");

  var createReactClass = _$$_REQUIRE(_dependencyMap[12], "create-react-class");

  var ensurePositiveDelayProps = _$$_REQUIRE(_dependencyMap[13], "./ensurePositiveDelayProps");

  var DEFAULT_PROPS = {
    activeOpacity: 0.85,
    delayPressOut: 100,
    underlayColor: 'black'
  };
  var PRESS_RETENTION_OFFSET = {
    top: 20,
    left: 20,
    right: 20,
    bottom: 30
  };
  var TouchableHighlight = createReactClass({
    displayName: 'TouchableHighlight',
    propTypes: _objectSpread({}, TouchableWithoutFeedback.propTypes, {
      activeOpacity: PropTypes.number,
      underlayColor: DeprecatedColorPropType,
      style: DeprecatedViewPropTypes.style,
      onShowUnderlay: PropTypes.func,
      onHideUnderlay: PropTypes.func,
      hasTVPreferredFocus: PropTypes.bool,
      nextFocusDown: PropTypes.number,
      nextFocusForward: PropTypes.number,
      nextFocusLeft: PropTypes.number,
      nextFocusRight: PropTypes.number,
      nextFocusUp: PropTypes.number,
      tvParallaxProperties: PropTypes.object,
      testOnly_pressed: PropTypes.bool
    }),
    mixins: [NativeMethodsMixin, Touchable.Mixin.withoutDefaultFocusAndBlur],
    getDefaultProps: function getDefaultProps() {
      return DEFAULT_PROPS;
    },
    getInitialState: function getInitialState() {
      this._isMounted = false;

      if (this.props.testOnly_pressed) {
        return _objectSpread({}, this.touchableGetInitialState(), {
          extraChildStyle: {
            opacity: this.props.activeOpacity
          },
          extraUnderlayStyle: {
            backgroundColor: this.props.underlayColor
          }
        });
      } else {
        return _objectSpread({}, this.touchableGetInitialState(), {
          extraChildStyle: null,
          extraUnderlayStyle: null
        });
      }
    },
    componentDidMount: function componentDidMount() {
      this._isMounted = true;
      ensurePositiveDelayProps(this.props);
    },
    componentWillUnmount: function componentWillUnmount() {
      this._isMounted = false;
      clearTimeout(this._hideTimeout);
    },
    UNSAFE_componentWillReceiveProps: function UNSAFE_componentWillReceiveProps(nextProps) {
      ensurePositiveDelayProps(nextProps);
    },
    viewConfig: {
      uiViewClassName: 'RCTView',
      validAttributes: ReactNativeViewAttributes.RCTView
    },
    touchableHandleActivePressIn: function touchableHandleActivePressIn(e) {
      clearTimeout(this._hideTimeout);
      this._hideTimeout = null;

      this._showUnderlay();

      this.props.onPressIn && this.props.onPressIn(e);
    },
    touchableHandleActivePressOut: function touchableHandleActivePressOut(e) {
      if (!this._hideTimeout) {
        this._hideUnderlay();
      }

      this.props.onPressOut && this.props.onPressOut(e);
    },
    touchableHandleFocus: function touchableHandleFocus(e) {
      if (Platform.isTV) {
        this._showUnderlay();
      }

      this.props.onFocus && this.props.onFocus(e);
    },
    touchableHandleBlur: function touchableHandleBlur(e) {
      if (Platform.isTV) {
        this._hideUnderlay();
      }

      this.props.onBlur && this.props.onBlur(e);
    },
    touchableHandlePress: function touchableHandlePress(e) {
      clearTimeout(this._hideTimeout);

      if (!Platform.isTV) {
        this._showUnderlay();

        this._hideTimeout = setTimeout(this._hideUnderlay, this.props.delayPressOut);
      }

      this.props.onPress && this.props.onPress(e);
    },
    touchableHandleLongPress: function touchableHandleLongPress(e) {
      this.props.onLongPress && this.props.onLongPress(e);
    },
    touchableGetPressRectOffset: function touchableGetPressRectOffset() {
      return this.props.pressRetentionOffset || PRESS_RETENTION_OFFSET;
    },
    touchableGetHitSlop: function touchableGetHitSlop() {
      return this.props.hitSlop;
    },
    touchableGetHighlightDelayMS: function touchableGetHighlightDelayMS() {
      return this.props.delayPressIn;
    },
    touchableGetLongPressDelayMS: function touchableGetLongPressDelayMS() {
      return this.props.delayLongPress;
    },
    touchableGetPressOutDelayMS: function touchableGetPressOutDelayMS() {
      return this.props.delayPressOut;
    },
    _showUnderlay: function _showUnderlay() {
      if (!this._isMounted || !this._hasPressHandler()) {
        return;
      }

      this.setState({
        extraChildStyle: {
          opacity: this.props.activeOpacity
        },
        extraUnderlayStyle: {
          backgroundColor: this.props.underlayColor
        }
      });
      this.props.onShowUnderlay && this.props.onShowUnderlay();
    },
    _hideUnderlay: function _hideUnderlay() {
      clearTimeout(this._hideTimeout);
      this._hideTimeout = null;

      if (this.props.testOnly_pressed) {
        return;
      }

      if (this._hasPressHandler()) {
        this.setState({
          extraChildStyle: null,
          extraUnderlayStyle: null
        });
        this.props.onHideUnderlay && this.props.onHideUnderlay();
      }
    },
    _hasPressHandler: function _hasPressHandler() {
      return !!(this.props.onPress || this.props.onPressIn || this.props.onPressOut || this.props.onLongPress);
    },
    render: function render() {
      var child = React.Children.only(this.props.children);
      return React.createElement(View, {
        accessible: this.props.accessible !== false,
        accessibilityLabel: this.props.accessibilityLabel,
        accessibilityHint: this.props.accessibilityHint,
        accessibilityRole: this.props.accessibilityRole,
        accessibilityStates: this.props.accessibilityStates,
        accessibilityState: this.props.accessibilityState,
        accessibilityActions: this.props.accessibilityActions,
        onAccessibilityAction: this.props.onAccessibilityAction,
        style: StyleSheet.compose(this.props.style, this.state.extraUnderlayStyle),
        onLayout: this.props.onLayout,
        hitSlop: this.props.hitSlop,
        isTVSelectable: true,
        tvParallaxProperties: this.props.tvParallaxProperties,
        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,
        onClick: this.touchableHandlePress,
        onStartShouldSetResponder: this.touchableHandleStartShouldSetResponder,
        onResponderTerminationRequest: this.touchableHandleResponderTerminationRequest,
        onResponderGrant: this.touchableHandleResponderGrant,
        onResponderMove: this.touchableHandleResponderMove,
        onResponderRelease: this.touchableHandleResponderRelease,
        onResponderTerminate: this.touchableHandleResponderTerminate,
        nativeID: this.props.nativeID,
        testID: this.props.testID,
        __source: {
          fileName: _jsxFileName,
          lineNumber: 405
        }
      }, React.cloneElement(child, {
        style: StyleSheet.compose(child.props.style, this.state.extraChildStyle)
      }), Touchable.renderDebugView({
        color: 'green',
        hitSlop: this.props.hitSlop
      }));
    }
  });
  module.exports = TouchableHighlight;
},357,[46,66,315,325,48,69,54,230,60,241,251,86,252,258],"node_modules/react-native/Libraries/Components/Touchable/TouchableHighlight.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  function mapWithSeparator(items, itemRenderer, spacerRenderer) {
    var mapped = [];

    if (items.length > 0) {
      mapped.push(itemRenderer(items[0], 0, items));

      for (var ii = 1; ii < items.length; ii++) {
        mapped.push(spacerRenderer(ii - 1), itemRenderer(items[ii], ii, items));
      }
    }

    return mapped;
  }

  module.exports = mapWithSeparator;
},358,[],"node_modules/react-native/Libraries/Utilities/mapWithSeparator.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var getDevServer = _$$_REQUIRE(_dependencyMap[0], "./getDevServer");

  function openFileInEditor(file, lineNumber) {
    fetch(getDevServer().url + 'open-stack-frame', {
      method: 'POST',
      body: JSON.stringify({
        file: file,
        lineNumber: lineNumber
      })
    });
  }

  module.exports = openFileInEditor;
},359,[106],"node_modules/react-native/Libraries/Core/Devtools/openFileInEditor.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");

  var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");

  var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");

  var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native/Libraries/Inspector/NetworkOverlay.js";

  var FlatList = _$$_REQUIRE(_dependencyMap[5], "../Lists/FlatList");

  var React = _$$_REQUIRE(_dependencyMap[6], "react");

  var ScrollView = _$$_REQUIRE(_dependencyMap[7], "../Components/ScrollView/ScrollView");

  var StyleSheet = _$$_REQUIRE(_dependencyMap[8], "../StyleSheet/StyleSheet");

  var Text = _$$_REQUIRE(_dependencyMap[9], "../Text/Text");

  var TouchableHighlight = _$$_REQUIRE(_dependencyMap[10], "../Components/Touchable/TouchableHighlight");

  var View = _$$_REQUIRE(_dependencyMap[11], "../Components/View/View");

  var WebSocketInterceptor = _$$_REQUIRE(_dependencyMap[12], "../WebSocket/WebSocketInterceptor");

  var XHRInterceptor = _$$_REQUIRE(_dependencyMap[13], "../Network/XHRInterceptor");

  var LISTVIEW_CELL_HEIGHT = 15;
  var nextXHRId = 0;

  function getStringByValue(value) {
    if (value === undefined) {
      return 'undefined';
    }

    if (typeof value === 'object') {
      return JSON.stringify(value);
    }

    if (typeof value === 'string' && value.length > 500) {
      return String(value).substr(0, 500).concat('\n***TRUNCATED TO 500 CHARACTERS***');
    }

    return value;
  }

  function getTypeShortName(type) {
    if (type === 'XMLHttpRequest') {
      return 'XHR';
    } else if (type === 'WebSocket') {
      return 'WS';
    }

    return '';
  }

  function keyExtractor(request) {
    return String(request.id);
  }

  var NetworkOverlay = function (_React$Component) {
    _inherits(NetworkOverlay, _React$Component);

    function NetworkOverlay() {
      var _getPrototypeOf2;

      var _this;

      _classCallCheck(this, NetworkOverlay);

      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
        args[_key] = arguments[_key];
      }

      _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(NetworkOverlay)).call.apply(_getPrototypeOf2, [this].concat(args)));
      _this._requestsListViewScrollMetrics = {
        offset: 0,
        visibleLength: 0,
        contentLength: 0
      };
      _this._socketIdMap = {};
      _this._xhrIdMap = {};
      _this.state = {
        detailRowId: null,
        requests: []
      };

      _this._renderItem = function (_ref) {
        var item = _ref.item,
            index = _ref.index;
        var tableRowViewStyle = [styles.tableRow, index % 2 === 1 ? styles.tableRowOdd : styles.tableRowEven, index === _this.state.detailRowId && styles.tableRowPressed];
        var urlCellViewStyle = styles.urlCellView;
        var methodCellViewStyle = styles.methodCellView;
        return React.createElement(TouchableHighlight, {
          onPress: function onPress() {
            _this._pressRow(index);
          },
          __source: {
            fileName: _jsxFileName,
            lineNumber: 338
          }
        }, React.createElement(View, {
          __source: {
            fileName: _jsxFileName,
            lineNumber: 342
          }
        }, React.createElement(View, {
          style: tableRowViewStyle,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 343
          }
        }, React.createElement(View, {
          style: urlCellViewStyle,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 344
          }
        }, React.createElement(Text, {
          style: styles.cellText,
          numberOfLines: 1,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 345
          }
        }, item.url)), React.createElement(View, {
          style: methodCellViewStyle,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 349
          }
        }, React.createElement(Text, {
          style: styles.cellText,
          numberOfLines: 1,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 350
          }
        }, getTypeShortName(item.type))))));
      };

      _this._indicateAdditionalRequests = function () {
        if (_this._requestsListView) {
          var distanceFromEndThreshold = LISTVIEW_CELL_HEIGHT * 2;
          var _this$_requestsListVi = _this._requestsListViewScrollMetrics,
              offset = _this$_requestsListVi.offset,
              visibleLength = _this$_requestsListVi.visibleLength,
              contentLength = _this$_requestsListVi.contentLength;
          var distanceFromEnd = contentLength - visibleLength - offset;
          var isCloseToEnd = distanceFromEnd <= distanceFromEndThreshold;

          if (isCloseToEnd) {
            _this._requestsListView.scrollToEnd();
          } else {
            _this._requestsListView.flashScrollIndicators();
          }
        }
      };

      _this._captureRequestsListView = function (listRef) {
        _this._requestsListView = listRef;
      };

      _this._requestsListViewOnScroll = function (e) {
        _this._requestsListViewScrollMetrics.offset = e.nativeEvent.contentOffset.y;
        _this._requestsListViewScrollMetrics.visibleLength = e.nativeEvent.layoutMeasurement.height;
        _this._requestsListViewScrollMetrics.contentLength = e.nativeEvent.contentSize.height;
      };

      _this._scrollDetailToTop = function () {
        if (_this._detailScrollView) {
          _this._detailScrollView.scrollTo({
            y: 0,
            animated: false
          });
        }
      };

      _this._closeButtonClicked = function () {
        _this.setState({
          detailRowId: null
        });
      };

      return _this;
    }

    _createClass(NetworkOverlay, [{
      key: "_enableXHRInterception",
      value: function _enableXHRInterception() {
        var _this2 = this;

        if (XHRInterceptor.isInterceptorEnabled()) {
          return;
        }

        XHRInterceptor.setOpenCallback(function (method, url, xhr) {
          xhr._index = nextXHRId++;
          var xhrIndex = _this2.state.requests.length;
          _this2._xhrIdMap[xhr._index] = xhrIndex;
          var _xhr = {
            id: xhrIndex,
            type: 'XMLHttpRequest',
            method: method,
            url: url
          };

          _this2.setState({
            requests: _this2.state.requests.concat(_xhr)
          }, _this2._indicateAdditionalRequests);
        });
        XHRInterceptor.setRequestHeaderCallback(function (header, value, xhr) {
          var xhrIndex = _this2._getRequestIndexByXHRID(xhr._index);

          if (xhrIndex === -1) {
            return;
          }

          _this2.setState(function (_ref2) {
            var requests = _ref2.requests;
            var networkRequestInfo = requests[xhrIndex];

            if (!networkRequestInfo.requestHeaders) {
              networkRequestInfo.requestHeaders = {};
            }

            networkRequestInfo.requestHeaders[header] = value;
            return {
              requests: requests
            };
          });
        });
        XHRInterceptor.setSendCallback(function (data, xhr) {
          var xhrIndex = _this2._getRequestIndexByXHRID(xhr._index);

          if (xhrIndex === -1) {
            return;
          }

          _this2.setState(function (_ref3) {
            var requests = _ref3.requests;
            var networkRequestInfo = requests[xhrIndex];
            networkRequestInfo.dataSent = data;
            return {
              requests: requests
            };
          });
        });
        XHRInterceptor.setHeaderReceivedCallback(function (type, size, responseHeaders, xhr) {
          var xhrIndex = _this2._getRequestIndexByXHRID(xhr._index);

          if (xhrIndex === -1) {
            return;
          }

          _this2.setState(function (_ref4) {
            var requests = _ref4.requests;
            var networkRequestInfo = requests[xhrIndex];
            networkRequestInfo.responseContentType = type;
            networkRequestInfo.responseSize = size;
            networkRequestInfo.responseHeaders = responseHeaders;
            return {
              requests: requests
            };
          });
        });
        XHRInterceptor.setResponseCallback(function (status, timeout, response, responseURL, responseType, xhr) {
          var xhrIndex = _this2._getRequestIndexByXHRID(xhr._index);

          if (xhrIndex === -1) {
            return;
          }

          _this2.setState(function (_ref5) {
            var requests = _ref5.requests;
            var networkRequestInfo = requests[xhrIndex];
            networkRequestInfo.status = status;
            networkRequestInfo.timeout = timeout;
            networkRequestInfo.response = response;
            networkRequestInfo.responseURL = responseURL;
            networkRequestInfo.responseType = responseType;
            return {
              requests: requests
            };
          });
        });
        XHRInterceptor.enableInterception();
      }
    }, {
      key: "_enableWebSocketInterception",
      value: function _enableWebSocketInterception() {
        var _this3 = this;

        if (WebSocketInterceptor.isInterceptorEnabled()) {
          return;
        }

        WebSocketInterceptor.setConnectCallback(function (url, protocols, options, socketId) {
          var socketIndex = _this3.state.requests.length;
          _this3._socketIdMap[socketId] = socketIndex;
          var _webSocket = {
            id: socketIndex,
            type: 'WebSocket',
            url: url,
            protocols: protocols
          };

          _this3.setState({
            requests: _this3.state.requests.concat(_webSocket)
          }, _this3._indicateAdditionalRequests);
        });
        WebSocketInterceptor.setCloseCallback(function (statusCode, closeReason, socketId) {
          var socketIndex = _this3._socketIdMap[socketId];

          if (socketIndex === undefined) {
            return;
          }

          if (statusCode !== null && closeReason !== null) {
            _this3.setState(function (_ref6) {
              var requests = _ref6.requests;
              var networkRequestInfo = requests[socketIndex];
              networkRequestInfo.status = statusCode;
              networkRequestInfo.closeReason = closeReason;
              return {
                requests: requests
              };
            });
          }
        });
        WebSocketInterceptor.setSendCallback(function (data, socketId) {
          var socketIndex = _this3._socketIdMap[socketId];

          if (socketIndex === undefined) {
            return;
          }

          _this3.setState(function (_ref7) {
            var requests = _ref7.requests;
            var networkRequestInfo = requests[socketIndex];

            if (!networkRequestInfo.messages) {
              networkRequestInfo.messages = '';
            }

            networkRequestInfo.messages += 'Sent: ' + JSON.stringify(data) + '\n';
            return {
              requests: requests
            };
          });
        });
        WebSocketInterceptor.setOnMessageCallback(function (socketId, message) {
          var socketIndex = _this3._socketIdMap[socketId];

          if (socketIndex === undefined) {
            return;
          }

          _this3.setState(function (_ref8) {
            var requests = _ref8.requests;
            var networkRequestInfo = requests[socketIndex];

            if (!networkRequestInfo.messages) {
              networkRequestInfo.messages = '';
            }

            networkRequestInfo.messages += 'Received: ' + JSON.stringify(message) + '\n';
            return {
              requests: requests
            };
          });
        });
        WebSocketInterceptor.setOnCloseCallback(function (socketId, message) {
          var socketIndex = _this3._socketIdMap[socketId];

          if (socketIndex === undefined) {
            return;
          }

          _this3.setState(function (_ref9) {
            var requests = _ref9.requests;
            var networkRequestInfo = requests[socketIndex];
            networkRequestInfo.serverClose = message;
            return {
              requests: requests
            };
          });
        });
        WebSocketInterceptor.setOnErrorCallback(function (socketId, message) {
          var socketIndex = _this3._socketIdMap[socketId];

          if (socketIndex === undefined) {
            return;
          }

          _this3.setState(function (_ref10) {
            var requests = _ref10.requests;
            var networkRequestInfo = requests[socketIndex];
            networkRequestInfo.serverError = message;
            return {
              requests: requests
            };
          });
        });
        WebSocketInterceptor.enableInterception();
      }
    }, {
      key: "componentDidMount",
      value: function componentDidMount() {
        this._enableXHRInterception();

        this._enableWebSocketInterception();
      }
    }, {
      key: "componentWillUnmount",
      value: function componentWillUnmount() {
        XHRInterceptor.disableInterception();
        WebSocketInterceptor.disableInterception();
      }
    }, {
      key: "_renderItemDetail",
      value: function _renderItemDetail(id) {
        var _this4 = this;

        var requestItem = this.state.requests[id];
        var details = Object.keys(requestItem).map(function (key) {
          if (key === 'id') {
            return;
          }

          return React.createElement(View, {
            style: styles.detailViewRow,
            key: key,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 367
            }
          }, React.createElement(Text, {
            style: [styles.detailViewText, styles.detailKeyCellView],
            __source: {
              fileName: _jsxFileName,
              lineNumber: 368
            }
          }, key), React.createElement(Text, {
            style: [styles.detailViewText, styles.detailValueCellView],
            __source: {
              fileName: _jsxFileName,
              lineNumber: 371
            }
          }, getStringByValue(requestItem[key])));
        });
        return React.createElement(View, {
          __source: {
            fileName: _jsxFileName,
            lineNumber: 379
          }
        }, React.createElement(TouchableHighlight, {
          style: styles.closeButton,
          onPress: this._closeButtonClicked,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 380
          }
        }, React.createElement(View, {
          __source: {
            fileName: _jsxFileName,
            lineNumber: 383
          }
        }, React.createElement(Text, {
          style: styles.closeButtonText,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 384
          }
        }, "v"))), React.createElement(ScrollView, {
          style: styles.detailScrollView,
          ref: function ref(scrollRef) {
            return _this4._detailScrollView = scrollRef;
          },
          __source: {
            fileName: _jsxFileName,
            lineNumber: 387
          }
        }, details));
      }
    }, {
      key: "_pressRow",
      value: function _pressRow(rowId) {
        this.setState({
          detailRowId: rowId
        }, this._scrollDetailToTop);
      }
    }, {
      key: "_getRequestIndexByXHRID",
      value: function _getRequestIndexByXHRID(index) {
        if (index === undefined) {
          return -1;
        }

        var xhrIndex = this._xhrIdMap[index];

        if (xhrIndex === undefined) {
          return -1;
        } else {
          return xhrIndex;
        }
      }
    }, {
      key: "render",
      value: function render() {
        var _this$state = this.state,
            requests = _this$state.requests,
            detailRowId = _this$state.detailRowId;
        return React.createElement(View, {
          style: styles.container,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 463
          }
        }, detailRowId != null && this._renderItemDetail(detailRowId), React.createElement(View, {
          style: styles.listViewTitle,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 465
          }
        }, requests.length > 0 && React.createElement(View, {
          style: styles.tableRow,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 467
          }
        }, React.createElement(View, {
          style: styles.urlTitleCellView,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 468
          }
        }, React.createElement(Text, {
          style: styles.cellText,
          numberOfLines: 1,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 469
          }
        }, "URL")), React.createElement(View, {
          style: styles.methodTitleCellView,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 473
          }
        }, React.createElement(Text, {
          style: styles.cellText,
          numberOfLines: 1,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 474
          }
        }, "Type")))), React.createElement(FlatList, {
          ref: this._captureRequestsListView,
          onScroll: this._requestsListViewOnScroll,
          style: styles.listView,
          data: requests,
          renderItem: this._renderItem,
          keyExtractor: keyExtractor,
          extraData: this.state,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 482
          }
        }));
      }
    }]);

    return NetworkOverlay;
  }(React.Component);

  var styles = StyleSheet.create({
    container: {
      paddingTop: 10,
      paddingBottom: 10,
      paddingLeft: 5,
      paddingRight: 5
    },
    listViewTitle: {
      height: 20
    },
    listView: {
      flex: 1,
      height: 60
    },
    tableRow: {
      flexDirection: 'row',
      flex: 1,
      height: LISTVIEW_CELL_HEIGHT
    },
    tableRowEven: {
      backgroundColor: '#555'
    },
    tableRowOdd: {
      backgroundColor: '#000'
    },
    tableRowPressed: {
      backgroundColor: '#3B5998'
    },
    cellText: {
      color: 'white',
      fontSize: 12
    },
    methodTitleCellView: {
      height: 18,
      borderColor: '#DCD7CD',
      borderTopWidth: 1,
      borderBottomWidth: 1,
      borderRightWidth: 1,
      alignItems: 'center',
      justifyContent: 'center',
      backgroundColor: '#444',
      flex: 1
    },
    urlTitleCellView: {
      height: 18,
      borderColor: '#DCD7CD',
      borderTopWidth: 1,
      borderBottomWidth: 1,
      borderLeftWidth: 1,
      borderRightWidth: 1,
      justifyContent: 'center',
      backgroundColor: '#444',
      flex: 5,
      paddingLeft: 3
    },
    methodCellView: {
      height: 15,
      borderColor: '#DCD7CD',
      borderRightWidth: 1,
      alignItems: 'center',
      justifyContent: 'center',
      flex: 1
    },
    urlCellView: {
      height: 15,
      borderColor: '#DCD7CD',
      borderLeftWidth: 1,
      borderRightWidth: 1,
      justifyContent: 'center',
      flex: 5,
      paddingLeft: 3
    },
    detailScrollView: {
      flex: 1,
      height: 180,
      marginTop: 5,
      marginBottom: 5
    },
    detailKeyCellView: {
      flex: 1.3
    },
    detailValueCellView: {
      flex: 2
    },
    detailViewRow: {
      flexDirection: 'row',
      paddingHorizontal: 3
    },
    detailViewText: {
      color: 'white',
      fontSize: 11
    },
    closeButtonText: {
      color: 'white',
      fontSize: 10
    },
    closeButton: {
      marginTop: 5,
      backgroundColor: '#888',
      justifyContent: 'center',
      alignItems: 'center'
    }
  });
  module.exports = NetworkOverlay;
},360,[24,25,32,34,37,293,54,300,60,235,357,86,361,362],"node_modules/react-native/Libraries/Inspector/NetworkOverlay.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _NativeWebSocketModule = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./NativeWebSocketModule"));

  var NativeEventEmitter = _$$_REQUIRE(_dependencyMap[2], "../EventEmitter/NativeEventEmitter");

  var base64 = _$$_REQUIRE(_dependencyMap[3], "base64-js");

  var originalRCTWebSocketConnect = _NativeWebSocketModule.default.connect;
  var originalRCTWebSocketSend = _NativeWebSocketModule.default.send;
  var originalRCTWebSocketSendBinary = _NativeWebSocketModule.default.sendBinary;
  var originalRCTWebSocketClose = _NativeWebSocketModule.default.close;
  var eventEmitter;
  var subscriptions;
  var closeCallback;
  var sendCallback;
  var connectCallback;
  var onOpenCallback;
  var onMessageCallback;
  var onErrorCallback;
  var onCloseCallback;
  var _isInterceptorEnabled = false;
  var WebSocketInterceptor = {
    setCloseCallback: function setCloseCallback(callback) {
      closeCallback = callback;
    },
    setSendCallback: function setSendCallback(callback) {
      sendCallback = callback;
    },
    setConnectCallback: function setConnectCallback(callback) {
      connectCallback = callback;
    },
    setOnOpenCallback: function setOnOpenCallback(callback) {
      onOpenCallback = callback;
    },
    setOnMessageCallback: function setOnMessageCallback(callback) {
      onMessageCallback = callback;
    },
    setOnErrorCallback: function setOnErrorCallback(callback) {
      onErrorCallback = callback;
    },
    setOnCloseCallback: function setOnCloseCallback(callback) {
      onCloseCallback = callback;
    },
    isInterceptorEnabled: function isInterceptorEnabled() {
      return _isInterceptorEnabled;
    },
    _unregisterEvents: function _unregisterEvents() {
      subscriptions.forEach(function (e) {
        return e.remove();
      });
      subscriptions = [];
    },
    _registerEvents: function _registerEvents() {
      subscriptions = [eventEmitter.addListener('websocketMessage', function (ev) {
        if (onMessageCallback) {
          onMessageCallback(ev.id, ev.type === 'binary' ? WebSocketInterceptor._arrayBufferToString(ev.data) : ev.data);
        }
      }), eventEmitter.addListener('websocketOpen', function (ev) {
        if (onOpenCallback) {
          onOpenCallback(ev.id);
        }
      }), eventEmitter.addListener('websocketClosed', function (ev) {
        if (onCloseCallback) {
          onCloseCallback(ev.id, {
            code: ev.code,
            reason: ev.reason
          });
        }
      }), eventEmitter.addListener('websocketFailed', function (ev) {
        if (onErrorCallback) {
          onErrorCallback(ev.id, {
            message: ev.message
          });
        }
      })];
    },
    enableInterception: function enableInterception() {
      if (_isInterceptorEnabled) {
        return;
      }

      eventEmitter = new NativeEventEmitter(_NativeWebSocketModule.default);

      WebSocketInterceptor._registerEvents();

      _NativeWebSocketModule.default.connect = function (url, protocols, options, socketId) {
        if (connectCallback) {
          connectCallback(url, protocols, options, socketId);
        }

        originalRCTWebSocketConnect.apply(this, arguments);
      };

      _NativeWebSocketModule.default.send = function (data, socketId) {
        if (sendCallback) {
          sendCallback(data, socketId);
        }

        originalRCTWebSocketSend.apply(this, arguments);
      };

      _NativeWebSocketModule.default.sendBinary = function (data, socketId) {
        if (sendCallback) {
          sendCallback(WebSocketInterceptor._arrayBufferToString(data), socketId);
        }

        originalRCTWebSocketSendBinary.apply(this, arguments);
      };

      _NativeWebSocketModule.default.close = function () {
        if (closeCallback) {
          if (arguments.length === 3) {
            closeCallback(arguments[0], arguments[1], arguments[2]);
          } else {
            closeCallback(null, null, arguments[0]);
          }
        }

        originalRCTWebSocketClose.apply(this, arguments);
      };

      _isInterceptorEnabled = true;
    },
    _arrayBufferToString: function _arrayBufferToString(data) {
      var value = base64.toByteArray(data).buffer;

      if (value === undefined || value === null) {
        return '(no value)';
      }

      if (typeof ArrayBuffer !== 'undefined' && typeof Uint8Array !== 'undefined' && value instanceof ArrayBuffer) {
        return "ArrayBuffer {" + String(Array.from(new Uint8Array(value))) + "}";
      }

      return value;
    },
    disableInterception: function disableInterception() {
      if (!_isInterceptorEnabled) {
        return;
      }

      _isInterceptorEnabled = false;
      _NativeWebSocketModule.default.send = originalRCTWebSocketSend;
      _NativeWebSocketModule.default.sendBinary = originalRCTWebSocketSendBinary;
      _NativeWebSocketModule.default.close = originalRCTWebSocketClose;
      _NativeWebSocketModule.default.connect = originalRCTWebSocketConnect;
      connectCallback = null;
      closeCallback = null;
      sendCallback = null;
      onOpenCallback = null;
      onMessageCallback = null;
      onCloseCallback = null;
      onErrorCallback = null;

      WebSocketInterceptor._unregisterEvents();
    }
  };
  module.exports = WebSocketInterceptor;
},361,[1,140,134,137],"node_modules/react-native/Libraries/WebSocket/WebSocketInterceptor.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var XMLHttpRequest = _$$_REQUIRE(_dependencyMap[0], "./XMLHttpRequest");

  var originalXHROpen = XMLHttpRequest.prototype.open;
  var originalXHRSend = XMLHttpRequest.prototype.send;
  var originalXHRSetRequestHeader = XMLHttpRequest.prototype.setRequestHeader;
  var openCallback;
  var sendCallback;
  var requestHeaderCallback;
  var headerReceivedCallback;
  var responseCallback;
  var _isInterceptorEnabled = false;
  var XHRInterceptor = {
    setOpenCallback: function setOpenCallback(callback) {
      openCallback = callback;
    },
    setSendCallback: function setSendCallback(callback) {
      sendCallback = callback;
    },
    setHeaderReceivedCallback: function setHeaderReceivedCallback(callback) {
      headerReceivedCallback = callback;
    },
    setResponseCallback: function setResponseCallback(callback) {
      responseCallback = callback;
    },
    setRequestHeaderCallback: function setRequestHeaderCallback(callback) {
      requestHeaderCallback = callback;
    },
    isInterceptorEnabled: function isInterceptorEnabled() {
      return _isInterceptorEnabled;
    },
    enableInterception: function enableInterception() {
      if (_isInterceptorEnabled) {
        return;
      }

      XMLHttpRequest.prototype.open = function (method, url) {
        if (openCallback) {
          openCallback(method, url, this);
        }

        originalXHROpen.apply(this, arguments);
      };

      XMLHttpRequest.prototype.setRequestHeader = function (header, value) {
        if (requestHeaderCallback) {
          requestHeaderCallback(header, value, this);
        }

        originalXHRSetRequestHeader.apply(this, arguments);
      };

      XMLHttpRequest.prototype.send = function (data) {
        var _this = this;

        if (sendCallback) {
          sendCallback(data, this);
        }

        if (this.addEventListener) {
          this.addEventListener('readystatechange', function () {
            if (!_isInterceptorEnabled) {
              return;
            }

            if (_this.readyState === _this.HEADERS_RECEIVED) {
              var contentTypeString = _this.getResponseHeader('Content-Type');

              var contentLengthString = _this.getResponseHeader('Content-Length');

              var responseContentType, responseSize;

              if (contentTypeString) {
                responseContentType = contentTypeString.split(';')[0];
              }

              if (contentLengthString) {
                responseSize = parseInt(contentLengthString, 10);
              }

              if (headerReceivedCallback) {
                headerReceivedCallback(responseContentType, responseSize, _this.getAllResponseHeaders(), _this);
              }
            }

            if (_this.readyState === _this.DONE) {
              if (responseCallback) {
                responseCallback(_this.status, _this.timeout, _this.response, _this.responseURL, _this.responseType, _this);
              }
            }
          }, false);
        }

        originalXHRSend.apply(this, arguments);
      };

      _isInterceptorEnabled = true;
    },
    disableInterception: function disableInterception() {
      if (!_isInterceptorEnabled) {
        return;
      }

      _isInterceptorEnabled = false;
      XMLHttpRequest.prototype.send = originalXHRSend;
      XMLHttpRequest.prototype.open = originalXHROpen;
      XMLHttpRequest.prototype.setRequestHeader = originalXHRSetRequestHeader;
      responseCallback = null;
      openCallback = null;
      sendCallback = null;
      headerReceivedCallback = null;
      requestHeaderCallback = null;
    }
  };
  module.exports = XHRInterceptor;
},362,[126],"node_modules/react-native/Libraries/Network/XHRInterceptor.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");

  var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");

  var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");

  var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native/Libraries/Inspector/PerformanceOverlay.js";

  var PerformanceLogger = _$$_REQUIRE(_dependencyMap[5], "../Utilities/GlobalPerformanceLogger");

  var React = _$$_REQUIRE(_dependencyMap[6], "react");

  var StyleSheet = _$$_REQUIRE(_dependencyMap[7], "../StyleSheet/StyleSheet");

  var Text = _$$_REQUIRE(_dependencyMap[8], "../Text/Text");

  var View = _$$_REQUIRE(_dependencyMap[9], "../Components/View/View");

  var PerformanceOverlay = function (_React$Component) {
    _inherits(PerformanceOverlay, _React$Component);

    function PerformanceOverlay() {
      _classCallCheck(this, PerformanceOverlay);

      return _possibleConstructorReturn(this, _getPrototypeOf(PerformanceOverlay).apply(this, arguments));
    }

    _createClass(PerformanceOverlay, [{
      key: "render",
      value: function render() {
        var perfLogs = PerformanceLogger.getTimespans();
        var items = [];

        for (var key in perfLogs) {
          if (perfLogs[key].totalTime) {
            var unit = key === 'BundleSize' ? 'b' : 'ms';
            items.push(React.createElement(View, {
              style: styles.row,
              key: key,
              __source: {
                fileName: _jsxFileName,
                lineNumber: 28
              }
            }, React.createElement(Text, {
              style: [styles.text, styles.label],
              __source: {
                fileName: _jsxFileName,
                lineNumber: 29
              }
            }, key), React.createElement(Text, {
              style: [styles.text, styles.totalTime],
              __source: {
                fileName: _jsxFileName,
                lineNumber: 30
              }
            }, perfLogs[key].totalTime + unit)));
          }
        }

        return React.createElement(View, {
          style: styles.container,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 38
          }
        }, items);
      }
    }]);

    return PerformanceOverlay;
  }(React.Component);

  var styles = StyleSheet.create({
    container: {
      height: 100,
      paddingTop: 10
    },
    label: {
      flex: 1
    },
    row: {
      flexDirection: 'row',
      paddingHorizontal: 10
    },
    text: {
      color: 'white',
      fontSize: 12
    },
    totalTime: {
      paddingRight: 100
    }
  });
  module.exports = PerformanceOverlay;
},363,[24,25,32,34,37,159,54,60,235,86],"node_modules/react-native/Libraries/Inspector/PerformanceOverlay.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");

  var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");

  var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");

  var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native/Libraries/YellowBox/YellowBox.js";

  var React = _$$_REQUIRE(_dependencyMap[5], "react");

  var YellowBox;

  if (__DEV__) {
    var _temp;

    var Platform = _$$_REQUIRE(_dependencyMap[6], "../Utilities/Platform");

    var RCTLog = _$$_REQUIRE(_dependencyMap[7], "../Utilities/RCTLog");

    var YellowBoxList = _$$_REQUIRE(_dependencyMap[8], "./UI/YellowBoxList");

    var YellowBoxRegistry = _$$_REQUIRE(_dependencyMap[9], "./Data/YellowBoxRegistry");

    var _console = console,
        error = _console.error,
        warn = _console.warn;
    YellowBox = (_temp = function (_React$Component) {
      _inherits(YellowBox, _React$Component);

      function YellowBox() {
        var _getPrototypeOf2;

        var _this;

        _classCallCheck(this, YellowBox);

        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
          args[_key] = arguments[_key];
        }

        _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(YellowBox)).call.apply(_getPrototypeOf2, [this].concat(args)));
        _this.state = {
          registry: null
        };

        _this._handleDismiss = function (category) {
          YellowBoxRegistry.delete(category);
        };

        return _this;
      }

      _createClass(YellowBox, [{
        key: "render",
        value: function render() {
          return this.state.registry == null ? null : React.createElement(YellowBoxList, {
            onDismiss: this._handleDismiss,
            onDismissAll: this._handleDismissAll,
            registry: this.state.registry,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 108
            }
          });
        }
      }, {
        key: "componentDidMount",
        value: function componentDidMount() {
          var _this2 = this;

          this._subscription = YellowBoxRegistry.observe(function (registry) {
            _this2.setState({
              registry: registry
            });
          });
        }
      }, {
        key: "componentWillUnmount",
        value: function componentWillUnmount() {
          if (this._subscription != null) {
            this._subscription.unsubscribe();
          }
        }
      }, {
        key: "_handleDismissAll",
        value: function _handleDismissAll() {
          YellowBoxRegistry.clear();
        }
      }], [{
        key: "ignoreWarnings",
        value: function ignoreWarnings(patterns) {
          YellowBoxRegistry.addIgnorePatterns(patterns);
        }
      }, {
        key: "install",
        value: function install() {
          console.error = function () {
            for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
              args[_key2] = arguments[_key2];
            }

            error.call.apply(error, [console].concat(args));

            if (typeof args[0] === 'string' && args[0].startsWith('Warning: ')) {
              registerWarning.apply(void 0, args);
            }
          };

          console.warn = function () {
            for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
              args[_key3] = arguments[_key3];
            }

            warn.call.apply(warn, [console].concat(args));
            registerWarning.apply(void 0, args);
          };

          if (console.disableYellowBox === true) {
            YellowBoxRegistry.setDisabled(true);
          }

          Object.defineProperty(console, 'disableYellowBox', {
            configurable: true,
            get: function get() {
              return YellowBoxRegistry.isDisabled();
            },
            set: function set(value) {
              return YellowBoxRegistry.setDisabled(value);
            }
          });

          if (Platform.isTesting) {
            console.disableYellowBox = true;
          }

          RCTLog.setWarningHandler(function () {
            registerWarning.apply(void 0, arguments);
          });
        }
      }, {
        key: "uninstall",
        value: function uninstall() {
          console.error = error;
          console.warn = error;
          delete console.disableYellowBox;
        }
      }]);

      return YellowBox;
    }(React.Component), _temp);

    var registerWarning = function registerWarning() {
      for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
        args[_key4] = arguments[_key4];
      }

      YellowBoxRegistry.add({
        args: args,
        framesToPop: 2
      });
    };
  } else {
    YellowBox = function (_React$Component2) {
      _inherits(YellowBox, _React$Component2);

      function YellowBox() {
        _classCallCheck(this, YellowBox);

        return _possibleConstructorReturn(this, _getPrototypeOf(YellowBox).apply(this, arguments));
      }

      _createClass(YellowBox, [{
        key: "render",
        value: function render() {
          return null;
        }
      }], [{
        key: "ignoreWarnings",
        value: function ignoreWarnings(patterns) {}
      }, {
        key: "install",
        value: function install() {}
      }, {
        key: "uninstall",
        value: function uninstall() {}
      }]);

      return YellowBox;
    }(React.Component);
  }

  module.exports = YellowBox;
},364,[24,25,32,34,37,54,48,157,365,382],"node_modules/react-native/Libraries/YellowBox/YellowBox.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");

  var _slicedToArray = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/slicedToArray");

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass");

  var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/possibleConstructorReturn");

  var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/getPrototypeOf");

  var _inherits = _$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits");

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native/Libraries/YellowBox/UI/YellowBoxList.js";

  var Dimensions = _$$_REQUIRE(_dependencyMap[7], "../../Utilities/Dimensions");

  var FlatList = _$$_REQUIRE(_dependencyMap[8], "../../Lists/FlatList");

  var React = _$$_REQUIRE(_dependencyMap[9], "react");

  var SafeAreaView = _$$_REQUIRE(_dependencyMap[10], "../../Components/SafeAreaView/SafeAreaView");

  var StyleSheet = _$$_REQUIRE(_dependencyMap[11], "../../StyleSheet/StyleSheet");

  var View = _$$_REQUIRE(_dependencyMap[12], "../../Components/View/View");

  var YellowBoxButton = _$$_REQUIRE(_dependencyMap[13], "./YellowBoxButton");

  var YellowBoxInspector = _$$_REQUIRE(_dependencyMap[14], "./YellowBoxInspector");

  var YellowBoxListRow = _$$_REQUIRE(_dependencyMap[15], "./YellowBoxListRow");

  var YellowBoxStyle = _$$_REQUIRE(_dependencyMap[16], "./YellowBoxStyle");

  var VIEWPORT_RATIO = 0.5;
  var MAX_ITEMS = Math.floor(Dimensions.get('window').height * VIEWPORT_RATIO / (YellowBoxListRow.GUTTER + YellowBoxListRow.HEIGHT));

  var YellowBoxList = function (_React$Component) {
    _inherits(YellowBoxList, _React$Component);

    function YellowBoxList() {
      var _getPrototypeOf2;

      var _this;

      _classCallCheck(this, YellowBoxList);

      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
        args[_key] = arguments[_key];
      }

      _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(YellowBoxList)).call.apply(_getPrototypeOf2, [this].concat(args)));
      _this.state = {
        selectedCategory: null
      };

      _this._handleInspectorDismiss = function () {
        var category = _this.state.selectedCategory;

        if (category == null) {
          return;
        }

        _this.setState({
          selectedCategory: null
        }, function () {
          _this.props.onDismiss(category);
        });
      };

      _this._handleInspectorMinimize = function () {
        _this.setState({
          selectedCategory: null
        });
      };

      _this._handleRowPress = function (category) {
        _this.setState({
          selectedCategory: category
        });
      };

      return _this;
    }

    _createClass(YellowBoxList, [{
      key: "render",
      value: function render() {
        var _this2 = this;

        var selectedWarnings = this.state.selectedCategory == null ? null : this.props.registry.get(this.state.selectedCategory);

        if (selectedWarnings != null) {
          return React.createElement(View, {
            style: StyleSheet.absoluteFill,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 56
            }
          }, React.createElement(YellowBoxInspector, {
            onDismiss: this._handleInspectorDismiss,
            onMinimize: this._handleInspectorMinimize,
            warnings: selectedWarnings,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 57
            }
          }));
        }

        var items = [];

        for (var _iterator = this.props.registry, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"]();;) {
          var _ref3;

          if (_isArray) {
            if (_i >= _iterator.length) break;
            _ref3 = _iterator[_i++];
          } else {
            _i = _iterator.next();
            if (_i.done) break;
            _ref3 = _i.value;
          }

          var _ref5 = _ref3;

          var _ref2 = _slicedToArray(_ref5, 2);

          var _category2 = _ref2[0];
          var _warnings = _ref2[1];
          items.unshift({
            category: _category2,
            warnings: _warnings
          });
        }

        var listStyle = {
          height: Math.min(items.length, MAX_ITEMS + 0.5) * (YellowBoxListRow.GUTTER + YellowBoxListRow.HEIGHT)
        };
        return items.length === 0 ? null : React.createElement(View, {
          style: styles.list,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 79
          }
        }, React.createElement(View, {
          pointerEvents: "box-none",
          style: styles.dismissAll,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 80
          }
        }, React.createElement(YellowBoxButton, {
          hitSlop: {
            bottom: 4,
            left: 4,
            right: 4,
            top: 4
          },
          label: "Dismiss All",
          onPress: this.props.onDismissAll,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 81
          }
        })), React.createElement(FlatList, {
          data: items,
          keyExtractor: function keyExtractor(item) {
            return item.category;
          },
          renderItem: function renderItem(_ref4) {
            var item = _ref4.item;
            return React.createElement(YellowBoxListRow, _extends({}, item, {
              onPress: _this2._handleRowPress,
              __source: {
                fileName: _jsxFileName,
                lineNumber: 91
              }
            }));
          },
          scrollEnabled: items.length > MAX_ITEMS,
          scrollsToTop: false,
          style: listStyle,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 87
          }
        }), React.createElement(SafeAreaView, {
          style: styles.safeArea,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 97
          }
        }));
      }
    }]);

    return YellowBoxList;
  }(React.Component);

  var styles = StyleSheet.create({
    list: {
      bottom: 0,
      position: 'absolute',
      width: '100%'
    },
    dismissAll: {
      bottom: '100%',
      flexDirection: 'row',
      justifyContent: 'flex-end',
      paddingBottom: 4,
      paddingEnd: 4,
      position: 'absolute',
      width: '100%'
    },
    safeArea: {
      backgroundColor: YellowBoxStyle.getBackgroundColor(0.95),
      marginTop: StyleSheet.hairlineWidth
    }
  });
  module.exports = YellowBoxList;
},365,[13,14,24,25,32,34,37,62,293,54,366,60,86,368,371,379,370],"node_modules/react-native/Libraries/YellowBox/UI/YellowBoxList.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");

  var _objectWithoutProperties = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/objectWithoutProperties");

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native/Libraries/Components/SafeAreaView/SafeAreaView.js";

  var Platform = _$$_REQUIRE(_dependencyMap[2], "../../Utilities/Platform");

  var React = _$$_REQUIRE(_dependencyMap[3], "react");

  var View = _$$_REQUIRE(_dependencyMap[4], "../View/View");

  var exported;

  if ("android" === 'android') {
    var SafeAreaView = function SafeAreaView(props, forwardedRef) {
      var emulateUnlessSupported = props.emulateUnlessSupported,
          localProps = _objectWithoutProperties(props, ["emulateUnlessSupported"]);

      return React.createElement(View, _extends({}, localProps, {
        ref: forwardedRef,
        __source: {
          fileName: _jsxFileName,
          lineNumber: 40
        }
      }));
    };

    var SafeAreaViewRef = React.forwardRef(SafeAreaView);
    SafeAreaViewRef.displayName = 'SafeAreaView';
    exported = SafeAreaViewRef;
  } else {
    var RCTSafeAreaViewNativeComponent = _$$_REQUIRE(_dependencyMap[5], "./RCTSafeAreaViewNativeComponent").default;

    var _SafeAreaView = function _SafeAreaView(props, forwardedRef) {
      return React.createElement(RCTSafeAreaViewNativeComponent, _extends({
        emulateUnlessSupported: true
      }, props, {
        ref: forwardedRef,
        __source: {
          fileName: _jsxFileName,
          lineNumber: 55
        }
      }));
    };

    var _SafeAreaViewRef = React.forwardRef(_SafeAreaView);

    _SafeAreaViewRef.displayName = 'SafeAreaView';
    exported = _SafeAreaViewRef;
  }

  module.exports = exported;
},366,[13,52,48,54,86,367],"node_modules/react-native/Libraries/Components/SafeAreaView/SafeAreaView.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _codegenNativeComponent = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../../Utilities/codegenNativeComponent"));

  var _default = (0, _codegenNativeComponent.default)('RCTSafeAreaView');

  exports.default = _default;
},367,[1,222],"node_modules/react-native/Libraries/Components/SafeAreaView/RCTSafeAreaViewNativeComponent.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native/Libraries/YellowBox/UI/YellowBoxButton.js";

  var React = _$$_REQUIRE(_dependencyMap[0], "react");

  var StyleSheet = _$$_REQUIRE(_dependencyMap[1], "../../StyleSheet/StyleSheet");

  var Text = _$$_REQUIRE(_dependencyMap[2], "../../Text/Text");

  var YellowBoxPressable = _$$_REQUIRE(_dependencyMap[3], "./YellowBoxPressable");

  var YellowBoxStyle = _$$_REQUIRE(_dependencyMap[4], "./YellowBoxStyle");

  var YellowBoxButton = function YellowBoxButton(props) {
    return React.createElement(YellowBoxPressable, {
      hitSlop: props.hitSlop,
      onPress: props.onPress,
      style: styles.root,
      __source: {
        fileName: _jsxFileName,
        lineNumber: 28
      }
    }, React.createElement(Text, {
      numberOfLines: 1,
      style: styles.label,
      __source: {
        fileName: _jsxFileName,
        lineNumber: 32
      }
    }, props.label));
  };

  var styles = StyleSheet.create({
    root: {
      borderRadius: 14,
      height: 28,
      justifyContent: 'center',
      paddingHorizontal: 12
    },
    label: {
      color: YellowBoxStyle.getTextColor(1),
      fontSize: 12,
      includeFontPadding: false,
      lineHeight: 16
    }
  });
  module.exports = YellowBoxButton;
},368,[54,60,235,369,370],"node_modules/react-native/Libraries/YellowBox/UI/YellowBoxButton.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");

  var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");

  var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");

  var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native/Libraries/YellowBox/UI/YellowBoxPressable.js";

  var React = _$$_REQUIRE(_dependencyMap[5], "react");

  var StyleSheet = _$$_REQUIRE(_dependencyMap[6], "../../StyleSheet/StyleSheet");

  var TouchableWithoutFeedback = _$$_REQUIRE(_dependencyMap[7], "../../Components/Touchable/TouchableWithoutFeedback");

  var View = _$$_REQUIRE(_dependencyMap[8], "../../Components/View/View");

  var YellowBoxStyle = _$$_REQUIRE(_dependencyMap[9], "./YellowBoxStyle");

  var YellowBoxPressable = function (_React$Component) {
    _inherits(YellowBoxPressable, _React$Component);

    function YellowBoxPressable() {
      var _getPrototypeOf2;

      var _this;

      _classCallCheck(this, YellowBoxPressable);

      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
        args[_key] = arguments[_key];
      }

      _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(YellowBoxPressable)).call.apply(_getPrototypeOf2, [this].concat(args)));
      _this.state = {
        pressed: false
      };

      _this._handlePressIn = function () {
        _this.setState({
          pressed: true
        });
      };

      _this._handlePressOut = function () {
        _this.setState({
          pressed: false
        });
      };

      return _this;
    }

    _createClass(YellowBoxPressable, [{
      key: "render",
      value: function render() {
        var content = React.createElement(View, {
          style: StyleSheet.compose({
            backgroundColor: this.state.pressed ? this.props.backgroundColor.pressed : this.props.backgroundColor.default
          }, this.props.style),
          __source: {
            fileName: _jsxFileName,
            lineNumber: 54
          }
        }, this.props.children);
        return this.props.onPress == null ? content : React.createElement(TouchableWithoutFeedback, {
          hitSlop: this.props.hitSlop,
          onPress: this.props.onPress,
          onPressIn: this._handlePressIn,
          onPressOut: this._handlePressOut,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 69
          }
        }, content);
      }
    }]);

    return YellowBoxPressable;
  }(React.Component);

  YellowBoxPressable.defaultProps = {
    backgroundColor: {
      default: YellowBoxStyle.getBackgroundColor(0.95),
      pressed: YellowBoxStyle.getHighlightColor(1)
    }
  };
  module.exports = YellowBoxPressable;
},369,[24,25,32,34,37,54,60,251,86,370],"node_modules/react-native/Libraries/YellowBox/UI/YellowBoxPressable.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var YellowBoxStyle = {
    getBackgroundColor: function getBackgroundColor(opacity) {
      return "rgba(250, 186, 48, " + opacity + ")";
    },
    getDividerColor: function getDividerColor(opacity) {
      return "rgba(255, 255, 255, " + opacity + ")";
    },
    getHighlightColor: function getHighlightColor(opacity) {
      return "rgba(252, 176, 29, " + opacity + ")";
    },
    getTextColor: function getTextColor(opacity) {
      return "rgba(255, 255, 255, " + opacity + ")";
    }
  };
  module.exports = YellowBoxStyle;
},370,[],"node_modules/react-native/Libraries/YellowBox/UI/YellowBoxStyle.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");

  var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");

  var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");

  var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native/Libraries/YellowBox/UI/YellowBoxInspector.js";

  var Platform = _$$_REQUIRE(_dependencyMap[5], "../../Utilities/Platform");

  var React = _$$_REQUIRE(_dependencyMap[6], "react");

  var ScrollView = _$$_REQUIRE(_dependencyMap[7], "../../Components/ScrollView/ScrollView");

  var StyleSheet = _$$_REQUIRE(_dependencyMap[8], "../../StyleSheet/StyleSheet");

  var Text = _$$_REQUIRE(_dependencyMap[9], "../../Text/Text");

  var View = _$$_REQUIRE(_dependencyMap[10], "../../Components/View/View");

  var YellowBoxCategory = _$$_REQUIRE(_dependencyMap[11], "../Data/YellowBoxCategory");

  var YellowBoxInspectorFooter = _$$_REQUIRE(_dependencyMap[12], "./YellowBoxInspectorFooter");

  var YellowBoxInspectorHeader = _$$_REQUIRE(_dependencyMap[13], "./YellowBoxInspectorHeader");

  var YellowBoxInspectorSourceMapStatus = _$$_REQUIRE(_dependencyMap[14], "./YellowBoxInspectorSourceMapStatus");

  var YellowBoxInspectorStackFrame = _$$_REQUIRE(_dependencyMap[15], "./YellowBoxInspectorStackFrame");

  var YellowBoxStyle = _$$_REQUIRE(_dependencyMap[16], "./YellowBoxStyle");

  var openFileInEditor = _$$_REQUIRE(_dependencyMap[17], "../../Core/Devtools/openFileInEditor");

  var YellowBoxInspector = function (_React$Component) {
    _inherits(YellowBoxInspector, _React$Component);

    function YellowBoxInspector() {
      var _getPrototypeOf2;

      var _this;

      _classCallCheck(this, YellowBoxInspector);

      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
        args[_key] = arguments[_key];
      }

      _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(YellowBoxInspector)).call.apply(_getPrototypeOf2, [this].concat(args)));
      _this.state = {
        selectedIndex: 0
      };

      _this._handleRetrySymbolication = function () {
        _this._cancelSymbolication();

        _this.forceUpdate(function () {
          var warning = _this.props.warnings[_this.state.selectedIndex];
          _this._symbolication = warning.retrySymbolicate(function () {
            _this.forceUpdate();
          });
        });
      };

      _this._handleSelectIndex = function (selectedIndex) {
        _this.setState({
          selectedIndex: selectedIndex
        });
      };

      return _this;
    }

    _createClass(YellowBoxInspector, [{
      key: "render",
      value: function render() {
        var warnings = this.props.warnings;
        var selectedIndex = this.state.selectedIndex;
        var warning = warnings[selectedIndex];
        return React.createElement(View, {
          style: styles.root,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 55
          }
        }, React.createElement(YellowBoxInspectorHeader, {
          onSelectIndex: this._handleSelectIndex,
          selectedIndex: selectedIndex,
          warnings: warnings,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 56
          }
        }), React.createElement(ScrollView, {
          contentContainerStyle: styles.bodyContent,
          key: selectedIndex,
          style: styles.body,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 61
          }
        }, React.createElement(View, {
          __source: {
            fileName: _jsxFileName,
            lineNumber: 65
          }
        }, React.createElement(View, {
          style: styles.bodyHeading,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 66
          }
        }, React.createElement(Text, {
          style: styles.bodyHeadingText,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 67
          }
        }, "Warning")), React.createElement(Text, {
          style: styles.bodyText,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 69
          }
        }, YellowBoxCategory.render(warning.message, styles.substitutionText))), React.createElement(View, {
          style: styles.bodySection,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 76
          }
        }, React.createElement(View, {
          style: styles.bodyHeading,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 77
          }
        }, React.createElement(Text, {
          style: styles.bodyHeadingText,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 78
          }
        }, "Stack"), React.createElement(YellowBoxInspectorSourceMapStatus, {
          onPress: warning.symbolicated.status === 'FAILED' ? this._handleRetrySymbolication : null,
          status: warning.symbolicated.status,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 79
          }
        })), warning.getAvailableStack().map(function (frame, index) {
          var file = frame.file,
              lineNumber = frame.lineNumber;
          return React.createElement(YellowBoxInspectorStackFrame, {
            key: index,
            frame: frame,
            onPress: warning.symbolicated.status === 'COMPLETE' && file != null && lineNumber != null ? function () {
              openFileInEditor(file, lineNumber);
            } : null,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 91
            }
          });
        }))), React.createElement(YellowBoxInspectorFooter, {
          onDismiss: this.props.onDismiss,
          onMinimize: this.props.onMinimize,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 108
          }
        }));
      }
    }, {
      key: "componentDidMount",
      value: function componentDidMount() {
        this._handleSymbolication();
      }
    }, {
      key: "componentDidUpdate",
      value: function componentDidUpdate(prevProps, prevState) {
        if (prevProps.warnings !== this.props.warnings || prevState.selectedIndex !== this.state.selectedIndex) {
          this._cancelSymbolication();

          this._handleSymbolication();
        }
      }
    }, {
      key: "componentWillUnmount",
      value: function componentWillUnmount() {
        this._cancelSymbolication();
      }
    }, {
      key: "_handleSymbolication",
      value: function _handleSymbolication() {
        var _this2 = this;

        var warning = this.props.warnings[this.state.selectedIndex];

        if (warning.symbolicated.status !== 'COMPLETE') {
          this._symbolication = warning.symbolicate(function () {
            _this2.forceUpdate();
          });
        }
      }
    }, {
      key: "_cancelSymbolication",
      value: function _cancelSymbolication() {
        if (this._symbolication != null) {
          this._symbolication.abort();

          this._symbolication = null;
        }
      }
    }]);

    return YellowBoxInspector;
  }(React.Component);

  var styles = StyleSheet.create({
    root: {
      elevation: "android" === 'android' ? Number.MAX_SAFE_INTEGER : undefined,
      height: '100%'
    },
    body: {
      backgroundColor: YellowBoxStyle.getBackgroundColor(0.95),
      borderBottomColor: YellowBoxStyle.getDividerColor(0.95),
      borderBottomWidth: StyleSheet.hairlineWidth,
      borderTopColor: YellowBoxStyle.getDividerColor(0.95),
      borderTopWidth: StyleSheet.hairlineWidth,
      flex: 1
    },
    bodyContent: {
      paddingVertical: 12
    },
    bodyHeading: {
      alignItems: 'center',
      flexDirection: 'row',
      marginBottom: 6,
      paddingHorizontal: 12
    },
    bodyHeadingText: {
      color: YellowBoxStyle.getTextColor(1),
      flex: 1,
      fontSize: 20,
      fontWeight: '600',
      includeFontPadding: false,
      lineHeight: 28
    },
    bodyText: {
      color: YellowBoxStyle.getTextColor(1),
      fontSize: 14,
      includeFontPadding: false,
      lineHeight: 18,
      paddingHorizontal: 12
    },
    substitutionText: {
      color: YellowBoxStyle.getTextColor(0.6)
    },
    bodySection: {
      marginTop: 20
    }
  });
  module.exports = YellowBoxInspector;
},371,[24,25,32,34,37,48,54,300,60,235,86,372,374,375,377,378,370,359],"node_modules/react-native/Libraries/YellowBox/UI/YellowBoxInspector.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _toConsumableArray = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/toConsumableArray");

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native/Libraries/YellowBox/Data/YellowBoxCategory.js";

  var React = _$$_REQUIRE(_dependencyMap[1], "react");

  var Text = _$$_REQUIRE(_dependencyMap[2], "../../Text/Text");

  var UTFSequence = _$$_REQUIRE(_dependencyMap[3], "../../UTFSequence");

  var stringifySafe = _$$_REQUIRE(_dependencyMap[4], "../../Utilities/stringifySafe");

  var SUBSTITUTION = UTFSequence.BOM + '%s';
  var YellowBoxCategory = {
    parse: function parse(args) {
      var categoryParts = [];
      var contentParts = [];
      var substitutionOffsets = [];

      var remaining = _toConsumableArray(args);

      if (typeof remaining[0] === 'string') {
        var formatString = String(remaining.shift());
        var formatStringParts = formatString.split('%s');
        var substitutionCount = formatStringParts.length - 1;
        var substitutions = remaining.splice(0, substitutionCount);
        var categoryString = '';
        var contentString = '';
        var substitutionIndex = 0;

        for (var _iterator = formatStringParts, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"]();;) {
          var _ref;

          if (_isArray) {
            if (_i >= _iterator.length) break;
            _ref = _iterator[_i++];
          } else {
            _i = _iterator.next();
            if (_i.done) break;
            _ref = _i.value;
          }

          var _formatStringPart = _ref;
          categoryString += _formatStringPart;
          contentString += _formatStringPart;

          if (substitutionIndex < substitutionCount) {
            if (substitutionIndex < substitutions.length) {
              var substitution = stringifySafe(substitutions[substitutionIndex]);
              substitutionOffsets.push({
                length: substitution.length,
                offset: contentString.length
              });
              categoryString += SUBSTITUTION;
              contentString += substitution;
            } else {
              substitutionOffsets.push({
                length: 2,
                offset: contentString.length
              });
              categoryString += '%s';
              contentString += '%s';
            }

            substitutionIndex++;
          }
        }

        categoryParts.push(categoryString);
        contentParts.push(contentString);
      }

      var remainingArgs = remaining.map(stringifySafe);
      categoryParts.push.apply(categoryParts, _toConsumableArray(remainingArgs));
      contentParts.push.apply(contentParts, _toConsumableArray(remainingArgs));
      return {
        category: categoryParts.join(' '),
        message: {
          content: contentParts.join(' '),
          substitutions: substitutionOffsets
        }
      };
    },
    render: function render(_ref2, substitutionStyle) {
      var content = _ref2.content,
          substitutions = _ref2.substitutions;
      var elements = [];
      var lastOffset = substitutions.reduce(function (prevOffset, substitution, index) {
        var key = String(index);

        if (substitution.offset > prevOffset) {
          var prevPart = content.substr(prevOffset, substitution.offset - prevOffset);
          elements.push(React.createElement(Text, {
            key: key,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 119
            }
          }, prevPart));
        }

        var substititionPart = content.substr(substitution.offset, substitution.length);
        elements.push(React.createElement(Text, {
          key: key + '.5',
          style: substitutionStyle,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 127
          }
        }, substititionPart));
        return substitution.offset + substitution.length;
      }, 0);

      if (lastOffset < content.length) {
        var lastPart = content.substr(lastOffset);
        elements.push(React.createElement(Text, {
          key: "-1",
          __source: {
            fileName: _jsxFileName,
            lineNumber: 139
          }
        }, lastPart));
      }

      return elements;
    }
  };
  module.exports = YellowBoxCategory;
},372,[20,54,235,373,29],"node_modules/react-native/Libraries/YellowBox/Data/YellowBoxCategory.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var deepFreezeAndThrowOnMutationInDev = _$$_REQUIRE(_dependencyMap[0], "./Utilities/deepFreezeAndThrowOnMutationInDev");

  var UTFSequence = deepFreezeAndThrowOnMutationInDev({
    BOM: "\uFEFF",
    BULLET: "\u2022",
    BULLET_SP: "\xA0\u2022\xA0",
    MIDDOT: "\xB7",
    MIDDOT_SP: "\xA0\xB7\xA0",
    MIDDOT_KATAKANA: "\u30FB",
    MDASH: "\u2014",
    MDASH_SP: "\xA0\u2014\xA0",
    NDASH: "\u2013",
    NDASH_SP: "\xA0\u2013\xA0",
    NBSP: "\xA0",
    PIZZA: "\uD83C\uDF55",
    TRIANGLE_LEFT: "\u25C0",
    TRIANGLE_RIGHT: "\u25B6"
  });
  module.exports = UTFSequence;
},373,[28],"node_modules/react-native/Libraries/UTFSequence.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native/Libraries/YellowBox/UI/YellowBoxInspectorFooter.js";

  var React = _$$_REQUIRE(_dependencyMap[0], "react");

  var SafeAreaView = _$$_REQUIRE(_dependencyMap[1], "../../Components/SafeAreaView/SafeAreaView");

  var StyleSheet = _$$_REQUIRE(_dependencyMap[2], "../../StyleSheet/StyleSheet");

  var Text = _$$_REQUIRE(_dependencyMap[3], "../../Text/Text");

  var View = _$$_REQUIRE(_dependencyMap[4], "../../Components/View/View");

  var YellowBoxPressable = _$$_REQUIRE(_dependencyMap[5], "./YellowBoxPressable");

  var YellowBoxStyle = _$$_REQUIRE(_dependencyMap[6], "./YellowBoxStyle");

  var YellowBoxInspectorFooter = function YellowBoxInspectorFooter(props) {
    return React.createElement(View, {
      style: styles.root,
      __source: {
        fileName: _jsxFileName,
        lineNumber: 27
      }
    }, React.createElement(YellowBoxPressable, {
      backgroundColor: {
        default: 'transparent',
        pressed: YellowBoxStyle.getHighlightColor(1)
      },
      onPress: props.onMinimize,
      style: styles.button,
      __source: {
        fileName: _jsxFileName,
        lineNumber: 28
      }
    }, React.createElement(View, {
      style: styles.content,
      __source: {
        fileName: _jsxFileName,
        lineNumber: 35
      }
    }, React.createElement(Text, {
      style: styles.label,
      __source: {
        fileName: _jsxFileName,
        lineNumber: 36
      }
    }, "Minimize")), React.createElement(SafeAreaView, {
      __source: {
        fileName: _jsxFileName,
        lineNumber: 38
      }
    })), React.createElement(YellowBoxPressable, {
      backgroundColor: {
        default: 'transparent',
        pressed: YellowBoxStyle.getHighlightColor(1)
      },
      onPress: props.onDismiss,
      style: styles.button,
      __source: {
        fileName: _jsxFileName,
        lineNumber: 40
      }
    }, React.createElement(View, {
      style: styles.content,
      __source: {
        fileName: _jsxFileName,
        lineNumber: 47
      }
    }, React.createElement(Text, {
      style: styles.label,
      __source: {
        fileName: _jsxFileName,
        lineNumber: 48
      }
    }, "Dismiss")), React.createElement(SafeAreaView, {
      __source: {
        fileName: _jsxFileName,
        lineNumber: 50
      }
    })));
  };

  var styles = StyleSheet.create({
    root: {
      backgroundColor: YellowBoxStyle.getBackgroundColor(0.95),
      flexDirection: 'row'
    },
    button: {
      flex: 1
    },
    content: {
      alignItems: 'center',
      height: 48,
      justifyContent: 'center'
    },
    label: {
      color: YellowBoxStyle.getTextColor(1),
      fontSize: 14,
      includeFontPadding: false,
      lineHeight: 18
    }
  });
  module.exports = YellowBoxInspectorFooter;
},374,[54,366,60,235,86,369,370],"node_modules/react-native/Libraries/YellowBox/UI/YellowBoxInspectorFooter.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native/Libraries/YellowBox/UI/YellowBoxInspectorHeader.js";

  var Image = _$$_REQUIRE(_dependencyMap[0], "../../Image/Image");

  var Platform = _$$_REQUIRE(_dependencyMap[1], "../../Utilities/Platform");

  var React = _$$_REQUIRE(_dependencyMap[2], "react");

  var SafeAreaView = _$$_REQUIRE(_dependencyMap[3], "../../Components/SafeAreaView/SafeAreaView");

  var StyleSheet = _$$_REQUIRE(_dependencyMap[4], "../../StyleSheet/StyleSheet");

  var Text = _$$_REQUIRE(_dependencyMap[5], "../../Text/Text");

  var View = _$$_REQUIRE(_dependencyMap[6], "../../Components/View/View");

  var YellowBoxImageSource = _$$_REQUIRE(_dependencyMap[7], "./YellowBoxImageSource");

  var YellowBoxPressable = _$$_REQUIRE(_dependencyMap[8], "./YellowBoxPressable");

  var YellowBoxStyle = _$$_REQUIRE(_dependencyMap[9], "./YellowBoxStyle");

  var YellowBoxInspectorHeader = function YellowBoxInspectorHeader(props) {
    var prevIndex = props.selectedIndex - 1;
    var nextIndex = props.selectedIndex + 1;
    var titleText = props.warnings.length === 1 ? 'Single Occurrence' : "Occurrence " + (props.selectedIndex + 1) + " of " + props.warnings.length;
    return React.createElement(SafeAreaView, {
      style: styles.root,
      __source: {
        fileName: _jsxFileName,
        lineNumber: 42
      }
    }, React.createElement(View, {
      style: styles.header,
      __source: {
        fileName: _jsxFileName,
        lineNumber: 43
      }
    }, React.createElement(YellowBoxInspectorHeaderButton, {
      disabled: props.warnings[prevIndex] == null,
      image: YellowBoxImageSource.chevronLeft,
      onPress: function onPress() {
        return props.onSelectIndex(prevIndex);
      },
      __source: {
        fileName: _jsxFileName,
        lineNumber: 44
      }
    }), React.createElement(View, {
      style: styles.headerTitle,
      __source: {
        fileName: _jsxFileName,
        lineNumber: 49
      }
    }, React.createElement(Text, {
      style: styles.headerTitleText,
      __source: {
        fileName: _jsxFileName,
        lineNumber: 50
      }
    }, titleText)), React.createElement(YellowBoxInspectorHeaderButton, {
      disabled: props.warnings[nextIndex] == null,
      image: YellowBoxImageSource.chevronRight,
      onPress: function onPress() {
        return props.onSelectIndex(nextIndex);
      },
      __source: {
        fileName: _jsxFileName,
        lineNumber: 52
      }
    })));
  };

  var YellowBoxInspectorHeaderButton = function YellowBoxInspectorHeaderButton(props) {
    return React.createElement(YellowBoxPressable, {
      backgroundColor: {
        default: 'transparent',
        pressed: YellowBoxStyle.getHighlightColor(1)
      },
      onPress: props.disabled ? null : props.onPress,
      style: styles.headerButton,
      __source: {
        fileName: _jsxFileName,
        lineNumber: 69
      }
    }, props.disabled ? null : React.createElement(Image, {
      source: {
        height: 16,
        uri: props.image,
        width: 16
      },
      style: styles.headerButtonImage,
      __source: {
        fileName: _jsxFileName,
        lineNumber: 77
      }
    }));
  };

  var styles = StyleSheet.create({
    root: {
      backgroundColor: YellowBoxStyle.getBackgroundColor(0.95)
    },
    header: {
      flexDirection: 'row',
      height: 48
    },
    headerButton: {
      alignItems: 'center',
      aspectRatio: 1,
      justifyContent: 'center'
    },
    headerButtonImage: {
      tintColor: YellowBoxStyle.getTextColor(1)
    },
    headerTitle: {
      alignItems: 'center',
      flex: 1,
      justifyContent: 'center'
    },
    headerTitleText: {
      color: YellowBoxStyle.getTextColor(1),
      fontSize: 16,
      fontWeight: '600',
      includeFontPadding: false,
      lineHeight: 20
    }
  });
  module.exports = YellowBoxInspectorHeader;
},375,[314,48,54,366,60,235,86,376,369,370],"node_modules/react-native/Libraries/YellowBox/UI/YellowBoxInspectorHeader.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var PixelRatio = _$$_REQUIRE(_dependencyMap[0], "../../Utilities/PixelRatio");

  var scale = PixelRatio.get();
  /**
   * We use inline images for YellowBox in order to avoid display latency due to
   * resource contention with symbolicating stack traces.
   *
   * The following steps were used to create these:
   *
   *   1. Download SVG files from: https://feathericons.com
   *   2. Rasterize SVG files to PNG files at 16dp, 36dp, and 48dp.
   *   3. Convert to Base64: https://www.google.com/search?q=base64+image+encoder
   *
   * @see https://github.com/feathericons/feather
   * @copyright 2013-2017 Cole Bemis
   * @license MIT
   */

  var YellowBoxImageSource = {
    alertTriangle: scale > 2 ? 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAADAAAAAwCAYAAABXAvmHAAAB60lEQVRoge2Z3W3DIBSFj9oFPAIjZARGyAiMkBHuJh4hI2QEj5AR3Me+tQ91JALHmD8bKvmTkCr5Auc6/kzUACcnRXzuvL4GoAB8Afjeea9qXADcAfw4475c65orgBl++NeYl5ouUQiHt5tQTRJuwB6b5zLY49QVGn7I0bo+kuv60IQbuHf5CWCIqOkCgX93maia1MkRAUMo+OI+AvUPp7a50EzcUCBF6psJrUkYiZgnZJ7eId8mMeIyhpW5hyLw72LKCXsl86VqwgAKceKapW5e/nZpJnSsuHaTM7muyDq7C63JprJS69YxhNTpSlkpKeLGNHCo0EJChcSNaQA4SGiFtBMXJFSI3YVOPXFB6kMoUl9NaE0Wl4h5KQ0AOwqde+KmNrCL0EKCxJ64qQ0AlYVWSBfXZusgW6Oa0Dni2hiEv0qsoci+yUJrsoikLlKAkP11ygK54taiSOgb/O5b/DMqS+gBZeLWJlnoEX7XwQkBDPIktlEkz7hWrEmxZG4M5L9GXYTk0qxwcopKxa3VABN6cosM/C5LxTUof4ReMKHf1nRlaSnuGsGM7kfU4w8RF5Bz4aNlokLe/HQ/ngl9/Qih4L9k3h4hA1+S3odxu3Q77Hl4r1Hg75n6D01M2Difbp02Mi3ZTk5OLH4BUyEtOlDYuK0AAAAASUVORK5CYII=' : scale > 1 ? 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAABVklEQVRYheWX4U3DMBBGH4gBMoJHyAgeoSNkAxjBG5QNOkJHCGzQDcoGZQP4gY3Oqe1cEscS4pNOqs9Jvqvv6ZrCf9fDhnutD4A3H810Br4mcW5l7hLmIdze5mZi+OJD5syeBYzC6CjyR5Ef9zI/CJMb0Im9zufC/qG2eQdchcGQuGYQ+9dJgZvl0B2xbJGrZW6IIevFXp9YVwcyB540syJfFcgSeJb0cVcDcg68XAFQCUhH+ShLBcBGIA158LQFqIB8zBRwEp9fgctcxQld/L2pZxZVAk/KkucjaDGQmoknrz35KEE2sABIRxm8tVIBaZgHb61UQOYmXk7aFgQVJ6QWPCnLAriYAVILnpTxD7yh/9EZiIEE4m+y29uMkGy1nQ6i9wYFRB5PwKdYP/v1msmnUe89gn695bG0iqjdXeMiRu9599csvGKZ0jlu0Ac/7d2rxX9Q37HW6QfX/ZguAAAAAElFTkSuQmCC' : 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAvUlEQVQ4jbWT4Q3CIBCFP40DdANxg24gIzhKuwEjuIFxAkcwTtARGicoG+iPXlMCB8UfvoQc4e7ePV4A/ogWuMlqc0W7AsEo0QMNcPplugMmwMia5KwKWkNIuIkHq3wLXGQ/Sq4IC3wkLpOfmZyKeEpIEKsDYB8VN0Afkfpg30uNiycbdKcNqXEOxdBEWoEAoqta8uZ0iqqkxwGDUrSFAXAHZpOWd/+ubD5Kz335Cx1wZna4Bh54AddauVl8ARfCLO9Xq7xGAAAAAElFTkSuQmCC',
    check: scale > 2 ? 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAADAAAAAwCAYAAABXAvmHAAAAqElEQVRoge3YTQ7CIBRF4bPUu/8JS6gTSaqilh95vuR+CaO2cGgYNAUzMzOzFgHlPhRaMkDAcRoltKaTeIxPtQHxGn+Q5AgJx8cQjo8hHB9DOP76Yiu/RcTmN18WLiQCjs3zBkYXVGOeLWd+xcIr5pgyEzDz7FIjISPP/FRPUM+9W4nvYVfuCSXeB3669ldEOzRFfCUSx1cicXwlEsdXIvEPKDMzM7PMbtugw3XTpNA2AAAAAElFTkSuQmCC' : scale > 1 ? 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAAf0lEQVRYhe2UvQ2AIBQGL3EBR3AESkv3bxxFN8DmWUgwvkI+En1X0cBd+IMg+DuDyDMCs413kfMiX4EMbD3l8oCaPIU85B4mYLEF5XJscrYFPRGvb/sZ4IlocubJGdH0wj1FSG77XYT0qdUi5O+8jOjyyZQRUnkZ0UUeBMF3OQC/0VsyGlxligAAAABJRU5ErkJggg==' : 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAASElEQVQ4jWNgGJHAgIGBIYESze8ZGBjWU6L5PAMDgwBNNCdAFZJt83qoQmRDSHK2AFQhzBCy/IxsCNkBJsDAwLAfiknWPBIBAETPFeuA4fr6AAAAAElFTkSuQmCC',
    chevronLeft: scale > 2 ? 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAADAAAAAwCAYAAABXAvmHAAAAgElEQVRoge3YMQ6DQBAEwRYvnf8nPAECbAnkyATsrt0lXUyPdAE6kCRJ/yXA+jopLbkhwHY6a2nNl8I1ftSA8Bm/MeQKBeNrBONrBONrBONrhMHxcPwOlMUvT32oszD8CoEj+giO6CE4oofgiB7Cj44Y86zyFoYPgOFPi5Ik6WwHji+QVIOyhqgAAAAASUVORK5CYII=' : scale > 1 ? 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACQAAAAkCAYAAADhAJiYAAAAaUlEQVRYhe3WsQ2AMAwAwRcs5LEYg3HpYANoQKKgcEEUI/6adM5LbgySfmZsNDeACdiApdEfaQGswH6+Xd1jugc9xYQxxhjz9RhaxwxvDuul3MrAqDyjsozKKnWgXUqdsJcAZgqsTFJ5B7gjUNw0n0HHAAAAAElFTkSuQmCC' : 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAARklEQVQ4jWNgGPKAmUh1AQwMDBIMDAwPyLEkgYGB4T/UELI1J9BdcwCxmpnIMZ1YkECsK+hmCNZoZCHCgAUMDAwfoHg4AgDJuQ/bcLyV+QAAAABJRU5ErkJggg==',
    chevronRight: scale > 2 ? 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAADAAAAAwCAYAAABXAvmHAAAAeElEQVRoge3YMQ6AIBQE0Ykn3fs3HEEbC6MdFp+v8xJaspNQAZIkqbcA4zwpXTJpAPvlpHTNhHtAu4jwDDCiQjBiDcGINQQj1hCMWEN4Boy3l25vL/iL0PgJBcfXCI6vERxfIzi+Rmg8Hj7wrdL+Yys0/1qUJEmzDvSAkFQ8EOdJAAAAAElFTkSuQmCC' : scale > 1 ? 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACQAAAAkCAYAAADhAJiYAAAAZElEQVRYhe3WsQmAQAxA0Y8ulLEcw3HtdANtBNvzCJjD/5pUgQ9pApJ+Zu7YCWABDmDLzemzA+c94+MW4AkqExUY1caoVka1GibqlSm7qJJSJzPGGGMylYqBgi9sACtFYiQN7wKC6VDcJ7tlpQAAAABJRU5ErkJggg==' : 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAANUlEQVQ4jWNgGLbAgYGBIYASAwIYGBj+MzAwJFBiSMLQMISJEpMptp2mmimORgcGChPSEAIAHGENPH8gqdYAAAAASUVORK5CYII=',
    loader: scale > 2 ? 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAADAAAAAwCAYAAABXAvmHAAABXElEQVRoge2a3W3DMAyEr+0CHkGjaISOcKN4k6zQETpCR+gGzgbpQ10kcamIpKQ6avQBBPxg3pHwL2UDg/8LASxrcNdKnCwATmssrUyeWgnju/DmXs8tRP+Sh2kgAJga1rFlWj2rcMD5YqQh77QJLbzIORjyRIJQCJW5ngYo5AVlrsgkCGqbsDbAhFfxqZsSZibP0oDXQ43HQPsg82i7sBoR+VcJq2YxKcPo0IoJLRZXmYGC6ezQmQUdVqhPBVH/CNBTSMkLVlzjA8Bbocb7GoPBoADi+umZilYzbrG/JrnljOvy734iu4To/BQaDB6Rl4LciPPF9Lmjhgvi+s7w6tCIGw3WKS0P8fvWNjt0ZkGHFeq7CQXTbkZKGg2JOxrqPUZ3s6ziNdju38IjS/dLi0EQpDLX2gDQYHEX6Hx5/YcA+6H0NgAYPnCMj3x7Mxq4wTGx3Q1E578aDDR8AX0mOGD6BEN/AAAAAElFTkSuQmCC' : scale > 1 ? 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAABN0lEQVRYhe2WzU3EMBCFP34KyJEjJaQDXAIlJJ24BSow2wEdhHSwJSwd7JHbcmC0mOxMnDiWDIInWbHkN29exo4n8IvRAEFGU8OAA04yulyR60Jm7msbyIZloAMGwBfI4UWrWxM08LW/weC4iOMNTog4g0awKjBG827GxBwC3996NHizAifsSrTRmlsZm23CT9adktyXSq6ZUPdxgiXnZzW8CLcLuC3lvqA/gCt5NtjlPQL7TP0Wu1HtRRu4PO3T4TKTz2kG+AG9IN6CR/Su9iojBw69egfghWgL/pGCp+JFVPUqTjWjlsuqeAo1o6rt2C8QcNiV0UxoHPMieojmz0CfMKyhl1hN84xbI3gnz5Ftp7kH3iT5LsFdDUf6pzSJ6r2glIFDbuDNhqRH4I7Pvv4EvG/QqocP2Jh/xzzX/zUAAAAASUVORK5CYII=' : 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAsklEQVQ4jaWTYRHCMAyFP7gJmIQ6oChgEpBQKXMwC3MADpAAEiphDuBHC4QuDRu8u9ylyWtem7Rgw2X7GT1wsghb4beAVzhtsfYyJgs44AoEQzBkjrMId1HkKPwyZ6oMSnxYsnk1NqT7yMo34Fzhd9meGJvs7Hh3NhqCLXDI/rT0lKsR+KOJgc9RdaRRarkZvELogYsi8HqxjUhGYE+aQg1jzketwFTZXHbbEpjB8eU7PwAbLiJz46707gAAAABJRU5ErkJggg=='
  };
  module.exports = YellowBoxImageSource;
},376,[61],"node_modules/react-native/Libraries/YellowBox/UI/YellowBoxImageSource.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");

  var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");

  var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");

  var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native/Libraries/YellowBox/UI/YellowBoxInspectorSourceMapStatus.js";

  var Animated = _$$_REQUIRE(_dependencyMap[5], "../../Animated/src/Animated");

  var Easing = _$$_REQUIRE(_dependencyMap[6], "../../Animated/src/Easing");

  var React = _$$_REQUIRE(_dependencyMap[7], "react");

  var StyleSheet = _$$_REQUIRE(_dependencyMap[8], "../../StyleSheet/StyleSheet");

  var Text = _$$_REQUIRE(_dependencyMap[9], "../../Text/Text");

  var YellowBoxImageSource = _$$_REQUIRE(_dependencyMap[10], "./YellowBoxImageSource");

  var YellowBoxPressable = _$$_REQUIRE(_dependencyMap[11], "./YellowBoxPressable");

  var YellowBoxStyle = _$$_REQUIRE(_dependencyMap[12], "./YellowBoxStyle");

  var YellowBoxInspectorSourceMapStatus = function (_React$Component) {
    _inherits(YellowBoxInspectorSourceMapStatus, _React$Component);

    function YellowBoxInspectorSourceMapStatus() {
      var _getPrototypeOf2;

      var _this;

      _classCallCheck(this, YellowBoxInspectorSourceMapStatus);

      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
        args[_key] = arguments[_key];
      }

      _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(YellowBoxInspectorSourceMapStatus)).call.apply(_getPrototypeOf2, [this].concat(args)));
      _this.state = {
        animation: null,
        rotate: null
      };
      return _this;
    }

    _createClass(YellowBoxInspectorSourceMapStatus, [{
      key: "render",
      value: function render() {
        var image;

        switch (this.props.status) {
          case 'COMPLETE':
            image = YellowBoxImageSource.check;
            break;

          case 'FAILED':
            image = YellowBoxImageSource.alertTriangle;
            break;

          case 'PENDING':
            image = YellowBoxImageSource.loader;
            break;
        }

        return image == null ? null : React.createElement(YellowBoxPressable, {
          backgroundColor: {
            default: YellowBoxStyle.getTextColor(0.8),
            pressed: YellowBoxStyle.getTextColor(0.6)
          },
          hitSlop: {
            bottom: 8,
            left: 8,
            right: 8,
            top: 8
          },
          onPress: this.props.onPress,
          style: StyleSheet.compose(styles.root, this.props.status === 'PENDING' ? styles.pending : null),
          __source: {
            fileName: _jsxFileName,
            lineNumber: 57
          }
        }, React.createElement(Animated.Image, {
          source: {
            height: 16,
            uri: image,
            width: 16
          },
          style: StyleSheet.compose(styles.image, this.state.rotate == null ? null : {
            transform: [{
              rotate: this.state.rotate
            }]
          }),
          __source: {
            fileName: _jsxFileName,
            lineNumber: 68
          }
        }), React.createElement(Text, {
          style: styles.text,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 77
          }
        }, "Source Map"));
      }
    }, {
      key: "componentDidMount",
      value: function componentDidMount() {
        this._updateAnimation();
      }
    }, {
      key: "componentDidUpdate",
      value: function componentDidUpdate() {
        this._updateAnimation();
      }
    }, {
      key: "componentWillUnmount",
      value: function componentWillUnmount() {
        if (this.state.animation != null) {
          this.state.animation.stop();
        }
      }
    }, {
      key: "_updateAnimation",
      value: function _updateAnimation() {
        if (this.props.status === 'PENDING') {
          if (this.state.animation == null) {
            var animated = new Animated.Value(0);
            var animation = Animated.loop(Animated.timing(animated, {
              duration: 2000,
              easing: Easing.linear,
              toValue: 1,
              useNativeDriver: true
            }));
            this.setState({
              animation: animation,
              rotate: animated.interpolate({
                inputRange: [0, 1],
                outputRange: ['0deg', '360deg']
              })
            }, function () {
              animation.start();
            });
          }
        } else {
          if (this.state.animation != null) {
            this.state.animation.stop();
            this.setState({
              animation: null,
              rotate: null
            });
          }
        }
      }
    }]);

    return YellowBoxInspectorSourceMapStatus;
  }(React.Component);

  var styles = StyleSheet.create({
    root: {
      alignItems: 'center',
      borderRadius: 12,
      flexDirection: 'row',
      height: 24,
      paddingHorizontal: 8
    },
    pending: {
      backgroundColor: YellowBoxStyle.getTextColor(0.6)
    },
    image: {
      marginEnd: 4,
      tintColor: YellowBoxStyle.getBackgroundColor(1)
    },
    text: {
      color: YellowBoxStyle.getBackgroundColor(1),
      fontSize: 12,
      includeFontPadding: false,
      lineHeight: 16
    }
  });
  module.exports = YellowBoxInspectorSourceMapStatus;
},377,[24,25,32,34,37,261,289,54,60,235,376,369,370],"node_modules/react-native/Libraries/YellowBox/UI/YellowBoxInspectorSourceMapStatus.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native/Libraries/YellowBox/UI/YellowBoxInspectorStackFrame.js";

  var React = _$$_REQUIRE(_dependencyMap[0], "react");

  var StyleSheet = _$$_REQUIRE(_dependencyMap[1], "../../StyleSheet/StyleSheet");

  var Text = _$$_REQUIRE(_dependencyMap[2], "../../Text/Text");

  var YellowBoxPressable = _$$_REQUIRE(_dependencyMap[3], "./YellowBoxPressable");

  var YellowBoxStyle = _$$_REQUIRE(_dependencyMap[4], "./YellowBoxStyle");

  var YellowBoxInspectorStackFrame = function YellowBoxInspectorStackFrame(props) {
    var frame = props.frame,
        onPress = props.onPress;
    return React.createElement(YellowBoxPressable, {
      backgroundColor: {
        default: YellowBoxStyle.getBackgroundColor(0),
        pressed: YellowBoxStyle.getHighlightColor(1)
      },
      onPress: onPress,
      style: styles.frame,
      __source: {
        fileName: _jsxFileName,
        lineNumber: 31
      }
    }, React.createElement(Text, {
      style: styles.frameName,
      __source: {
        fileName: _jsxFileName,
        lineNumber: 38
      }
    }, frame.methodName), React.createElement(Text, {
      ellipsizeMode: "middle",
      numberOfLines: 1,
      style: styles.frameLocation,
      __source: {
        fileName: _jsxFileName,
        lineNumber: 39
      }
    }, formatFrameLocation(frame)));
  };

  var formatFrameLocation = function formatFrameLocation(frame) {
    var file = frame.file,
        lineNumber = frame.lineNumber,
        column = frame.column;

    if (file == null) {
      return '<unknown>';
    }

    var queryIndex = file.indexOf('?');
    var query = queryIndex < 0 ? '' : file.substr(queryIndex);
    var path = queryIndex < 0 ? file : file.substr(0, queryIndex);
    var location = path.substr(path.lastIndexOf('/') + 1) + query;

    if (lineNumber == null) {
      return location;
    }

    location = location + ':' + lineNumber;

    if (column == null) {
      return location;
    }

    return location + ':' + column;
  };

  var styles = StyleSheet.create({
    frame: {
      paddingHorizontal: 12,
      paddingVertical: 4
    },
    frameName: {
      color: YellowBoxStyle.getTextColor(1),
      fontSize: 14,
      includeFontPadding: false,
      lineHeight: 18
    },
    frameLocation: {
      color: YellowBoxStyle.getTextColor(0.7),
      fontSize: 12,
      fontWeight: '300',
      includeFontPadding: false,
      lineHeight: 16
    }
  });
  module.exports = YellowBoxInspectorStackFrame;
},378,[54,60,235,369,370],"node_modules/react-native/Libraries/YellowBox/UI/YellowBoxInspectorStackFrame.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");

  var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");

  var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");

  var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native/Libraries/YellowBox/UI/YellowBoxListRow.js";

  var React = _$$_REQUIRE(_dependencyMap[5], "react");

  var StyleSheet = _$$_REQUIRE(_dependencyMap[6], "../../StyleSheet/StyleSheet");

  var Text = _$$_REQUIRE(_dependencyMap[7], "../../Text/Text");

  var View = _$$_REQUIRE(_dependencyMap[8], "../../Components/View/View");

  var YellowBoxCategory = _$$_REQUIRE(_dependencyMap[9], "../Data/YellowBoxCategory");

  var YellowBoxPressable = _$$_REQUIRE(_dependencyMap[10], "./YellowBoxPressable");

  var YellowBoxStyle = _$$_REQUIRE(_dependencyMap[11], "./YellowBoxStyle");

  var YellowBoxWarning = _$$_REQUIRE(_dependencyMap[12], "../Data/YellowBoxWarning");

  var YellowBoxListRow = function (_React$Component) {
    _inherits(YellowBoxListRow, _React$Component);

    function YellowBoxListRow() {
      var _getPrototypeOf2;

      var _this;

      _classCallCheck(this, YellowBoxListRow);

      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
        args[_key] = arguments[_key];
      }

      _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(YellowBoxListRow)).call.apply(_getPrototypeOf2, [this].concat(args)));

      _this._handlePress = function () {
        _this.props.onPress(_this.props.category);
      };

      return _this;
    }

    _createClass(YellowBoxListRow, [{
      key: "shouldComponentUpdate",
      value: function shouldComponentUpdate(nextProps) {
        var prevProps = this.props;
        return prevProps.category !== nextProps.category || prevProps.onPress !== nextProps.onPress || prevProps.warnings.length !== nextProps.warnings.length || prevProps.warnings.some(function (prevWarning, index) {
          return prevWarning !== nextProps.warnings[index];
        });
      }
    }, {
      key: "render",
      value: function render() {
        var warnings = this.props.warnings;
        return React.createElement(YellowBoxPressable, {
          onPress: this._handlePress,
          style: styles.root,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 50
          }
        }, React.createElement(View, {
          style: styles.content,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 51
          }
        }, warnings.length < 2 ? null : React.createElement(Text, {
          style: styles.metaText,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 53
          }
        }, '(' + warnings.length + ') '), React.createElement(Text, {
          numberOfLines: 2,
          style: styles.bodyText,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 55
          }
        }, YellowBoxCategory.render(warnings[warnings.length - 1].message, styles.substitutionText))));
      }
    }]);

    return YellowBoxListRow;
  }(React.Component);

  YellowBoxListRow.GUTTER = StyleSheet.hairlineWidth;
  YellowBoxListRow.HEIGHT = 48;
  var styles = StyleSheet.create({
    root: {
      height: YellowBoxListRow.HEIGHT,
      justifyContent: 'center',
      marginTop: YellowBoxListRow.GUTTER,
      paddingHorizontal: 12
    },
    content: {
      alignItems: 'flex-start',
      flexDirection: 'row'
    },
    bodyText: {
      color: YellowBoxStyle.getTextColor(1),
      flex: 1,
      fontSize: 14,
      includeFontPadding: false,
      lineHeight: 18
    },
    metaText: {
      color: YellowBoxStyle.getTextColor(0.5),
      fontSize: 14,
      includeFontPadding: false,
      lineHeight: 18
    },
    substitutionText: {
      color: YellowBoxStyle.getTextColor(0.6)
    }
  });
  module.exports = YellowBoxListRow;
},379,[24,25,32,34,37,54,60,235,86,372,369,370,380],"node_modules/react-native/Libraries/YellowBox/UI/YellowBoxListRow.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass");

  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

  var YellowBoxCategory = _$$_REQUIRE(_dependencyMap[3], "./YellowBoxCategory");

  var YellowBoxSymbolication = _$$_REQUIRE(_dependencyMap[4], "./YellowBoxSymbolication");

  var parseErrorStack = _$$_REQUIRE(_dependencyMap[5], "../../Core/Devtools/parseErrorStack");

  var YellowBoxWarning = function () {
    _createClass(YellowBoxWarning, null, [{
      key: "parse",
      value: function parse(_ref) {
        var args = _ref.args,
            framesToPop = _ref.framesToPop;
        return _objectSpread({}, YellowBoxCategory.parse(args), {
          stack: createStack({
            framesToPop: framesToPop + 1
          })
        });
      }
    }]);

    function YellowBoxWarning(message, stack) {
      _classCallCheck(this, YellowBoxWarning);

      this.symbolicated = {
        error: null,
        stack: null,
        status: 'NONE'
      };
      this.message = message;
      this.stack = stack;
    }

    _createClass(YellowBoxWarning, [{
      key: "getAvailableStack",
      value: function getAvailableStack() {
        return this.symbolicated.status === 'COMPLETE' ? this.symbolicated.stack : this.stack;
      }
    }, {
      key: "retrySymbolicate",
      value: function retrySymbolicate(callback) {
        YellowBoxSymbolication.delete(this.stack);
        return this.symbolicate(callback);
      }
    }, {
      key: "symbolicate",
      value: function symbolicate(callback) {
        var _this = this;

        var aborted = false;

        if (this.symbolicated.status !== 'COMPLETE') {
          var updateStatus = function updateStatus(error, stack) {
            if (error != null) {
              _this.symbolicated = {
                error: error,
                stack: null,
                status: 'FAILED'
              };
            } else if (stack != null) {
              _this.symbolicated = {
                error: null,
                stack: stack,
                status: 'COMPLETE'
              };
            } else {
              _this.symbolicated = {
                error: null,
                stack: null,
                status: 'PENDING'
              };
            }

            if (!aborted) {
              callback();
            }
          };

          updateStatus(null, null);
          YellowBoxSymbolication.symbolicate(this.stack).then(function (stack) {
            updateStatus(null, stack);
          }, function (error) {
            updateStatus(error, null);
          });
        }

        return {
          abort: function abort() {
            aborted = true;
          }
        };
      }
    }]);

    return YellowBoxWarning;
  }();

  function createStack(_ref2) {
    var framesToPop = _ref2.framesToPop;
    var error = new Error();
    error.framesToPop = framesToPop + 1;
    return parseErrorStack(error);
  }

  module.exports = YellowBoxWarning;
},380,[46,24,25,372,381,100],"node_modules/react-native/Libraries/YellowBox/Data/YellowBoxWarning.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var symbolicateStackTrace = _$$_REQUIRE(_dependencyMap[0], "../../Core/Devtools/symbolicateStackTrace");

  var cache = new Map();
  var YellowBoxSymbolication = {
    delete: function _delete(stack) {
      cache.delete(getCacheKey(stack));
    },
    symbolicate: function symbolicate(stack) {
      var key = getCacheKey(stack);
      var promise = cache.get(key);

      if (promise == null) {
        promise = symbolicateStackTrace(stack).then(sanitize);
        cache.set(key, promise);
      }

      return promise;
    }
  };

  var getCacheKey = function getCacheKey(stack) {
    return JSON.stringify(stack);
  };

  var sanitize = function sanitize(maybeStack) {
    if (!Array.isArray(maybeStack)) {
      throw new Error('Expected stack to be an array.');
    }

    var stack = [];

    for (var _iterator = maybeStack, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"]();;) {
      var _ref;

      if (_isArray) {
        if (_i >= _iterator.length) break;
        _ref = _iterator[_i++];
      } else {
        _i = _iterator.next();
        if (_i.done) break;
        _ref = _i.value;
      }

      var _maybeFrame = _ref;

      if (typeof _maybeFrame !== 'object' || _maybeFrame == null) {
        throw new Error('Expected each stack frame to be an object.');
      }

      if (typeof _maybeFrame.column !== 'number' && _maybeFrame.column != null) {
        throw new Error('Expected stack frame `column` to be a nullable number.');
      }

      if (typeof _maybeFrame.file !== 'string') {
        throw new Error('Expected stack frame `file` to be a string.');
      }

      if (typeof _maybeFrame.lineNumber !== 'number') {
        throw new Error('Expected stack frame `lineNumber` to be a number.');
      }

      if (typeof _maybeFrame.methodName !== 'string') {
        throw new Error('Expected stack frame `methodName` to be a string.');
      }

      stack.push({
        column: _maybeFrame.column,
        file: _maybeFrame.file,
        lineNumber: _maybeFrame.lineNumber,
        methodName: _maybeFrame.methodName
      });
    }

    return stack;
  };

  module.exports = YellowBoxSymbolication;
},381,[102],"node_modules/react-native/Libraries/YellowBox/Data/YellowBoxSymbolication.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _toConsumableArray = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/toConsumableArray");

  var _slicedToArray = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/slicedToArray");

  var YellowBoxWarning = _$$_REQUIRE(_dependencyMap[2], "./YellowBoxWarning");

  var observers = new Set();
  var ignorePatterns = new Set();
  var registry = new Map();
  var disabled = false;
  var projection = new Map();
  var updateTimeout = null;

  function isWarningIgnored(warning) {
    for (var _iterator = ignorePatterns, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"]();;) {
      var _ref;

      if (_isArray) {
        if (_i >= _iterator.length) break;
        _ref = _iterator[_i++];
      } else {
        _i = _iterator.next();
        if (_i.done) break;
        _ref = _i.value;
      }

      var _pattern = _ref;

      if (_pattern instanceof RegExp && _pattern.test(warning.message.content)) {
        return true;
      } else if (typeof _pattern === 'string' && warning.message.content.includes(_pattern)) {
        return true;
      }
    }

    return false;
  }

  function handleUpdate() {
    projection = new Map();

    if (!disabled) {
      for (var _iterator2 = registry, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"]();;) {
        var _ref4;

        if (_isArray2) {
          if (_i2 >= _iterator2.length) break;
          _ref4 = _iterator2[_i2++];
        } else {
          _i2 = _iterator2.next();
          if (_i2.done) break;
          _ref4 = _i2.value;
        }

        var _ref5 = _ref4;

        var _ref3 = _slicedToArray(_ref5, 2);

        var _category = _ref3[0];
        var _warnings = _ref3[1];

        var _filtered = _warnings.filter(function (warning) {
          return !isWarningIgnored(warning);
        });

        if (_filtered.length > 0) {
          projection.set(_category, _filtered);
        }
      }
    }

    if (updateTimeout == null) {
      updateTimeout = setImmediate(function () {
        updateTimeout = null;

        for (var _iterator3 = observers, _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"]();;) {
          var _ref7;

          if (_isArray3) {
            if (_i3 >= _iterator3.length) break;
            _ref7 = _iterator3[_i3++];
          } else {
            _i3 = _iterator3.next();
            if (_i3.done) break;
            _ref7 = _i3.value;
          }

          var _ref8 = _ref7;
          var _observer = _ref8.observer;

          _observer(projection);
        }
      });
    }
  }

  var YellowBoxRegistry = {
    add: function add(_ref9) {
      var args = _ref9.args,
          framesToPop = _ref9.framesToPop;

      if (typeof args[0] === 'string' && args[0].startsWith('(ADVICE)')) {
        return;
      }

      var _YellowBoxWarning$par = YellowBoxWarning.parse({
        args: args,
        framesToPop: framesToPop + 1
      }),
          category = _YellowBoxWarning$par.category,
          message = _YellowBoxWarning$par.message,
          stack = _YellowBoxWarning$par.stack;

      var warnings = registry.get(category);

      if (warnings == null) {
        warnings = [];
      }

      warnings = [].concat(_toConsumableArray(warnings), [new YellowBoxWarning(message, stack)]);
      registry.delete(category);
      registry.set(category, warnings);
      handleUpdate();
    },
    delete: function _delete(category) {
      if (registry.has(category)) {
        registry.delete(category);
        handleUpdate();
      }
    },
    clear: function clear() {
      if (registry.size > 0) {
        registry.clear();
        handleUpdate();
      }
    },
    addIgnorePatterns: function addIgnorePatterns(patterns) {
      var newPatterns = patterns.filter(function (pattern) {
        if (pattern instanceof RegExp) {
          for (var _iterator4 = ignorePatterns.entries(), _isArray4 = Array.isArray(_iterator4), _i4 = 0, _iterator4 = _isArray4 ? _iterator4 : _iterator4[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"]();;) {
            var _ref10;

            if (_isArray4) {
              if (_i4 >= _iterator4.length) break;
              _ref10 = _iterator4[_i4++];
            } else {
              _i4 = _iterator4.next();
              if (_i4.done) break;
              _ref10 = _i4.value;
            }

            var _existingPattern = _ref10;

            if (_existingPattern instanceof RegExp && _existingPattern.toString() === pattern.toString()) {
              return false;
            }
          }

          return true;
        }

        return !ignorePatterns.has(pattern);
      });

      if (newPatterns.length === 0) {
        return;
      }

      for (var _iterator5 = newPatterns, _isArray5 = Array.isArray(_iterator5), _i5 = 0, _iterator5 = _isArray5 ? _iterator5 : _iterator5[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"]();;) {
        var _ref11;

        if (_isArray5) {
          if (_i5 >= _iterator5.length) break;
          _ref11 = _iterator5[_i5++];
        } else {
          _i5 = _iterator5.next();
          if (_i5.done) break;
          _ref11 = _i5.value;
        }

        var _pattern2 = _ref11;
        ignorePatterns.add(_pattern2);
      }

      handleUpdate();
    },
    setDisabled: function setDisabled(value) {
      if (value === disabled) {
        return;
      }

      disabled = value;
      handleUpdate();
    },
    isDisabled: function isDisabled() {
      return disabled;
    },
    observe: function observe(observer) {
      var subscription = {
        observer: observer
      };
      observers.add(subscription);
      observer(projection);
      return {
        unsubscribe: function unsubscribe() {
          observers.delete(subscription);
        }
      };
    }
  };
  module.exports = YellowBoxRegistry;
},382,[20,14,380],"node_modules/react-native/Libraries/YellowBox/Data/YellowBoxRegistry.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass");

  var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn");

  var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf");

  var _inherits = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits");

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native/Libraries/Components/Picker/Picker.js";

  var PickerAndroid = _$$_REQUIRE(_dependencyMap[6], "./PickerAndroid");

  var PickerIOS = _$$_REQUIRE(_dependencyMap[7], "./PickerIOS");

  var Platform = _$$_REQUIRE(_dependencyMap[8], "../../Utilities/Platform");

  var React = _$$_REQUIRE(_dependencyMap[9], "react");

  var UnimplementedView = _$$_REQUIRE(_dependencyMap[10], "../UnimplementedViews/UnimplementedView");

  var MODE_DIALOG = 'dialog';
  var MODE_DROPDOWN = 'dropdown';

  var PickerItem = function (_React$Component) {
    _inherits(PickerItem, _React$Component);

    function PickerItem() {
      _classCallCheck(this, PickerItem);

      return _possibleConstructorReturn(this, _getPrototypeOf(PickerItem).apply(this, arguments));
    }

    _createClass(PickerItem, [{
      key: "render",
      value: function render() {
        throw null;
      }
    }]);

    return PickerItem;
  }(React.Component);

  var Picker = function (_React$Component2) {
    _inherits(Picker, _React$Component2);

    function Picker() {
      _classCallCheck(this, Picker);

      return _possibleConstructorReturn(this, _getPrototypeOf(Picker).apply(this, arguments));
    }

    _createClass(Picker, [{
      key: "render",
      value: function render() {
        if ("android" === 'ios') {
          return React.createElement(PickerIOS, _extends({}, this.props, {
            __source: {
              fileName: _jsxFileName,
              lineNumber: 143
            }
          }), this.props.children);
        } else if ("android" === 'android') {
          return React.createElement(PickerAndroid, _extends({}, this.props, {
            __source: {
              fileName: _jsxFileName,
              lineNumber: 148
            }
          }), this.props.children);
        } else {
          return React.createElement(UnimplementedView, {
            __source: {
              fileName: _jsxFileName,
              lineNumber: 151
            }
          });
        }
      }
    }]);

    return Picker;
  }(React.Component);

  Picker.MODE_DIALOG = MODE_DIALOG;
  Picker.MODE_DROPDOWN = MODE_DROPDOWN;
  Picker.Item = PickerItem;
  Picker.defaultProps = {
    mode: MODE_DIALOG
  };
  module.exports = Picker;
},383,[13,24,25,32,34,37,384,387,48,54,340],"node_modules/react-native/Libraries/Components/Picker/Picker.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/interopRequireWildcard");

  var _extends2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/extends"));

  var _slicedToArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/slicedToArray"));

  var _AndroidDropdownPickerNativeComponent = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "./AndroidDropdownPickerNativeComponent"));

  var _AndroidDialogPickerNativeComponent = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "./AndroidDialogPickerNativeComponent"));

  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[6], "react"));

  var _StyleSheet = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "../../StyleSheet/StyleSheet"));

  var _processColor = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "../../StyleSheet/processColor"));

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native/Libraries/Components/Picker/PickerAndroid.android.js";

  function PickerAndroid(props) {
    var pickerRef = React.useRef(null);

    var _React$useMemo = React.useMemo(function () {
      var selected = 0;
      var items = React.Children.map(props.children, function (child, index) {
        if (child === null) {
          return null;
        }

        if (child.props.value === props.selectedValue) {
          selected = index;
        }

        var _child$props = child.props,
            color = _child$props.color,
            label = _child$props.label;
        return {
          color: color == null ? null : (0, _processColor.default)(color),
          label: label
        };
      });
      return [items, selected];
    }, [props.children, props.selectedValue]),
        _React$useMemo2 = (0, _slicedToArray2.default)(_React$useMemo, 2),
        items = _React$useMemo2[0],
        selected = _React$useMemo2[1];

    var onSelect = React.useCallback(function (_ref) {
      var nativeEvent = _ref.nativeEvent;
      var position = nativeEvent.position;
      var onValueChange = props.onValueChange;

      if (onValueChange != null) {
        if (position >= 0) {
          var children = React.Children.toArray(props.children).filter(function (item) {
            return item != null;
          });
          var value = children[position].props.value;

          if (props.selectedValue !== value) {
            onValueChange(value, position);
          }
        } else {
          onValueChange(null, position);
        }
      }

      var current = pickerRef.current;

      if (current != null && position !== selected) {
        current.setNativeProps({
          selected: selected
        });
      }
    }, [props.children, props.onValueChange, props.selectedValue, selected]);
    var rootProps = {
      accessibilityLabel: props.accessibilityLabel,
      enabled: props.enabled,
      items: items,
      onSelect: onSelect,
      prompt: props.prompt,
      ref: pickerRef,
      selected: selected,
      style: _StyleSheet.default.compose(styles.pickerAndroid, props.style),
      testID: props.testID
    };
    return props.mode === 'dropdown' ? React.createElement(_AndroidDropdownPickerNativeComponent.default, (0, _extends2.default)({}, rootProps, {
      __source: {
        fileName: _jsxFileName,
        lineNumber: 110
      }
    })) : React.createElement(_AndroidDialogPickerNativeComponent.default, (0, _extends2.default)({}, rootProps, {
      __source: {
        fileName: _jsxFileName,
        lineNumber: 112
      }
    }));
  }

  var styles = _StyleSheet.default.create({
    pickerAndroid: {
      height: 50
    }
  });

  module.exports = PickerAndroid;
},384,[1,9,13,14,385,386,54,60,80],"node_modules/react-native/Libraries/Components/Picker/PickerAndroid.android.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _reactNative = _$$_REQUIRE(_dependencyMap[0], "react-native");

  module.exports = (0, _reactNative.requireNativeComponent)('AndroidDropdownPicker');
},385,[2],"node_modules/react-native/Libraries/Components/Picker/AndroidDropdownPickerNativeComponent.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _reactNative = _$$_REQUIRE(_dependencyMap[0], "react-native");

  module.exports = (0, _reactNative.requireNativeComponent)('AndroidDialogPicker');
},386,[2],"node_modules/react-native/Libraries/Components/Picker/AndroidDialogPickerNativeComponent.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  module.exports = _$$_REQUIRE(_dependencyMap[0], "../UnimplementedViews/UnimplementedView");
},387,[340],"node_modules/react-native/Libraries/Components/Picker/PickerIOS.android.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");

  var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");

  var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");

  var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native/Libraries/Components/ProgressViewIOS/ProgressViewIOS.android.js";

  var React = _$$_REQUIRE(_dependencyMap[5], "react");

  var StyleSheet = _$$_REQUIRE(_dependencyMap[6], "../../StyleSheet/StyleSheet");

  var Text = _$$_REQUIRE(_dependencyMap[7], "../../Text/Text");

  var View = _$$_REQUIRE(_dependencyMap[8], "../View/View");

  var DummyProgressViewIOS = function (_React$Component) {
    _inherits(DummyProgressViewIOS, _React$Component);

    function DummyProgressViewIOS() {
      _classCallCheck(this, DummyProgressViewIOS);

      return _possibleConstructorReturn(this, _getPrototypeOf(DummyProgressViewIOS).apply(this, arguments));
    }

    _createClass(DummyProgressViewIOS, [{
      key: "render",
      value: function render() {
        return React.createElement(View, {
          style: [styles.dummy, this.props.style],
          __source: {
            fileName: _jsxFileName,
            lineNumber: 20
          }
        }, React.createElement(Text, {
          style: styles.text,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 21
          }
        }, "ProgressViewIOS is not supported on this platform!"));
      }
    }]);

    return DummyProgressViewIOS;
  }(React.Component);

  var 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;
},388,[24,25,32,34,37,54,60,235,86],"node_modules/react-native/Libraries/Components/ProgressViewIOS/ProgressViewIOS.android.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");

  var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");

  var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");

  var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native/Libraries/Components/SegmentedControlIOS/SegmentedControlIOS.android.js";

  var React = _$$_REQUIRE(_dependencyMap[5], "react");

  var StyleSheet = _$$_REQUIRE(_dependencyMap[6], "../../StyleSheet/StyleSheet");

  var Text = _$$_REQUIRE(_dependencyMap[7], "../../Text/Text");

  var View = _$$_REQUIRE(_dependencyMap[8], "../View/View");

  var DummySegmentedControlIOS = function (_React$Component) {
    _inherits(DummySegmentedControlIOS, _React$Component);

    function DummySegmentedControlIOS() {
      _classCallCheck(this, DummySegmentedControlIOS);

      return _possibleConstructorReturn(this, _getPrototypeOf(DummySegmentedControlIOS).apply(this, arguments));
    }

    _createClass(DummySegmentedControlIOS, [{
      key: "render",
      value: function render() {
        return React.createElement(View, {
          style: [styles.dummy, this.props.style],
          __source: {
            fileName: _jsxFileName,
            lineNumber: 20
          }
        }, React.createElement(Text, {
          style: styles.text,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 21
          }
        }, "SegmentedControlIOS is not supported on this platform!"));
      }
    }]);

    return DummySegmentedControlIOS;
  }(React.Component);

  var 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;
},389,[24,25,32,34,37,54,60,235,86],"node_modules/react-native/Libraries/Components/SegmentedControlIOS/SegmentedControlIOS.android.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _extends2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/extends"));

  var _objectWithoutProperties2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/objectWithoutProperties"));

  var _SliderNativeComponent = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "./SliderNativeComponent"));

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native/Libraries/Components/Slider/Slider.js";

  var Platform = _$$_REQUIRE(_dependencyMap[4], "../../Utilities/Platform");

  var React = _$$_REQUIRE(_dependencyMap[5], "react");

  var ReactNative = _$$_REQUIRE(_dependencyMap[6], "../../Renderer/shims/ReactNative");

  var StyleSheet = _$$_REQUIRE(_dependencyMap[7], "../../StyleSheet/StyleSheet");

  var Slider = function Slider(props, forwardedRef) {
    var style = StyleSheet.compose(styles.slider, props.style);
    var onValueChange = props.onValueChange,
        onSlidingComplete = props.onSlidingComplete,
        localProps = (0, _objectWithoutProperties2.default)(props, ["onValueChange", "onSlidingComplete"]);
    var onValueChangeEvent = onValueChange ? function (event) {
      var userEvent = true;

      if ("android" === 'android') {
        userEvent = event.nativeEvent.fromUser != null && event.nativeEvent.fromUser;
      }

      userEvent && onValueChange(event.nativeEvent.value);
    } : null;
    var onChangeEvent = onValueChangeEvent;
    var onSlidingCompleteEvent = onSlidingComplete ? function (event) {
      onSlidingComplete(event.nativeEvent.value);
    } : null;
    return React.createElement(_SliderNativeComponent.default, (0, _extends2.default)({}, localProps, {
      ref: forwardedRef,
      style: style,
      onChange: onChangeEvent,
      onSlidingComplete: onSlidingCompleteEvent,
      onValueChange: onValueChangeEvent,
      enabled: !props.disabled,
      onStartShouldSetResponder: function onStartShouldSetResponder() {
        return true;
      },
      onResponderTerminationRequest: function onResponderTerminationRequest() {
        return false;
      },
      __source: {
        fileName: _jsxFileName,
        lineNumber: 230
      }
    }));
  };

  var SliderWithRef = React.forwardRef(Slider);
  SliderWithRef.defaultProps = {
    disabled: false,
    value: 0,
    minimumValue: 0,
    maximumValue: 1,
    step: 0
  };
  var styles;

  if ("android" === 'ios') {
    styles = StyleSheet.create({
      slider: {
        height: 40
      }
    });
  } else {
    styles = StyleSheet.create({
      slider: {}
    });
  }

  module.exports = SliderWithRef;
},390,[1,13,52,391,48,54,88,60],"node_modules/react-native/Libraries/Components/Slider/Slider.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _codegenNativeComponent = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../../Utilities/codegenNativeComponent"));

  var _default = (0, _codegenNativeComponent.default)('Slider', {
    interfaceOnly: true,
    paperComponentName: 'RCTSlider'
  });

  exports.default = _default;
},391,[1,222],"node_modules/react-native/Libraries/Components/Slider/SliderNativeComponent.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _extends2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/extends"));

  var _objectWithoutProperties2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/objectWithoutProperties"));

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf3 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "@babel/runtime/helpers/inherits"));

  var _SwitchNativeComponent = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "./SwitchNativeComponent"));

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native/Libraries/Components/Switch/Switch.js";

  var AndroidSwitchNativeComponent = _$$_REQUIRE(_dependencyMap[9], "./AndroidSwitchNativeComponent");

  var Platform = _$$_REQUIRE(_dependencyMap[10], "../../Utilities/Platform");

  var React = _$$_REQUIRE(_dependencyMap[11], "react");

  var StyleSheet = _$$_REQUIRE(_dependencyMap[12], "../../StyleSheet/StyleSheet");

  var Switch = function (_React$Component) {
    (0, _inherits2.default)(Switch, _React$Component);

    function Switch() {
      var _getPrototypeOf2;

      var _this;

      (0, _classCallCheck2.default)(this, Switch);

      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
        args[_key] = arguments[_key];
      }

      _this = (0, _possibleConstructorReturn2.default)(this, (_getPrototypeOf2 = (0, _getPrototypeOf3.default)(Switch)).call.apply(_getPrototypeOf2, [this].concat(args)));

      _this._handleChange = function (event) {
        if (_this._nativeSwitchRef == null) {
          return;
        }

        var value = _this.props.value === true;

        if ("android" === 'android') {
          _this._nativeSwitchRef.setNativeProps({
            on: value
          });
        } else {
          _this._nativeSwitchRef.setNativeProps({
            value: value
          });
        }

        if (_this.props.onChange != null) {
          _this.props.onChange(event);
        }

        if (_this.props.onValueChange != null) {
          _this.props.onValueChange(event.nativeEvent.value);
        }
      };

      _this._handleSwitchNativeComponentRef = function (ref) {
        _this._nativeSwitchRef = ref;
      };

      return _this;
    }

    (0, _createClass2.default)(Switch, [{
      key: "render",
      value: function render() {
        var _props$accessibilityR2;

        var _this$props = this.props,
            disabled = _this$props.disabled,
            ios_backgroundColor = _this$props.ios_backgroundColor,
            onChange = _this$props.onChange,
            onValueChange = _this$props.onValueChange,
            style = _this$props.style,
            thumbColor = _this$props.thumbColor,
            trackColor = _this$props.trackColor,
            value = _this$props.value,
            props = (0, _objectWithoutProperties2.default)(_this$props, ["disabled", "ios_backgroundColor", "onChange", "onValueChange", "style", "thumbColor", "trackColor", "value"]);
        var _thumbColor = thumbColor;

        var _trackColorForFalse = trackColor == null ? void 0 : trackColor.false;

        var _trackColorForTrue = trackColor == null ? void 0 : trackColor.true;

        var _ref = props,
            thumbTintColor = _ref.thumbTintColor,
            tintColor = _ref.tintColor,
            onTintColor = _ref.onTintColor;

        if (thumbTintColor != null) {
          _thumbColor = thumbTintColor;

          if (__DEV__) {
            console.warn('Switch: `thumbTintColor` is deprecated, use `thumbColor` instead.');
          }
        }

        if (tintColor != null) {
          _trackColorForFalse = tintColor;

          if (__DEV__) {
            console.warn('Switch: `tintColor` is deprecated, use `trackColor` instead.');
          }
        }

        if (onTintColor != null) {
          _trackColorForTrue = onTintColor;

          if (__DEV__) {
            console.warn('Switch: `onTintColor` is deprecated, use `trackColor` instead.');
          }
        }

        if ("android" === 'android') {
          var _props$accessibilityR;

          var _platformProps = {
            enabled: disabled !== true,
            on: value === true,
            style: style,
            thumbTintColor: _thumbColor,
            trackColorForFalse: _trackColorForFalse,
            trackColorForTrue: _trackColorForTrue,
            trackTintColor: value === true ? _trackColorForTrue : _trackColorForFalse
          };
          return React.createElement(AndroidSwitchNativeComponent, (0, _extends2.default)({}, props, _platformProps, {
            accessibilityRole: (_props$accessibilityR = props.accessibilityRole) != null ? _props$accessibilityR : 'button',
            onChange: this._handleChange,
            onResponderTerminationRequest: returnsFalse,
            onStartShouldSetResponder: returnsTrue,
            ref: this._handleSwitchNativeComponentRef,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 154
            }
          }));
        }

        var platformProps = {
          disabled: 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 React.createElement(_SwitchNativeComponent.default, (0, _extends2.default)({}, props, platformProps, {
          accessibilityRole: (_props$accessibilityR2 = props.accessibilityRole) != null ? _props$accessibilityR2 : 'button',
          onChange: this._handleChange,
          onResponderTerminationRequest: returnsFalse,
          onStartShouldSetResponder: returnsTrue,
          ref: this._handleSwitchNativeComponentRef,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 187
          }
        }));
      }
    }]);
    return Switch;
  }(React.Component);

  var returnsFalse = function returnsFalse() {
    return false;
  };

  var returnsTrue = function returnsTrue() {
    return true;
  };

  module.exports = Switch;
},392,[1,13,52,24,25,32,34,37,393,394,48,54,60],"node_modules/react-native/Libraries/Components/Switch/Switch.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _codegenNativeComponent = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../../Utilities/codegenNativeComponent"));

  var _default = (0, _codegenNativeComponent.default)('Switch', {
    paperComponentName: 'RCTSwitch'
  });

  exports.default = _default;
},393,[1,222],"node_modules/react-native/Libraries/Components/Switch/SwitchNativeComponent.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _require = _$$_REQUIRE(_dependencyMap[0], "../../Renderer/shims/ReactNative"),
      NativeComponent = _require.NativeComponent;

  var requireNativeComponent = _$$_REQUIRE(_dependencyMap[1], "../../ReactNative/requireNativeComponent");

  module.exports = requireNativeComponent('AndroidSwitch');
},394,[88,218],"node_modules/react-native/Libraries/Components/Switch/AndroidSwitchNativeComponent.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");

  var _possibleConstructorReturn = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn");

  var _getPrototypeOf = _$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf");

  var _inherits = _$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits");

  var _extends = _$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/extends");

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native/Libraries/Components/TextInput/TextInput.js";

  var DeprecatedTextInputPropTypes = _$$_REQUIRE(_dependencyMap[6], "../../DeprecatedPropTypes/DeprecatedTextInputPropTypes");

  var DocumentSelectionState = _$$_REQUIRE(_dependencyMap[7], "../../vendor/document/selection/DocumentSelectionState");

  var NativeMethodsMixin = _$$_REQUIRE(_dependencyMap[8], "../../Renderer/shims/NativeMethodsMixin");

  var Platform = _$$_REQUIRE(_dependencyMap[9], "../../Utilities/Platform");

  var React = _$$_REQUIRE(_dependencyMap[10], "react");

  var ReactNative = _$$_REQUIRE(_dependencyMap[11], "../../Renderer/shims/ReactNative");

  var StyleSheet = _$$_REQUIRE(_dependencyMap[12], "../../StyleSheet/StyleSheet");

  var Text = _$$_REQUIRE(_dependencyMap[13], "../../Text/Text");

  var TextAncestor = _$$_REQUIRE(_dependencyMap[14], "../../Text/TextAncestor");

  var TextInputState = _$$_REQUIRE(_dependencyMap[15], "./TextInputState");

  var TouchableWithoutFeedback = _$$_REQUIRE(_dependencyMap[16], "../Touchable/TouchableWithoutFeedback");

  var UIManager = _$$_REQUIRE(_dependencyMap[17], "../../ReactNative/UIManager");

  var createReactClass = _$$_REQUIRE(_dependencyMap[18], "create-react-class");

  var invariant = _$$_REQUIRE(_dependencyMap[19], "invariant");

  var requireNativeComponent = _$$_REQUIRE(_dependencyMap[20], "../../ReactNative/requireNativeComponent");

  var warning = _$$_REQUIRE(_dependencyMap[21], "fbjs/lib/warning");

  var AndroidTextInput;
  var RCTMultilineTextInputView;
  var RCTSinglelineTextInputView;

  if ("android" === 'android') {
    AndroidTextInput = requireNativeComponent('AndroidTextInput');
  } else if ("android" === 'ios') {
    RCTMultilineTextInputView = requireNativeComponent('RCTMultilineTextInputView');
    RCTSinglelineTextInputView = requireNativeComponent('RCTSinglelineTextInputView');
  }

  var onlyMultiline = {
    onTextInput: true,
    children: true
  };

  var emptyFunctionThatReturnsTrue = function emptyFunctionThatReturnsTrue() {
    return true;
  };

  var TextInput = createReactClass({
    displayName: 'TextInput',
    statics: {
      State: {
        currentlyFocusedField: TextInputState.currentlyFocusedField,
        focusTextInput: TextInputState.focusTextInput,
        blurTextInput: TextInputState.blurTextInput
      }
    },
    propTypes: DeprecatedTextInputPropTypes,
    getDefaultProps: function getDefaultProps() {
      return {
        allowFontScaling: true,
        rejectResponderTermination: true,
        underlineColorAndroid: 'transparent'
      };
    },
    mixins: [NativeMethodsMixin],
    isFocused: function isFocused() {
      return TextInputState.currentlyFocusedField() === ReactNative.findNodeHandle(this._inputRef);
    },
    _inputRef: undefined,
    _focusSubscription: undefined,
    _lastNativeText: undefined,
    _lastNativeSelection: undefined,
    _rafId: null,
    componentDidMount: function componentDidMount() {
      this._lastNativeText = this.props.value;
      var tag = ReactNative.findNodeHandle(this._inputRef);

      if (tag != null) {
        TextInputState.registerInput(tag);
      }

      if (this.props.autoFocus) {
        this._rafId = requestAnimationFrame(this.focus);
      }
    },
    componentWillUnmount: function componentWillUnmount() {
      this._focusSubscription && this._focusSubscription.remove();

      if (this.isFocused()) {
        this.blur();
      }

      var tag = ReactNative.findNodeHandle(this._inputRef);

      if (tag != null) {
        TextInputState.unregisterInput(tag);
      }

      if (this._rafId != null) {
        cancelAnimationFrame(this._rafId);
      }
    },
    clear: function clear() {
      this.setNativeProps({
        text: ''
      });
    },
    render: function render() {
      var textInput;

      if ("android" === 'ios') {
        textInput = UIManager.getViewManagerConfig('RCTVirtualText') ? this._renderIOS() : this._renderIOSLegacy();
      } else if ("android" === 'android') {
        textInput = this._renderAndroid();
      }

      return React.createElement(TextAncestor.Provider, {
        value: true,
        __source: {
          fileName: _jsxFileName,
          lineNumber: 891
        }
      }, textInput);
    },
    _getText: function _getText() {
      return typeof this.props.value === 'string' ? this.props.value : typeof this.props.defaultValue === 'string' ? this.props.defaultValue : '';
    },
    _setNativeRef: function _setNativeRef(ref) {
      this._inputRef = ref;
    },
    _renderIOSLegacy: function _renderIOSLegacy() {
      var textContainer;

      var props = _extends({}, this.props);

      props.style = [this.props.style];

      if (props.selection && props.selection.end == null) {
        props.selection = {
          start: props.selection.start,
          end: props.selection.start
        };
      }

      if (!props.multiline) {
        if (__DEV__) {
          for (var propKey in onlyMultiline) {
            if (props[propKey]) {
              var error = new Error('TextInput prop `' + propKey + '` is only supported with multiline.');
              warning(false, '%s', error.stack);
            }
          }
        }

        textContainer = React.createElement(RCTSinglelineTextInputView, _extends({
          ref: this._setNativeRef
        }, props, {
          onFocus: this._onFocus,
          onBlur: this._onBlur,
          onChange: this._onChange,
          onSelectionChange: this._onSelectionChange,
          onSelectionChangeShouldSetResponder: emptyFunctionThatReturnsTrue,
          text: this._getText(),
          __source: {
            fileName: _jsxFileName,
            lineNumber: 934
          }
        }));
      } else {
        var children = props.children;
        var childCount = 0;
        React.Children.forEach(children, function () {
          return ++childCount;
        });
        invariant(!(props.value && childCount), 'Cannot specify both value and children.');

        if (childCount >= 1) {
          children = React.createElement(Text, {
            style: props.style,
            allowFontScaling: props.allowFontScaling,
            maxFontSizeMultiplier: props.maxFontSizeMultiplier,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 955
            }
          }, children);
        }

        if (props.inputView) {
          children = [children, props.inputView];
        }

        props.style.unshift(styles.multilineInput);
        textContainer = React.createElement(RCTMultilineTextInputView, _extends({
          ref: this._setNativeRef
        }, props, {
          children: children,
          onFocus: this._onFocus,
          onBlur: this._onBlur,
          onChange: this._onChange,
          onContentSizeChange: this.props.onContentSizeChange,
          onSelectionChange: this._onSelectionChange,
          onTextInput: this._onTextInput,
          onSelectionChangeShouldSetResponder: emptyFunctionThatReturnsTrue,
          text: this._getText(),
          dataDetectorTypes: this.props.dataDetectorTypes,
          onScroll: this._onScroll,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 968
          }
        }));
      }

      return React.createElement(TouchableWithoutFeedback, {
        onLayout: props.onLayout,
        onPress: this._onPress,
        rejectResponderTermination: true,
        accessible: props.accessible,
        accessibilityLabel: props.accessibilityLabel,
        accessibilityRole: props.accessibilityRole,
        accessibilityStates: props.accessibilityStates,
        accessibilityState: props.accessibilityState,
        nativeID: this.props.nativeID,
        testID: props.testID,
        __source: {
          fileName: _jsxFileName,
          lineNumber: 987
        }
      }, textContainer);
    },
    _renderIOS: function _renderIOS() {
      var props = _extends({}, this.props);

      props.style = [this.props.style];

      if (props.selection && props.selection.end == null) {
        props.selection = {
          start: props.selection.start,
          end: props.selection.start
        };
      }

      var RCTTextInputView = props.multiline ? RCTMultilineTextInputView : RCTSinglelineTextInputView;

      if (props.multiline) {
        props.style.unshift(styles.multilineInput);
      }

      var textContainer = React.createElement(RCTTextInputView, _extends({
        ref: this._setNativeRef
      }, props, {
        onFocus: this._onFocus,
        onBlur: this._onBlur,
        onChange: this._onChange,
        onContentSizeChange: this.props.onContentSizeChange,
        onSelectionChange: this._onSelectionChange,
        onTextInput: this._onTextInput,
        onSelectionChangeShouldSetResponder: emptyFunctionThatReturnsTrue,
        text: this._getText(),
        dataDetectorTypes: this.props.dataDetectorTypes,
        onScroll: this._onScroll,
        __source: {
          fileName: _jsxFileName,
          lineNumber: 1023
        }
      }));
      return React.createElement(TouchableWithoutFeedback, {
        onLayout: props.onLayout,
        onPress: this._onPress,
        rejectResponderTermination: props.rejectResponderTermination,
        accessible: props.accessible,
        accessibilityLabel: props.accessibilityLabel,
        accessibilityRole: props.accessibilityRole,
        accessibilityStates: props.accessibilityStates,
        accessibilityState: props.accessibilityState,
        nativeID: this.props.nativeID,
        testID: props.testID,
        __source: {
          fileName: _jsxFileName,
          lineNumber: 1040
        }
      }, textContainer);
    },
    _renderAndroid: function _renderAndroid() {
      var props = _extends({}, this.props);

      props.style = [this.props.style];
      props.autoCapitalize = props.autoCapitalize || 'sentences';
      var children = this.props.children;
      var childCount = 0;
      React.Children.forEach(children, function () {
        return ++childCount;
      });
      invariant(!(this.props.value && childCount), 'Cannot specify both value and children.');

      if (childCount > 1) {
        children = React.createElement(Text, {
          __source: {
            fileName: _jsxFileName,
            lineNumber: 1068
          }
        }, children);
      }

      if (props.selection && props.selection.end == null) {
        props.selection = {
          start: props.selection.start,
          end: props.selection.start
        };
      }

      var textContainer = React.createElement(AndroidTextInput, _extends({
        ref: this._setNativeRef
      }, props, {
        mostRecentEventCount: 0,
        onFocus: this._onFocus,
        onBlur: this._onBlur,
        onChange: this._onChange,
        onSelectionChange: this._onSelectionChange,
        onTextInput: this._onTextInput,
        text: this._getText(),
        children: children,
        disableFullscreenUI: this.props.disableFullscreenUI,
        textBreakStrategy: this.props.textBreakStrategy,
        onScroll: this._onScroll,
        __source: {
          fileName: _jsxFileName,
          lineNumber: 1079
        }
      }));
      return React.createElement(TouchableWithoutFeedback, {
        onLayout: props.onLayout,
        onPress: this._onPress,
        accessible: this.props.accessible,
        accessibilityLabel: this.props.accessibilityLabel,
        accessibilityRole: this.props.accessibilityRole,
        accessibilityStates: this.props.accessibilityStates,
        accessibilityState: this.props.accessibilityState,
        nativeID: this.props.nativeID,
        testID: this.props.testID,
        __source: {
          fileName: _jsxFileName,
          lineNumber: 1097
        }
      }, textContainer);
    },
    _onFocus: function _onFocus(event) {
      if (this.props.onFocus) {
        this.props.onFocus(event);
      }

      if (this.props.selectionState) {
        this.props.selectionState.focus();
      }
    },
    _onPress: function _onPress(event) {
      if (this.props.editable || this.props.editable === undefined) {
        this.focus();
      }
    },
    _onChange: function _onChange(event) {
      if (this._inputRef && this._inputRef.setNativeProps) {
        ReactNative.setNativeProps(this._inputRef, {
          mostRecentEventCount: event.nativeEvent.eventCount
        });
      }

      var text = event.nativeEvent.text;
      this.props.onChange && this.props.onChange(event);
      this.props.onChangeText && this.props.onChangeText(text);

      if (!this._inputRef) {
        return;
      }

      this._lastNativeText = text;
      this.forceUpdate();
    },
    _onSelectionChange: function _onSelectionChange(event) {
      this.props.onSelectionChange && this.props.onSelectionChange(event);

      if (!this._inputRef) {
        return;
      }

      this._lastNativeSelection = event.nativeEvent.selection;

      if (this.props.selection || this.props.selectionState) {
        this.forceUpdate();
      }
    },
    componentDidUpdate: function componentDidUpdate() {
      var nativeProps = {};

      if (this._lastNativeText !== this.props.value && typeof this.props.value === 'string') {
        nativeProps.text = this.props.value;
      }

      var selection = this.props.selection;

      if (this._lastNativeSelection && selection && (this._lastNativeSelection.start !== selection.start || this._lastNativeSelection.end !== selection.end)) {
        nativeProps.selection = this.props.selection;
      }

      if (Object.keys(nativeProps).length > 0 && this._inputRef && this._inputRef.setNativeProps) {
        ReactNative.setNativeProps(this._inputRef, nativeProps);
      }

      if (this.props.selectionState && selection) {
        this.props.selectionState.update(selection.start, selection.end);
      }
    },
    _onBlur: function _onBlur(event) {
      this.blur();

      if (this.props.onBlur) {
        this.props.onBlur(event);
      }

      if (this.props.selectionState) {
        this.props.selectionState.blur();
      }
    },
    _onTextInput: function _onTextInput(event) {
      this.props.onTextInput && this.props.onTextInput(event);
    },
    _onScroll: function _onScroll(event) {
      this.props.onScroll && this.props.onScroll(event);
    }
  });

  var InternalTextInputType = function (_ReactNative$NativeCo) {
    _inherits(InternalTextInputType, _ReactNative$NativeCo);

    function InternalTextInputType() {
      _classCallCheck(this, InternalTextInputType);

      return _possibleConstructorReturn(this, _getPrototypeOf(InternalTextInputType).apply(this, arguments));
    }

    _createClass(InternalTextInputType, [{
      key: "clear",
      value: function clear() {}
    }, {
      key: "isFocused",
      value: function isFocused() {}
    }]);

    return InternalTextInputType;
  }(ReactNative.NativeComponent);

  var TypedTextInput = TextInput;
  var styles = StyleSheet.create({
    multilineInput: {
      paddingTop: 5
    }
  });
  module.exports = TypedTextInput;
},395,[24,25,32,34,37,13,396,397,325,48,54,88,60,235,240,195,251,43,252,3,218,5],"node_modules/react-native/Libraries/Components/TextInput/TextInput.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _defineProperty = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/defineProperty");

  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

  var PropTypes = _$$_REQUIRE(_dependencyMap[1], "prop-types");

  var DeprecatedColorPropType = _$$_REQUIRE(_dependencyMap[2], "./DeprecatedColorPropType");

  var DeprecatedViewPropTypes = _$$_REQUIRE(_dependencyMap[3], "./DeprecatedViewPropTypes");

  var DocumentSelectionState = _$$_REQUIRE(_dependencyMap[4], "../vendor/document/selection/DocumentSelectionState");

  var Text = _$$_REQUIRE(_dependencyMap[5], "../Text/Text");

  var DataDetectorTypes = ['phoneNumber', 'link', 'address', 'calendarEvent', 'none', 'all'];
  module.exports = _objectSpread({}, DeprecatedViewPropTypes, {
    autoCapitalize: PropTypes.oneOf(['none', 'sentences', 'words', 'characters']),
    autoCompleteType: PropTypes.oneOf(['cc-csc', 'cc-exp', 'cc-exp-month', 'cc-exp-year', 'cc-number', 'email', 'name', 'password', 'postal-code', 'street-address', 'tel', 'username', 'off']),
    autoCorrect: PropTypes.bool,
    spellCheck: PropTypes.bool,
    autoFocus: PropTypes.bool,
    allowFontScaling: PropTypes.bool,
    maxFontSizeMultiplier: PropTypes.number,
    editable: PropTypes.bool,
    keyboardType: PropTypes.oneOf(['default', 'email-address', 'numeric', 'phone-pad', 'number-pad', 'ascii-capable', 'numbers-and-punctuation', 'url', 'name-phone-pad', 'decimal-pad', 'twitter', 'web-search', 'visible-password']),
    keyboardAppearance: PropTypes.oneOf(['default', 'light', 'dark']),
    returnKeyType: PropTypes.oneOf(['done', 'go', 'next', 'search', 'send', 'none', 'previous', 'default', 'emergency-call', 'google', 'join', 'route', 'yahoo']),
    returnKeyLabel: PropTypes.string,
    maxLength: PropTypes.number,
    numberOfLines: PropTypes.number,
    disableFullscreenUI: PropTypes.bool,
    enablesReturnKeyAutomatically: PropTypes.bool,
    multiline: PropTypes.bool,
    textBreakStrategy: PropTypes.oneOf(['simple', 'highQuality', 'balanced']),
    onBlur: PropTypes.func,
    onFocus: PropTypes.func,
    onChange: PropTypes.func,
    onChangeText: PropTypes.func,
    onContentSizeChange: PropTypes.func,
    onTextInput: PropTypes.func,
    onEndEditing: PropTypes.func,
    onSelectionChange: PropTypes.func,
    onSubmitEditing: PropTypes.func,
    onKeyPress: PropTypes.func,
    onLayout: PropTypes.func,
    onScroll: PropTypes.func,
    placeholder: PropTypes.string,
    placeholderTextColor: DeprecatedColorPropType,
    scrollEnabled: PropTypes.bool,
    secureTextEntry: PropTypes.bool,
    selectionColor: DeprecatedColorPropType,
    selectionState: PropTypes.instanceOf(DocumentSelectionState),
    selection: PropTypes.shape({
      start: PropTypes.number.isRequired,
      end: PropTypes.number
    }),
    value: PropTypes.string,
    defaultValue: PropTypes.string,
    clearButtonMode: PropTypes.oneOf(['never', 'while-editing', 'unless-editing', 'always']),
    clearTextOnFocus: PropTypes.bool,
    selectTextOnFocus: PropTypes.bool,
    blurOnSubmit: PropTypes.bool,
    style: Text.propTypes.style,
    underlineColorAndroid: DeprecatedColorPropType,
    inlineImageLeft: PropTypes.string,
    inlineImagePadding: PropTypes.number,
    rejectResponderTermination: PropTypes.bool,
    dataDetectorTypes: PropTypes.oneOfType([PropTypes.oneOf(DataDetectorTypes), PropTypes.arrayOf(PropTypes.oneOf(DataDetectorTypes))]),
    caretHidden: PropTypes.bool,
    contextMenuHidden: PropTypes.bool,
    inputAccessoryViewID: PropTypes.string,
    textContentType: PropTypes.oneOf(['none', 'URL', 'addressCity', 'addressCityAndState', 'addressState', 'countryName', 'creditCardNumber', 'emailAddress', 'familyName', 'fullStreetAddress', 'givenName', 'jobTitle', 'location', 'middleName', 'name', 'namePrefix', 'nameSuffix', 'nickname', 'organizationName', 'postalCode', 'streetAddressLine1', 'streetAddressLine2', 'sublocality', 'telephoneNumber', 'username', 'password', 'newPassword', 'oneTimeCode']),
    showSoftInputOnFocus: PropTypes.bool
  });
},396,[46,69,66,315,397,235],"node_modules/react-native/Libraries/DeprecatedPropTypes/DeprecatedTextInputPropTypes.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");

  var mixInEventEmitter = _$$_REQUIRE(_dependencyMap[2], "../../emitter/mixInEventEmitter");

  var DocumentSelectionState = function () {
    function DocumentSelectionState(anchor, focus) {
      _classCallCheck(this, DocumentSelectionState);

      this._anchorOffset = anchor;
      this._focusOffset = focus;
      this._hasFocus = false;
    }

    _createClass(DocumentSelectionState, [{
      key: "update",
      value: function update(anchor, focus) {
        if (this._anchorOffset !== anchor || this._focusOffset !== focus) {
          this._anchorOffset = anchor;
          this._focusOffset = focus;
          this.emit('update');
        }
      }
    }, {
      key: "constrainLength",
      value: function constrainLength(maxLength) {
        this.update(Math.min(this._anchorOffset, maxLength), Math.min(this._focusOffset, maxLength));
      }
    }, {
      key: "focus",
      value: function focus() {
        if (!this._hasFocus) {
          this._hasFocus = true;
          this.emit('focus');
        }
      }
    }, {
      key: "blur",
      value: function blur() {
        if (this._hasFocus) {
          this._hasFocus = false;
          this.emit('blur');
        }
      }
    }, {
      key: "hasFocus",
      value: function hasFocus() {
        return this._hasFocus;
      }
    }, {
      key: "isCollapsed",
      value: function isCollapsed() {
        return this._anchorOffset === this._focusOffset;
      }
    }, {
      key: "isBackward",
      value: function isBackward() {
        return this._anchorOffset > this._focusOffset;
      }
    }, {
      key: "getAnchorOffset",
      value: function getAnchorOffset() {
        return this._hasFocus ? this._anchorOffset : null;
      }
    }, {
      key: "getFocusOffset",
      value: function getFocusOffset() {
        return this._hasFocus ? this._focusOffset : null;
      }
    }, {
      key: "getStartOffset",
      value: function getStartOffset() {
        return this._hasFocus ? Math.min(this._anchorOffset, this._focusOffset) : null;
      }
    }, {
      key: "getEndOffset",
      value: function getEndOffset() {
        return this._hasFocus ? Math.max(this._anchorOffset, this._focusOffset) : null;
      }
    }, {
      key: "overlaps",
      value: function overlaps(start, end) {
        return this.hasFocus() && this.getStartOffset() <= end && start <= this.getEndOffset();
      }
    }]);

    return DocumentSelectionState;
  }();

  mixInEventEmitter(DocumentSelectionState, {
    blur: true,
    focus: true,
    update: true
  });
  module.exports = DocumentSelectionState;
},397,[24,25,398],"node_modules/react-native/Libraries/vendor/document/selection/DocumentSelectionState.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");

  var EventEmitter = _$$_REQUIRE(_dependencyMap[1], "./EventEmitter");

  var EventEmitterWithHolding = _$$_REQUIRE(_dependencyMap[2], "./EventEmitterWithHolding");

  var EventHolder = _$$_REQUIRE(_dependencyMap[3], "./EventHolder");

  var invariant = _$$_REQUIRE(_dependencyMap[4], "invariant");

  var keyOf = _$$_REQUIRE(_dependencyMap[5], "fbjs/lib/keyOf");

  var TYPES_KEY = keyOf({
    __types: true
  });

  function mixInEventEmitter(cls, types) {
    invariant(types, 'Must supply set of valid event types');
    var target = cls.prototype || cls;
    invariant(!target.__eventEmitter, 'An active emitter is already mixed in');
    var ctor = cls.constructor;

    if (ctor) {
      invariant(ctor === Object || ctor === Function, 'Mix EventEmitter into a class, not an instance');
    }

    if (target.hasOwnProperty(TYPES_KEY)) {
      _extends(target.__types, types);
    } else if (target.__types) {
      target.__types = _extends({}, target.__types, types);
    } else {
      target.__types = types;
    }

    _extends(target, EventEmitterMixin);
  }

  var EventEmitterMixin = {
    emit: function emit(eventType, a, b, c, d, e, _) {
      return this.__getEventEmitter().emit(eventType, a, b, c, d, e, _);
    },
    emitAndHold: function emitAndHold(eventType, a, b, c, d, e, _) {
      return this.__getEventEmitter().emitAndHold(eventType, a, b, c, d, e, _);
    },
    addListener: function addListener(eventType, listener, context) {
      return this.__getEventEmitter().addListener(eventType, listener, context);
    },
    once: function once(eventType, listener, context) {
      return this.__getEventEmitter().once(eventType, listener, context);
    },
    addRetroactiveListener: function addRetroactiveListener(eventType, listener, context) {
      return this.__getEventEmitter().addRetroactiveListener(eventType, listener, context);
    },
    addListenerMap: function addListenerMap(listenerMap, context) {
      return this.__getEventEmitter().addListenerMap(listenerMap, context);
    },
    addRetroactiveListenerMap: function addRetroactiveListenerMap(listenerMap, context) {
      return this.__getEventEmitter().addListenerMap(listenerMap, context);
    },
    removeAllListeners: function removeAllListeners() {
      this.__getEventEmitter().removeAllListeners();
    },
    removeCurrentListener: function removeCurrentListener() {
      this.__getEventEmitter().removeCurrentListener();
    },
    releaseHeldEventType: function releaseHeldEventType(eventType) {
      this.__getEventEmitter().releaseHeldEventType(eventType);
    },
    __getEventEmitter: function __getEventEmitter() {
      if (!this.__eventEmitter) {
        var emitter = new EventEmitter();

        if (__DEV__) {
          var EventValidator = _$$_REQUIRE(_dependencyMap[6], "./EventValidator");

          emitter = EventValidator.addValidation(emitter, this.__types);
        }

        var holder = new EventHolder();
        this.__eventEmitter = new EventEmitterWithHolding(emitter, holder);
      }

      return this.__eventEmitter;
    }
  };
  module.exports = mixInEventEmitter;
},398,[13,39,399,400,3,401,402],"node_modules/react-native/Libraries/vendor/emitter/mixInEventEmitter.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");

  var EventEmitterWithHolding = function () {
    function EventEmitterWithHolding(emitter, holder) {
      _classCallCheck(this, EventEmitterWithHolding);

      this._emitter = emitter;
      this._eventHolder = holder;
      this._currentEventToken = null;
      this._emittingHeldEvents = false;
    }

    _createClass(EventEmitterWithHolding, [{
      key: "addListener",
      value: function addListener(eventType, listener, context) {
        return this._emitter.addListener(eventType, listener, context);
      }
    }, {
      key: "once",
      value: function once(eventType, listener, context) {
        return this._emitter.once(eventType, listener, context);
      }
    }, {
      key: "addRetroactiveListener",
      value: function addRetroactiveListener(eventType, listener, context) {
        var subscription = this._emitter.addListener(eventType, listener, context);

        this._emittingHeldEvents = true;

        this._eventHolder.emitToListener(eventType, listener, context);

        this._emittingHeldEvents = false;
        return subscription;
      }
    }, {
      key: "removeAllListeners",
      value: function removeAllListeners(eventType) {
        this._emitter.removeAllListeners(eventType);
      }
    }, {
      key: "removeCurrentListener",
      value: function removeCurrentListener() {
        this._emitter.removeCurrentListener();
      }
    }, {
      key: "listeners",
      value: function listeners(eventType) {
        return this._emitter.listeners(eventType);
      }
    }, {
      key: "emit",
      value: function emit(eventType) {
        var _this$_emitter;

        for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
          args[_key - 1] = arguments[_key];
        }

        (_this$_emitter = this._emitter).emit.apply(_this$_emitter, [eventType].concat(args));
      }
    }, {
      key: "emitAndHold",
      value: function emitAndHold(eventType) {
        var _this$_eventHolder, _this$_emitter2;

        for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
          args[_key2 - 1] = arguments[_key2];
        }

        this._currentEventToken = (_this$_eventHolder = this._eventHolder).holdEvent.apply(_this$_eventHolder, [eventType].concat(args));

        (_this$_emitter2 = this._emitter).emit.apply(_this$_emitter2, [eventType].concat(args));

        this._currentEventToken = null;
      }
    }, {
      key: "releaseCurrentEvent",
      value: function releaseCurrentEvent() {
        if (this._currentEventToken) {
          this._eventHolder.releaseEvent(this._currentEventToken);
        } else if (this._emittingHeldEvents) {
          this._eventHolder.releaseCurrentEvent();
        }
      }
    }, {
      key: "releaseHeldEventType",
      value: function releaseHeldEventType(eventType) {
        this._eventHolder.releaseEventType(eventType);
      }
    }]);

    return EventEmitterWithHolding;
  }();

  module.exports = EventEmitterWithHolding;
},399,[24,25],"node_modules/react-native/Libraries/vendor/emitter/EventEmitterWithHolding.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _classCallCheck = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/classCallCheck");

  var _createClass = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/createClass");

  var invariant = _$$_REQUIRE(_dependencyMap[2], "invariant");

  var EventHolder = function () {
    function EventHolder() {
      _classCallCheck(this, EventHolder);

      this._heldEvents = {};
      this._currentEventKey = null;
    }

    _createClass(EventHolder, [{
      key: "holdEvent",
      value: function holdEvent(eventType) {
        this._heldEvents[eventType] = this._heldEvents[eventType] || [];
        var eventsOfType = this._heldEvents[eventType];
        var key = {
          eventType: eventType,
          index: eventsOfType.length
        };

        for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
          args[_key - 1] = arguments[_key];
        }

        eventsOfType.push(args);
        return key;
      }
    }, {
      key: "emitToListener",
      value: function emitToListener(eventType, listener, context) {
        var _this = this;

        var eventsOfType = this._heldEvents[eventType];

        if (!eventsOfType) {
          return;
        }

        var origEventKey = this._currentEventKey;
        eventsOfType.forEach(function (eventHeld, index) {
          if (!eventHeld) {
            return;
          }

          _this._currentEventKey = {
            eventType: eventType,
            index: index
          };
          listener.apply(context, eventHeld);
        });
        this._currentEventKey = origEventKey;
      }
    }, {
      key: "releaseCurrentEvent",
      value: function releaseCurrentEvent() {
        invariant(this._currentEventKey !== null, 'Not in an emitting cycle; there is no current event');
        this._currentEventKey && this.releaseEvent(this._currentEventKey);
      }
    }, {
      key: "releaseEvent",
      value: function releaseEvent(token) {
        delete this._heldEvents[token.eventType][token.index];
      }
    }, {
      key: "releaseEventType",
      value: function releaseEventType(type) {
        this._heldEvents[type] = [];
      }
    }]);

    return EventHolder;
  }();

  module.exports = EventHolder;
},400,[24,25,3],"node_modules/react-native/Libraries/vendor/emitter/EventHolder.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  "use strict";

  var keyOf = function keyOf(oneKeyObj) {
    var key;

    for (key in oneKeyObj) {
      if (!oneKeyObj.hasOwnProperty(key)) {
        continue;
      }

      return key;
    }

    return null;
  };

  module.exports = keyOf;
},401,[],"node_modules/fbjs/lib/keyOf.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");

  var EventValidator = {
    addValidation: function addValidation(emitter, types) {
      var eventTypes = Object.keys(types);
      var emitterWithValidation = Object.create(emitter);

      _extends(emitterWithValidation, {
        emit: function emit(type, a, b, c, d, e, _) {
          assertAllowsEventType(type, eventTypes);
          return emitter.emit.call(this, type, a, b, c, d, e, _);
        }
      });

      return emitterWithValidation;
    }
  };

  function assertAllowsEventType(type, allowedTypes) {
    if (allowedTypes.indexOf(type) === -1) {
      throw new TypeError(errorMessageFor(type, allowedTypes));
    }
  }

  function errorMessageFor(type, allowedTypes) {
    var message = 'Unknown event type "' + type + '". ';

    if (__DEV__) {
      message += recommendationFor(type, allowedTypes);
    }

    message += 'Known event types: ' + allowedTypes.join(', ') + '.';
    return message;
  }

  if (__DEV__) {
    var recommendationFor = function recommendationFor(type, allowedTypes) {
      var closestTypeRecommendation = closestTypeFor(type, allowedTypes);

      if (isCloseEnough(closestTypeRecommendation, type)) {
        return 'Did you mean "' + closestTypeRecommendation.type + '"? ';
      } else {
        return '';
      }
    };

    var closestTypeFor = function closestTypeFor(type, allowedTypes) {
      var typeRecommendations = allowedTypes.map(typeRecommendationFor.bind(this, type));
      return typeRecommendations.sort(recommendationSort)[0];
    };

    var typeRecommendationFor = function typeRecommendationFor(type, recommendedType) {
      return {
        type: recommendedType,
        distance: damerauLevenshteinDistance(type, recommendedType)
      };
    };

    var recommendationSort = function recommendationSort(recommendationA, recommendationB) {
      if (recommendationA.distance < recommendationB.distance) {
        return -1;
      } else if (recommendationA.distance > recommendationB.distance) {
        return 1;
      } else {
        return 0;
      }
    };

    var isCloseEnough = function isCloseEnough(closestType, actualType) {
      return closestType.distance / actualType.length < 0.334;
    };

    var damerauLevenshteinDistance = function damerauLevenshteinDistance(a, b) {
      var i, j;
      var d = [];

      for (i = 0; i <= a.length; i++) {
        d[i] = [i];
      }

      for (j = 1; j <= b.length; j++) {
        d[0][j] = j;
      }

      for (i = 1; i <= a.length; i++) {
        for (j = 1; j <= b.length; j++) {
          var cost = a.charAt(i - 1) === b.charAt(j - 1) ? 0 : 1;
          d[i][j] = Math.min(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + cost);

          if (i > 1 && j > 1 && a.charAt(i - 1) === b.charAt(j - 2) && a.charAt(i - 2) === b.charAt(j - 1)) {
            d[i][j] = Math.min(d[i][j], d[i - 2][j - 2] + cost);
          }
        }
      }

      return d[a.length][b.length];
    };
  }

  module.exports = EventValidator;
},402,[13],"node_modules/react-native/Libraries/vendor/emitter/EventValidator.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _defineProperty2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/defineProperty"));

  var _objectWithoutProperties2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/objectWithoutProperties"));

  var _NativeActionSheetManager = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "./NativeActionSheetManager"));

  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

  var invariant = _$$_REQUIRE(_dependencyMap[4], "invariant");

  var processColor = _$$_REQUIRE(_dependencyMap[5], "../StyleSheet/processColor");

  var ActionSheetIOS = {
    showActionSheetWithOptions: function showActionSheetWithOptions(options, callback) {
      invariant(typeof options === 'object' && options !== null, 'Options must be a valid object');
      invariant(typeof callback === 'function', 'Must provide a valid callback');
      invariant(_NativeActionSheetManager.default, "ActionSheetManager does't exist");
      var tintColor = options.tintColor,
          remainingOptions = (0, _objectWithoutProperties2.default)(options, ["tintColor"]);

      _NativeActionSheetManager.default.showActionSheetWithOptions(_objectSpread({}, remainingOptions, {
        tintColor: processColor(tintColor)
      }), callback);
    },
    showShareActionSheetWithOptions: function showShareActionSheetWithOptions(options, failureCallback, successCallback) {
      invariant(typeof options === 'object' && options !== null, 'Options must be a valid object');
      invariant(typeof failureCallback === 'function', 'Must provide a valid failureCallback');
      invariant(typeof successCallback === 'function', 'Must provide a valid successCallback');
      invariant(_NativeActionSheetManager.default, "ActionSheetManager does't exist");

      _NativeActionSheetManager.default.showShareActionSheetWithOptions(_objectSpread({}, options, {
        tintColor: processColor(options.tintColor)
      }), failureCallback, successCallback);
    }
  };
  module.exports = ActionSheetIOS;
},403,[1,46,52,404,3,80],"node_modules/react-native/Libraries/ActionSheetIOS/ActionSheetIOS.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireWildcard");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[1], "../TurboModule/TurboModuleRegistry"));

  var _default = TurboModuleRegistry.get('ActionSheetManager');

  exports.default = _default;
},404,[9,11],"node_modules/react-native/Libraries/ActionSheetIOS/NativeActionSheetManager.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _defineProperty2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/defineProperty"));

  var _NativeHeadlessJsTaskSupport = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "./NativeHeadlessJsTaskSupport"));

  var _HeadlessJsTaskError = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "./HeadlessJsTaskError"));

  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

  var BatchedBridge = _$$_REQUIRE(_dependencyMap[4], "../BatchedBridge/BatchedBridge");

  var BugReporting = _$$_REQUIRE(_dependencyMap[5], "../BugReporting/BugReporting");

  var ReactNative = _$$_REQUIRE(_dependencyMap[6], "../Renderer/shims/ReactNative");

  var SceneTracker = _$$_REQUIRE(_dependencyMap[7], "../Utilities/SceneTracker");

  var infoLog = _$$_REQUIRE(_dependencyMap[8], "../Utilities/infoLog");

  var invariant = _$$_REQUIRE(_dependencyMap[9], "invariant");

  var renderApplication = _$$_REQUIRE(_dependencyMap[10], "./renderApplication");

  var createPerformanceLogger = _$$_REQUIRE(_dependencyMap[11], "../Utilities/createPerformanceLogger");

  var runnables = {};
  var runCount = 1;
  var sections = {};
  var taskProviders = new Map();
  var taskCancelProviders = new Map();

  var componentProviderInstrumentationHook = function componentProviderInstrumentationHook(component) {
    return component();
  };

  var wrapperComponentProvider;
  var showFabricIndicator = false;
  var AppRegistry = {
    setWrapperComponentProvider: function setWrapperComponentProvider(provider) {
      wrapperComponentProvider = provider;
    },
    enableFabricIndicator: function enableFabricIndicator(enabled) {
      showFabricIndicator = enabled;
    },
    registerConfig: function registerConfig(config) {
      config.forEach(function (appConfig) {
        if (appConfig.run) {
          AppRegistry.registerRunnable(appConfig.appKey, appConfig.run);
        } else {
          invariant(appConfig.component != null, 'AppRegistry.registerConfig(...): Every config is expected to set ' + 'either `run` or `component`, but `%s` has neither.', appConfig.appKey);
          AppRegistry.registerComponent(appConfig.appKey, appConfig.component, appConfig.section);
        }
      });
    },
    registerComponent: function registerComponent(appKey, componentProvider, section) {
      var scopedPerformanceLogger = createPerformanceLogger();
      runnables[appKey] = {
        componentProvider: componentProvider,
        run: function run(appParameters) {
          renderApplication(componentProviderInstrumentationHook(componentProvider, scopedPerformanceLogger), appParameters.initialProps, appParameters.rootTag, wrapperComponentProvider && wrapperComponentProvider(appParameters), appParameters.fabric, showFabricIndicator, scopedPerformanceLogger);
        }
      };

      if (section) {
        sections[appKey] = runnables[appKey];
      }

      return appKey;
    },
    registerRunnable: function registerRunnable(appKey, run) {
      runnables[appKey] = {
        run: run
      };
      return appKey;
    },
    registerSection: function registerSection(appKey, component) {
      AppRegistry.registerComponent(appKey, component, true);
    },
    getAppKeys: function getAppKeys() {
      return Object.keys(runnables);
    },
    getSectionKeys: function getSectionKeys() {
      return Object.keys(sections);
    },
    getSections: function getSections() {
      return _objectSpread({}, sections);
    },
    getRunnable: function getRunnable(appKey) {
      return runnables[appKey];
    },
    getRegistry: function getRegistry() {
      return {
        sections: AppRegistry.getSectionKeys(),
        runnables: _objectSpread({}, runnables)
      };
    },
    setComponentProviderInstrumentationHook: function setComponentProviderInstrumentationHook(hook) {
      componentProviderInstrumentationHook = hook;
    },
    runApplication: function runApplication(appKey, appParameters) {
      var msg = 'Running "' + appKey + '" with ' + JSON.stringify(appParameters);
      infoLog(msg);
      BugReporting.addSource('AppRegistry.runApplication' + runCount++, function () {
        return msg;
      });
      invariant(runnables[appKey] && runnables[appKey].run, "\"" + appKey + "\" has not been registered. This can happen if:\n" + '* Metro (the local dev server) is run from the wrong folder. ' + 'Check if Metro is running, stop it and restart it in the current project.\n' + "* A module failed to load due to an error and `AppRegistry.registerComponent` wasn't called.");
      SceneTracker.setActiveScene({
        name: appKey
      });
      runnables[appKey].run(appParameters);
    },
    unmountApplicationComponentAtRootTag: function unmountApplicationComponentAtRootTag(rootTag) {
      ReactNative.unmountComponentAtNodeAndRemoveContainer(rootTag);
    },
    registerHeadlessTask: function registerHeadlessTask(taskKey, taskProvider) {
      this.registerCancellableHeadlessTask(taskKey, taskProvider, function () {
        return function () {};
      });
    },
    registerCancellableHeadlessTask: function registerCancellableHeadlessTask(taskKey, taskProvider, taskCancelProvider) {
      if (taskProviders.has(taskKey)) {
        console.warn("registerHeadlessTask or registerCancellableHeadlessTask called multiple times for same key '" + taskKey + "'");
      }

      taskProviders.set(taskKey, taskProvider);
      taskCancelProviders.set(taskKey, taskCancelProvider);
    },
    startHeadlessTask: function startHeadlessTask(taskId, taskKey, data) {
      var taskProvider = taskProviders.get(taskKey);

      if (!taskProvider) {
        console.warn("No task registered for key " + taskKey);

        if (_NativeHeadlessJsTaskSupport.default) {
          _NativeHeadlessJsTaskSupport.default.notifyTaskFinished(taskId);
        }

        return;
      }

      taskProvider()(data).then(function () {
        if (_NativeHeadlessJsTaskSupport.default) {
          _NativeHeadlessJsTaskSupport.default.notifyTaskFinished(taskId);
        }
      }).catch(function (reason) {
        console.error(reason);

        if (_NativeHeadlessJsTaskSupport.default && reason instanceof _HeadlessJsTaskError.default) {
          _NativeHeadlessJsTaskSupport.default.notifyTaskRetry(taskId).then(function (retryPosted) {
            if (!retryPosted) {
              _NativeHeadlessJsTaskSupport.default.notifyTaskFinished(taskId);
            }
          });
        }
      });
    },
    cancelHeadlessTask: function cancelHeadlessTask(taskId, taskKey) {
      var taskCancelProvider = taskCancelProviders.get(taskKey);

      if (!taskCancelProvider) {
        throw new Error("No task canceller registered for key '" + taskKey + "'");
      }

      taskCancelProvider()();
    }
  };
  BatchedBridge.registerCallableModule('AppRegistry', AppRegistry);
  module.exports = AppRegistry;
},405,[1,46,406,407,18,408,88,411,161,3,412,160],"node_modules/react-native/Libraries/ReactNative/AppRegistry.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireWildcard");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[1], "../TurboModule/TurboModuleRegistry"));

  var _default = TurboModuleRegistry.get('HeadlessJsTaskSupport');

  exports.default = _default;
},406,[9,11],"node_modules/react-native/Libraries/ReactNative/NativeHeadlessJsTaskSupport.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/inherits"));

  var _wrapNativeSuper2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/wrapNativeSuper"));

  var HeadlessJsTaskError = function (_Error) {
    (0, _inherits2.default)(HeadlessJsTaskError, _Error);

    function HeadlessJsTaskError() {
      (0, _classCallCheck2.default)(this, HeadlessJsTaskError);
      return (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(HeadlessJsTaskError).apply(this, arguments));
    }

    return HeadlessJsTaskError;
  }((0, _wrapNativeSuper2.default)(Error));

  exports.default = HeadlessJsTaskError;
},407,[1,24,32,34,37,96],"node_modules/react-native/Libraries/ReactNative/HeadlessJsTaskError.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _slicedToArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/slicedToArray"));

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass"));

  var _NativeBugReporting = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "./NativeBugReporting"));

  var _NativeRedBox = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "../NativeModules/specs/NativeRedBox"));

  var RCTDeviceEventEmitter = _$$_REQUIRE(_dependencyMap[6], "../EventEmitter/RCTDeviceEventEmitter");

  var infoLog = _$$_REQUIRE(_dependencyMap[7], "../Utilities/infoLog");

  function defaultExtras() {
    BugReporting.addFileSource('react_hierarchy.txt', function () {
      return _$$_REQUIRE(_dependencyMap[8], "./dumpReactTree")();
    });
  }

  var BugReporting = function () {
    function BugReporting() {
      (0, _classCallCheck2.default)(this, BugReporting);
    }

    (0, _createClass2.default)(BugReporting, null, [{
      key: "_maybeInit",
      value: function _maybeInit() {
        if (!BugReporting._subscription) {
          BugReporting._subscription = RCTDeviceEventEmitter.addListener('collectBugExtraData', BugReporting.collectExtraData, null);
          defaultExtras();
        }

        if (!BugReporting._redboxSubscription) {
          BugReporting._redboxSubscription = RCTDeviceEventEmitter.addListener('collectRedBoxExtraData', BugReporting.collectExtraData, null);
        }
      }
    }, {
      key: "addSource",
      value: function addSource(key, callback) {
        return this._addSource(key, callback, BugReporting._extraSources);
      }
    }, {
      key: "addFileSource",
      value: function addFileSource(key, callback) {
        return this._addSource(key, callback, BugReporting._fileSources);
      }
    }, {
      key: "_addSource",
      value: function _addSource(key, callback, source) {
        BugReporting._maybeInit();

        if (source.has(key)) {
          console.warn("BugReporting.add* called multiple times for same key '" + key + "'");
        }

        source.set(key, callback);
        return {
          remove: function remove() {
            source.delete(key);
          }
        };
      }
    }, {
      key: "collectExtraData",
      value: function collectExtraData() {
        var extraData = {};

        for (var _iterator = BugReporting._extraSources, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"]();;) {
          var _ref3;

          if (_isArray) {
            if (_i >= _iterator.length) break;
            _ref3 = _iterator[_i++];
          } else {
            _i = _iterator.next();
            if (_i.done) break;
            _ref3 = _i.value;
          }

          var _ref7 = _ref3;

          var _ref2 = (0, _slicedToArray2.default)(_ref7, 2);

          var _key3 = _ref2[0];
          var _callback2 = _ref2[1];
          extraData[_key3] = _callback2();
        }

        var fileData = {};

        for (var _iterator2 = BugReporting._fileSources, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"]();;) {
          var _ref6;

          if (_isArray2) {
            if (_i2 >= _iterator2.length) break;
            _ref6 = _iterator2[_i2++];
          } else {
            _i2 = _iterator2.next();
            if (_i2.done) break;
            _ref6 = _i2.value;
          }

          var _ref8 = _ref6;

          var _ref5 = (0, _slicedToArray2.default)(_ref8, 2);

          var _key4 = _ref5[0];
          var _callback3 = _ref5[1];
          fileData[_key4] = _callback3();
        }

        infoLog('BugReporting extraData:', extraData);

        if (_NativeBugReporting.default != null && _NativeBugReporting.default.setExtraData != null) {
          _NativeBugReporting.default.setExtraData(extraData, fileData);
        }

        if (_NativeRedBox.default != null && _NativeRedBox.default.setExtraData != null) {
          _NativeRedBox.default.setExtraData(extraData, 'From BugReporting.js');
        }

        return {
          extras: extraData,
          files: fileData
        };
      }
    }]);
    return BugReporting;
  }();

  BugReporting._extraSources = new Map();
  BugReporting._fileSources = new Map();
  BugReporting._subscription = null;
  BugReporting._redboxSubscription = null;
  module.exports = BugReporting;
},408,[1,14,24,25,409,165,31,161,410],"node_modules/react-native/Libraries/BugReporting/BugReporting.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireWildcard");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[1], "../TurboModule/TurboModuleRegistry"));

  var _default = TurboModuleRegistry.get('BugReporting');

  exports.default = _default;
},409,[9,11],"node_modules/react-native/Libraries/BugReporting/NativeBugReporting.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  function dumpReactTree() {
    try {
      return getReactTree();
    } catch (e) {
      return 'Failed to dump react tree: ' + e;
    }
  }

  function getReactTree() {
    return 'React tree dumps have been temporarily disabled while React is ' + 'upgraded to Fiber.';
  }

  module.exports = dumpReactTree;
},410,[],"node_modules/react-native/Libraries/BugReporting/dumpReactTree.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _listeners = [];
  var _activeScene = {
    name: 'default'
  };
  var SceneTracker = {
    setActiveScene: function setActiveScene(scene) {
      _activeScene = scene;

      _listeners.forEach(function (listener) {
        return listener(_activeScene);
      });
    },
    getActiveScene: function getActiveScene() {
      return _activeScene;
    },
    addActiveSceneChangedListener: function addActiveSceneChangedListener(callback) {
      _listeners.push(callback);

      return {
        remove: function remove() {
          _listeners = _listeners.filter(function (listener) {
            return callback !== listener;
          });
        }
      };
    }
  };
  module.exports = SceneTracker;
},411,[],"node_modules/react-native/Libraries/Utilities/SceneTracker.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _extends2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/extends"));

  var _GlobalPerformanceLogger = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../Utilities/GlobalPerformanceLogger"));

  var _PerformanceLoggerContext = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../Utilities/PerformanceLoggerContext"));

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native/Libraries/ReactNative/renderApplication.js";

  var AppContainer = _$$_REQUIRE(_dependencyMap[4], "./AppContainer");

  var React = _$$_REQUIRE(_dependencyMap[5], "react");

  var ReactFabricIndicator = _$$_REQUIRE(_dependencyMap[6], "./ReactFabricIndicator");

  var invariant = _$$_REQUIRE(_dependencyMap[7], "invariant");

  _$$_REQUIRE(_dependencyMap[8], "../Utilities/BackHandler");

  function renderApplication(RootComponent, initialProps, rootTag, WrapperComponent, fabric, showFabricIndicator, scopedPerformanceLogger) {
    invariant(rootTag, 'Expect to have a valid rootTag, instead got ', rootTag);
    var renderable = React.createElement(_PerformanceLoggerContext.default.Provider, {
      value: scopedPerformanceLogger != null ? scopedPerformanceLogger : _GlobalPerformanceLogger.default,
      __source: {
        fileName: _jsxFileName,
        lineNumber: 37
      }
    }, React.createElement(AppContainer, {
      rootTag: rootTag,
      WrapperComponent: WrapperComponent,
      __source: {
        fileName: _jsxFileName,
        lineNumber: 39
      }
    }, React.createElement(RootComponent, (0, _extends2.default)({}, initialProps, {
      rootTag: rootTag,
      __source: {
        fileName: _jsxFileName,
        lineNumber: 40
      }
    })), fabric === true && showFabricIndicator === true ? React.createElement(ReactFabricIndicator, {
      __source: {
        fileName: _jsxFileName,
        lineNumber: 42
      }
    }) : null));

    _GlobalPerformanceLogger.default.startTimespan('renderApplication_React_render');

    if (fabric) {
      _$$_REQUIRE(_dependencyMap[9], "../Renderer/shims/ReactFabric").render(renderable, rootTag);
    } else {
      _$$_REQUIRE(_dependencyMap[10], "../Renderer/shims/ReactNative").render(renderable, rootTag);
    }

    _GlobalPerformanceLogger.default.stopTimespan('renderApplication_React_render');
  }

  module.exports = renderApplication;
},412,[1,13,159,413,344,54,414,3,415,417,88],"node_modules/react-native/Libraries/ReactNative/renderApplication.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/interopRequireWildcard");

  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[2], "react"));

  var _GlobalPerformanceLogger = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "./GlobalPerformanceLogger"));

  var PerformanceLoggerContext = React.createContext(_GlobalPerformanceLogger.default);
  module.exports = PerformanceLoggerContext;
},413,[1,9,54,159],"node_modules/react-native/Libraries/Utilities/PerformanceLoggerContext.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native/Libraries/ReactNative/ReactFabricIndicator.js";

  var React = _$$_REQUIRE(_dependencyMap[0], "react");

  var StyleSheet = _$$_REQUIRE(_dependencyMap[1], "../StyleSheet/StyleSheet");

  var Text = _$$_REQUIRE(_dependencyMap[2], "../Text/Text");

  var View = _$$_REQUIRE(_dependencyMap[3], "../Components/View/View");

  function ReactFabricIndicator() {
    return React.createElement(View, {
      style: styles.container,
      __source: {
        fileName: _jsxFileName,
        lineNumber: 20
      }
    }, React.createElement(Text, {
      style: styles.text,
      __source: {
        fileName: _jsxFileName,
        lineNumber: 21
      }
    }, "FABRIC"));
  }

  var styles = StyleSheet.create({
    container: {
      alignItems: 'center',
      justifyContent: 'center',
      backgroundColor: 'rgba(0,0,0, 0.25)',
      position: 'absolute',
      top: 0,
      right: 0,
      padding: 2
    },
    text: {
      fontSize: 6,
      color: '#ffffff'
    }
  });
  module.exports = ReactFabricIndicator;
},414,[54,60,235,86],"node_modules/react-native/Libraries/ReactNative/ReactFabricIndicator.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _NativeDeviceEventManager = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../../Libraries/NativeModules/specs/NativeDeviceEventManager"));

  var _RCTDeviceEventEmitter = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../EventEmitter/RCTDeviceEventEmitter"));

  var DEVICE_BACK_EVENT = 'hardwareBackPress';
  var _backPressSubscriptions = [];

  _RCTDeviceEventEmitter.default.addListener(DEVICE_BACK_EVENT, function () {
    for (var i = _backPressSubscriptions.length - 1; i >= 0; i--) {
      if (_backPressSubscriptions[i]()) {
        return;
      }
    }

    BackHandler.exitApp();
  });

  var BackHandler = {
    exitApp: function exitApp() {
      if (!_NativeDeviceEventManager.default) {
        return;
      }

      _NativeDeviceEventManager.default.invokeDefaultBackPressHandler();
    },
    addEventListener: function addEventListener(eventName, handler) {
      if (_backPressSubscriptions.indexOf(handler) === -1) {
        _backPressSubscriptions.push(handler);
      }

      return {
        remove: function remove() {
          return BackHandler.removeEventListener(eventName, handler);
        }
      };
    },
    removeEventListener: function removeEventListener(eventName, handler) {
      if (_backPressSubscriptions.indexOf(handler) !== -1) {
        _backPressSubscriptions.splice(_backPressSubscriptions.indexOf(handler), 1);
      }
    }
  };
  module.exports = BackHandler;
},415,[1,416,31],"node_modules/react-native/Libraries/Utilities/BackHandler.android.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireWildcard");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[1], "../../TurboModule/TurboModuleRegistry"));

  var _default = TurboModuleRegistry.get('DeviceEventManager');

  exports.default = _default;
},416,[9,11],"node_modules/react-native/Libraries/NativeModules/specs/NativeDeviceEventManager.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _ReactNativePrivateInterface = _$$_REQUIRE(_dependencyMap[0], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface");

  var ReactFabric;

  if (__DEV__) {
    ReactFabric = _$$_REQUIRE(_dependencyMap[1], "../implementations/ReactFabric-dev");
  } else {
    ReactFabric = _$$_REQUIRE(_dependencyMap[2], "../implementations/ReactFabric-prod");
  }

  _ReactNativePrivateInterface.BatchedBridge.registerCallableModule('ReactFabric', ReactFabric);

  module.exports = ReactFabric;
},417,[192,418,419],"node_modules/react-native/Libraries/Renderer/shims/ReactFabric.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");

  if (__DEV__) {
    (function () {
      "use strict";

      _$$_REQUIRE(_dependencyMap[1], "react-native/Libraries/ReactPrivate/ReactNativePrivateInitializeCore");

      var ReactNativePrivateInterface = _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface");

      var React = _$$_REQUIRE(_dependencyMap[3], "react");

      var Scheduler = _$$_REQUIRE(_dependencyMap[4], "scheduler");

      var checkPropTypes = _$$_REQUIRE(_dependencyMap[5], "prop-types/checkPropTypes");

      var tracing = _$$_REQUIRE(_dependencyMap[6], "scheduler/tracing");

      function ReactError(error) {
        error.name = "Invariant Violation";
        return error;
      }

      var eventPluginOrder = null;
      var namesToPlugins = {};

      function recomputePluginOrdering() {
        if (!eventPluginOrder) {
          return;
        }

        for (var pluginName in namesToPlugins) {
          var pluginModule = namesToPlugins[pluginName];
          var pluginIndex = eventPluginOrder.indexOf(pluginName);

          (function () {
            if (!(pluginIndex > -1)) {
              throw ReactError(Error("EventPluginRegistry: Cannot inject event plugins that do not exist in the plugin ordering, `" + pluginName + "`."));
            }
          })();

          if (plugins[pluginIndex]) {
            continue;
          }

          (function () {
            if (!pluginModule.extractEvents) {
              throw ReactError(Error("EventPluginRegistry: Event plugins must implement an `extractEvents` method, but `" + pluginName + "` does not."));
            }
          })();

          plugins[pluginIndex] = pluginModule;
          var publishedEvents = pluginModule.eventTypes;

          for (var eventName in publishedEvents) {
            (function () {
              if (!publishEventForPlugin(publishedEvents[eventName], pluginModule, eventName)) {
                throw ReactError(Error("EventPluginRegistry: Failed to publish event `" + eventName + "` for plugin `" + pluginName + "`."));
              }
            })();
          }
        }
      }

      function publishEventForPlugin(dispatchConfig, pluginModule, eventName) {
        (function () {
          if (!!eventNameDispatchConfigs.hasOwnProperty(eventName)) {
            throw ReactError(Error("EventPluginHub: More than one plugin attempted to publish the same event name, `" + eventName + "`."));
          }
        })();

        eventNameDispatchConfigs[eventName] = dispatchConfig;
        var phasedRegistrationNames = dispatchConfig.phasedRegistrationNames;

        if (phasedRegistrationNames) {
          for (var phaseName in phasedRegistrationNames) {
            if (phasedRegistrationNames.hasOwnProperty(phaseName)) {
              var phasedRegistrationName = phasedRegistrationNames[phaseName];
              publishRegistrationName(phasedRegistrationName, pluginModule, eventName);
            }
          }

          return true;
        } else if (dispatchConfig.registrationName) {
          publishRegistrationName(dispatchConfig.registrationName, pluginModule, eventName);
          return true;
        }

        return false;
      }

      function publishRegistrationName(registrationName, pluginModule, eventName) {
        (function () {
          if (!!registrationNameModules[registrationName]) {
            throw ReactError(Error("EventPluginHub: More than one plugin attempted to publish the same registration name, `" + registrationName + "`."));
          }
        })();

        registrationNameModules[registrationName] = pluginModule;
        registrationNameDependencies[registrationName] = pluginModule.eventTypes[eventName].dependencies;
        {
          var lowerCasedName = registrationName.toLowerCase();
        }
      }

      var plugins = [];
      var eventNameDispatchConfigs = {};
      var registrationNameModules = {};
      var registrationNameDependencies = {};

      function injectEventPluginOrder(injectedEventPluginOrder) {
        (function () {
          if (!!eventPluginOrder) {
            throw ReactError(Error("EventPluginRegistry: Cannot inject event plugin ordering more than once. You are likely trying to load more than one copy of React."));
          }
        })();

        eventPluginOrder = Array.prototype.slice.call(injectedEventPluginOrder);
        recomputePluginOrdering();
      }

      function injectEventPluginsByName(injectedNamesToPlugins) {
        var isOrderingDirty = false;

        for (var pluginName in injectedNamesToPlugins) {
          if (!injectedNamesToPlugins.hasOwnProperty(pluginName)) {
            continue;
          }

          var pluginModule = injectedNamesToPlugins[pluginName];

          if (!namesToPlugins.hasOwnProperty(pluginName) || namesToPlugins[pluginName] !== pluginModule) {
            (function () {
              if (!!namesToPlugins[pluginName]) {
                throw ReactError(Error("EventPluginRegistry: Cannot inject two different event plugins using the same name, `" + pluginName + "`."));
              }
            })();

            namesToPlugins[pluginName] = pluginModule;
            isOrderingDirty = true;
          }
        }

        if (isOrderingDirty) {
          recomputePluginOrdering();
        }
      }

      var invokeGuardedCallbackImpl = function invokeGuardedCallbackImpl(name, func, context, a, b, c, d, e, f) {
        var funcArgs = Array.prototype.slice.call(arguments, 3);

        try {
          func.apply(context, funcArgs);
        } catch (error) {
          this.onError(error);
        }
      };

      {
        if (typeof window !== "undefined" && typeof window.dispatchEvent === "function" && typeof document !== "undefined" && typeof document.createEvent === "function") {
          var fakeNode = document.createElement("react");

          var invokeGuardedCallbackDev = function invokeGuardedCallbackDev(name, func, context, a, b, c, d, e, f) {
            (function () {
              if (!(typeof document !== "undefined")) {
                throw ReactError(Error("The `document` global was defined when React was initialized, but is not defined anymore. This can happen in a test environment if a component schedules an update from an asynchronous callback, but the test has already finished running. To solve this, you can either unmount the component at the end of your test (and ensure that any asynchronous operations get canceled in `componentWillUnmount`), or you can change the test itself to be asynchronous."));
              }
            })();

            var evt = document.createEvent("Event");
            var didError = true;
            var windowEvent = window.event;
            var windowEventDescriptor = Object.getOwnPropertyDescriptor(window, "event");
            var funcArgs = Array.prototype.slice.call(arguments, 3);

            function callCallback() {
              fakeNode.removeEventListener(evtType, callCallback, false);

              if (typeof window.event !== "undefined" && window.hasOwnProperty("event")) {
                window.event = windowEvent;
              }

              func.apply(context, funcArgs);
              didError = false;
            }

            var error = void 0;
            var didSetError = false;
            var isCrossOriginError = false;

            function handleWindowError(event) {
              error = event.error;
              didSetError = true;

              if (error === null && event.colno === 0 && event.lineno === 0) {
                isCrossOriginError = true;
              }

              if (event.defaultPrevented) {
                if (error != null && typeof error === "object") {
                  try {
                    error._suppressLogging = true;
                  } catch (inner) {}
                }
              }
            }

            var evtType = "react-" + (name ? name : "invokeguardedcallback");
            window.addEventListener("error", handleWindowError);
            fakeNode.addEventListener(evtType, callCallback, false);
            evt.initEvent(evtType, false, false);
            fakeNode.dispatchEvent(evt);

            if (windowEventDescriptor) {
              Object.defineProperty(window, "event", windowEventDescriptor);
            }

            if (didError) {
              if (!didSetError) {
                error = new Error("An error was thrown inside one of your components, but React " + "doesn't know what it was. This is likely due to browser " + 'flakiness. React does its best to preserve the "Pause on ' + 'exceptions" behavior of the DevTools, which requires some ' + "DEV-mode only tricks. It's possible that these don't work in " + "your browser. Try triggering the error in production mode, " + "or switching to a modern browser. If you suspect that this is " + "actually an issue with React, please file an issue.");
              } else if (isCrossOriginError) {
                error = new Error("A cross-origin error was thrown. React doesn't have access to " + "the actual error object in development. " + "See https://fb.me/react-crossorigin-error for more information.");
              }

              this.onError(error);
            }

            window.removeEventListener("error", handleWindowError);
          };

          invokeGuardedCallbackImpl = invokeGuardedCallbackDev;
        }
      }
      var invokeGuardedCallbackImpl$1 = invokeGuardedCallbackImpl;
      var hasError = false;
      var caughtError = null;
      var hasRethrowError = false;
      var rethrowError = null;
      var reporter = {
        onError: function onError(error) {
          hasError = true;
          caughtError = error;
        }
      };

      function invokeGuardedCallback(name, func, context, a, b, c, d, e, f) {
        hasError = false;
        caughtError = null;
        invokeGuardedCallbackImpl$1.apply(reporter, arguments);
      }

      function invokeGuardedCallbackAndCatchFirstError(name, func, context, a, b, c, d, e, f) {
        invokeGuardedCallback.apply(this, arguments);

        if (hasError) {
          var error = clearCaughtError();

          if (!hasRethrowError) {
            hasRethrowError = true;
            rethrowError = error;
          }
        }
      }

      function rethrowCaughtError() {
        if (hasRethrowError) {
          var error = rethrowError;
          hasRethrowError = false;
          rethrowError = null;
          throw error;
        }
      }

      function hasCaughtError() {
        return hasError;
      }

      function clearCaughtError() {
        if (hasError) {
          var error = caughtError;
          hasError = false;
          caughtError = null;
          return error;
        } else {
          (function () {
            {
              throw ReactError(Error("clearCaughtError was called but no error was captured. This error is likely caused by a bug in React. Please file an issue."));
            }
          })();
        }
      }

      var warningWithoutStack = function warningWithoutStack() {};

      {
        warningWithoutStack = function warningWithoutStack(condition, format) {
          for (var _len = arguments.length, args = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
            args[_key - 2] = arguments[_key];
          }

          if (format === undefined) {
            throw new Error("`warningWithoutStack(condition, format, ...args)` requires a warning " + "message argument");
          }

          if (args.length > 8) {
            throw new Error("warningWithoutStack() currently supports at most 8 arguments.");
          }

          if (condition) {
            return;
          }

          if (typeof console !== "undefined") {
            var argsWithFormat = args.map(function (item) {
              return "" + item;
            });
            argsWithFormat.unshift("Warning: " + format);
            Function.prototype.apply.call(console.error, console, argsWithFormat);
          }

          try {
            var argIndex = 0;
            var message = "Warning: " + format.replace(/%s/g, function () {
              return args[argIndex++];
            });
            throw new Error(message);
          } catch (x) {}
        };
      }
      var warningWithoutStack$1 = warningWithoutStack;
      var getFiberCurrentPropsFromNode = null;
      var getInstanceFromNode = null;
      var getNodeFromInstance = null;

      function setComponentTree(getFiberCurrentPropsFromNodeImpl, getInstanceFromNodeImpl, getNodeFromInstanceImpl) {
        getFiberCurrentPropsFromNode = getFiberCurrentPropsFromNodeImpl;
        getInstanceFromNode = getInstanceFromNodeImpl;
        getNodeFromInstance = getNodeFromInstanceImpl;
        {
          !(getNodeFromInstance && getInstanceFromNode) ? warningWithoutStack$1(false, "EventPluginUtils.setComponentTree(...): Injected " + "module is missing getNodeFromInstance or getInstanceFromNode.") : void 0;
        }
      }

      var validateEventDispatches = void 0;
      {
        validateEventDispatches = function validateEventDispatches(event) {
          var dispatchListeners = event._dispatchListeners;
          var dispatchInstances = event._dispatchInstances;
          var listenersIsArr = Array.isArray(dispatchListeners);
          var listenersLen = listenersIsArr ? dispatchListeners.length : dispatchListeners ? 1 : 0;
          var instancesIsArr = Array.isArray(dispatchInstances);
          var instancesLen = instancesIsArr ? dispatchInstances.length : dispatchInstances ? 1 : 0;
          !(instancesIsArr === listenersIsArr && instancesLen === listenersLen) ? warningWithoutStack$1(false, "EventPluginUtils: Invalid `event`.") : void 0;
        };
      }

      function executeDispatch(event, listener, inst) {
        var type = event.type || "unknown-event";
        event.currentTarget = getNodeFromInstance(inst);
        invokeGuardedCallbackAndCatchFirstError(type, listener, undefined, event);
        event.currentTarget = null;
      }

      function executeDispatchesInOrder(event) {
        var dispatchListeners = event._dispatchListeners;
        var dispatchInstances = event._dispatchInstances;
        {
          validateEventDispatches(event);
        }

        if (Array.isArray(dispatchListeners)) {
          for (var i = 0; i < dispatchListeners.length; i++) {
            if (event.isPropagationStopped()) {
              break;
            }

            executeDispatch(event, dispatchListeners[i], dispatchInstances[i]);
          }
        } else if (dispatchListeners) {
          executeDispatch(event, dispatchListeners, dispatchInstances);
        }

        event._dispatchListeners = null;
        event._dispatchInstances = null;
      }

      function executeDispatchesInOrderStopAtTrueImpl(event) {
        var dispatchListeners = event._dispatchListeners;
        var dispatchInstances = event._dispatchInstances;
        {
          validateEventDispatches(event);
        }

        if (Array.isArray(dispatchListeners)) {
          for (var i = 0; i < dispatchListeners.length; i++) {
            if (event.isPropagationStopped()) {
              break;
            }

            if (dispatchListeners[i](event, dispatchInstances[i])) {
              return dispatchInstances[i];
            }
          }
        } else if (dispatchListeners) {
          if (dispatchListeners(event, dispatchInstances)) {
            return dispatchInstances;
          }
        }

        return null;
      }

      function executeDispatchesInOrderStopAtTrue(event) {
        var ret = executeDispatchesInOrderStopAtTrueImpl(event);
        event._dispatchInstances = null;
        event._dispatchListeners = null;
        return ret;
      }

      function executeDirectDispatch(event) {
        {
          validateEventDispatches(event);
        }
        var dispatchListener = event._dispatchListeners;
        var dispatchInstance = event._dispatchInstances;

        (function () {
          if (!!Array.isArray(dispatchListener)) {
            throw ReactError(Error("executeDirectDispatch(...): Invalid `event`."));
          }
        })();

        event.currentTarget = dispatchListener ? getNodeFromInstance(dispatchInstance) : null;
        var res = dispatchListener ? dispatchListener(event) : null;
        event.currentTarget = null;
        event._dispatchListeners = null;
        event._dispatchInstances = null;
        return res;
      }

      function hasDispatches(event) {
        return !!event._dispatchListeners;
      }

      function accumulateInto(current, next) {
        (function () {
          if (!(next != null)) {
            throw ReactError(Error("accumulateInto(...): Accumulated items must not be null or undefined."));
          }
        })();

        if (current == null) {
          return next;
        }

        if (Array.isArray(current)) {
          if (Array.isArray(next)) {
            current.push.apply(current, next);
            return current;
          }

          current.push(next);
          return current;
        }

        if (Array.isArray(next)) {
          return [current].concat(next);
        }

        return [current, next];
      }

      function forEachAccumulated(arr, cb, scope) {
        if (Array.isArray(arr)) {
          arr.forEach(cb, scope);
        } else if (arr) {
          cb.call(scope, arr);
        }
      }

      var eventQueue = null;

      var executeDispatchesAndRelease = function executeDispatchesAndRelease(event) {
        if (event) {
          executeDispatchesInOrder(event);

          if (!event.isPersistent()) {
            event.constructor.release(event);
          }
        }
      };

      var executeDispatchesAndReleaseTopLevel = function executeDispatchesAndReleaseTopLevel(e) {
        return executeDispatchesAndRelease(e);
      };

      function runEventsInBatch(events) {
        if (events !== null) {
          eventQueue = accumulateInto(eventQueue, events);
        }

        var processingEventQueue = eventQueue;
        eventQueue = null;

        if (!processingEventQueue) {
          return;
        }

        forEachAccumulated(processingEventQueue, executeDispatchesAndReleaseTopLevel);

        (function () {
          if (!!eventQueue) {
            throw ReactError(Error("processEventQueue(): Additional events were enqueued while processing an event queue. Support for this has not yet been implemented."));
          }
        })();

        rethrowCaughtError();
      }

      function isInteractive(tag) {
        return tag === "button" || tag === "input" || tag === "select" || tag === "textarea";
      }

      function shouldPreventMouseEvent(name, type, props) {
        switch (name) {
          case "onClick":
          case "onClickCapture":
          case "onDoubleClick":
          case "onDoubleClickCapture":
          case "onMouseDown":
          case "onMouseDownCapture":
          case "onMouseMove":
          case "onMouseMoveCapture":
          case "onMouseUp":
          case "onMouseUpCapture":
            return !!(props.disabled && isInteractive(type));

          default:
            return false;
        }
      }

      var injection = {
        injectEventPluginOrder: injectEventPluginOrder,
        injectEventPluginsByName: injectEventPluginsByName
      };

      function getListener(inst, registrationName) {
        var listener = void 0;
        var stateNode = inst.stateNode;

        if (!stateNode) {
          return null;
        }

        var props = getFiberCurrentPropsFromNode(stateNode);

        if (!props) {
          return null;
        }

        listener = props[registrationName];

        if (shouldPreventMouseEvent(registrationName, inst.type, props)) {
          return null;
        }

        (function () {
          if (!(!listener || typeof listener === "function")) {
            throw ReactError(Error("Expected `" + registrationName + "` listener to be a function, instead got a value of `" + typeof listener + "` type."));
          }
        })();

        return listener;
      }

      function extractPluginEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
        var events = null;

        for (var i = 0; i < plugins.length; i++) {
          var possiblePlugin = plugins[i];

          if (possiblePlugin) {
            var extractedEvents = possiblePlugin.extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget);

            if (extractedEvents) {
              events = accumulateInto(events, extractedEvents);
            }
          }
        }

        return events;
      }

      function runExtractedPluginEventsInBatch(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
        var events = extractPluginEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget);
        runEventsInBatch(events);
      }

      var FunctionComponent = 0;
      var ClassComponent = 1;
      var IndeterminateComponent = 2;
      var HostRoot = 3;
      var HostPortal = 4;
      var HostComponent = 5;
      var HostText = 6;
      var Fragment = 7;
      var Mode = 8;
      var ContextConsumer = 9;
      var ContextProvider = 10;
      var ForwardRef = 11;
      var Profiler = 12;
      var SuspenseComponent = 13;
      var MemoComponent = 14;
      var SimpleMemoComponent = 15;
      var LazyComponent = 16;
      var IncompleteClassComponent = 17;
      var DehydratedSuspenseComponent = 18;
      var SuspenseListComponent = 19;
      var FundamentalComponent = 20;

      function getParent(inst) {
        do {
          inst = inst.return;
        } while (inst && inst.tag !== HostComponent);

        if (inst) {
          return inst;
        }

        return null;
      }

      function getLowestCommonAncestor(instA, instB) {
        var depthA = 0;

        for (var tempA = instA; tempA; tempA = getParent(tempA)) {
          depthA++;
        }

        var depthB = 0;

        for (var tempB = instB; tempB; tempB = getParent(tempB)) {
          depthB++;
        }

        while (depthA - depthB > 0) {
          instA = getParent(instA);
          depthA--;
        }

        while (depthB - depthA > 0) {
          instB = getParent(instB);
          depthB--;
        }

        var depth = depthA;

        while (depth--) {
          if (instA === instB || instA === instB.alternate) {
            return instA;
          }

          instA = getParent(instA);
          instB = getParent(instB);
        }

        return null;
      }

      function isAncestor(instA, instB) {
        while (instB) {
          if (instA === instB || instA === instB.alternate) {
            return true;
          }

          instB = getParent(instB);
        }

        return false;
      }

      function getParentInstance(inst) {
        return getParent(inst);
      }

      function traverseTwoPhase(inst, fn, arg) {
        var path = [];

        while (inst) {
          path.push(inst);
          inst = getParent(inst);
        }

        var i = void 0;

        for (i = path.length; i-- > 0;) {
          fn(path[i], "captured", arg);
        }

        for (i = 0; i < path.length; i++) {
          fn(path[i], "bubbled", arg);
        }
      }

      function listenerAtPhase(inst, event, propagationPhase) {
        var registrationName = event.dispatchConfig.phasedRegistrationNames[propagationPhase];
        return getListener(inst, registrationName);
      }

      function accumulateDirectionalDispatches(inst, phase, event) {
        {
          !inst ? warningWithoutStack$1(false, "Dispatching inst must not be null") : void 0;
        }
        var listener = listenerAtPhase(inst, event, phase);

        if (listener) {
          event._dispatchListeners = accumulateInto(event._dispatchListeners, listener);
          event._dispatchInstances = accumulateInto(event._dispatchInstances, inst);
        }
      }

      function accumulateTwoPhaseDispatchesSingle(event) {
        if (event && event.dispatchConfig.phasedRegistrationNames) {
          traverseTwoPhase(event._targetInst, accumulateDirectionalDispatches, event);
        }
      }

      function accumulateTwoPhaseDispatchesSingleSkipTarget(event) {
        if (event && event.dispatchConfig.phasedRegistrationNames) {
          var targetInst = event._targetInst;
          var parentInst = targetInst ? getParentInstance(targetInst) : null;
          traverseTwoPhase(parentInst, accumulateDirectionalDispatches, event);
        }
      }

      function accumulateDispatches(inst, ignoredDirection, event) {
        if (inst && event && event.dispatchConfig.registrationName) {
          var registrationName = event.dispatchConfig.registrationName;
          var listener = getListener(inst, registrationName);

          if (listener) {
            event._dispatchListeners = accumulateInto(event._dispatchListeners, listener);
            event._dispatchInstances = accumulateInto(event._dispatchInstances, inst);
          }
        }
      }

      function accumulateDirectDispatchesSingle(event) {
        if (event && event.dispatchConfig.registrationName) {
          accumulateDispatches(event._targetInst, null, event);
        }
      }

      function accumulateTwoPhaseDispatches(events) {
        forEachAccumulated(events, accumulateTwoPhaseDispatchesSingle);
      }

      function accumulateTwoPhaseDispatchesSkipTarget(events) {
        forEachAccumulated(events, accumulateTwoPhaseDispatchesSingleSkipTarget);
      }

      function accumulateDirectDispatches(events) {
        forEachAccumulated(events, accumulateDirectDispatchesSingle);
      }

      var EVENT_POOL_SIZE = 10;
      var EventInterface = {
        type: null,
        target: null,
        currentTarget: function currentTarget() {
          return null;
        },
        eventPhase: null,
        bubbles: null,
        cancelable: null,
        timeStamp: function timeStamp(event) {
          return event.timeStamp || Date.now();
        },
        defaultPrevented: null,
        isTrusted: null
      };

      function functionThatReturnsTrue() {
        return true;
      }

      function functionThatReturnsFalse() {
        return false;
      }

      function SyntheticEvent(dispatchConfig, targetInst, nativeEvent, nativeEventTarget) {
        {
          delete this.nativeEvent;
          delete this.preventDefault;
          delete this.stopPropagation;
          delete this.isDefaultPrevented;
          delete this.isPropagationStopped;
        }
        this.dispatchConfig = dispatchConfig;
        this._targetInst = targetInst;
        this.nativeEvent = nativeEvent;
        var Interface = this.constructor.Interface;

        for (var propName in Interface) {
          if (!Interface.hasOwnProperty(propName)) {
            continue;
          }

          {
            delete this[propName];
          }
          var normalize = Interface[propName];

          if (normalize) {
            this[propName] = normalize(nativeEvent);
          } else {
            if (propName === "target") {
              this.target = nativeEventTarget;
            } else {
              this[propName] = nativeEvent[propName];
            }
          }
        }

        var defaultPrevented = nativeEvent.defaultPrevented != null ? nativeEvent.defaultPrevented : nativeEvent.returnValue === false;

        if (defaultPrevented) {
          this.isDefaultPrevented = functionThatReturnsTrue;
        } else {
          this.isDefaultPrevented = functionThatReturnsFalse;
        }

        this.isPropagationStopped = functionThatReturnsFalse;
        return this;
      }

      _extends(SyntheticEvent.prototype, {
        preventDefault: function preventDefault() {
          this.defaultPrevented = true;
          var event = this.nativeEvent;

          if (!event) {
            return;
          }

          if (event.preventDefault) {
            event.preventDefault();
          } else if (typeof event.returnValue !== "unknown") {
            event.returnValue = false;
          }

          this.isDefaultPrevented = functionThatReturnsTrue;
        },
        stopPropagation: function stopPropagation() {
          var event = this.nativeEvent;

          if (!event) {
            return;
          }

          if (event.stopPropagation) {
            event.stopPropagation();
          } else if (typeof event.cancelBubble !== "unknown") {
            event.cancelBubble = true;
          }

          this.isPropagationStopped = functionThatReturnsTrue;
        },
        persist: function persist() {
          this.isPersistent = functionThatReturnsTrue;
        },
        isPersistent: functionThatReturnsFalse,
        destructor: function destructor() {
          var Interface = this.constructor.Interface;

          for (var propName in Interface) {
            {
              Object.defineProperty(this, propName, getPooledWarningPropertyDefinition(propName, Interface[propName]));
            }
          }

          this.dispatchConfig = null;
          this._targetInst = null;
          this.nativeEvent = null;
          this.isDefaultPrevented = functionThatReturnsFalse;
          this.isPropagationStopped = functionThatReturnsFalse;
          this._dispatchListeners = null;
          this._dispatchInstances = null;
          {
            Object.defineProperty(this, "nativeEvent", getPooledWarningPropertyDefinition("nativeEvent", null));
            Object.defineProperty(this, "isDefaultPrevented", getPooledWarningPropertyDefinition("isDefaultPrevented", functionThatReturnsFalse));
            Object.defineProperty(this, "isPropagationStopped", getPooledWarningPropertyDefinition("isPropagationStopped", functionThatReturnsFalse));
            Object.defineProperty(this, "preventDefault", getPooledWarningPropertyDefinition("preventDefault", function () {}));
            Object.defineProperty(this, "stopPropagation", getPooledWarningPropertyDefinition("stopPropagation", function () {}));
          }
        }
      });

      SyntheticEvent.Interface = EventInterface;

      SyntheticEvent.extend = function (Interface) {
        var Super = this;

        var E = function E() {};

        E.prototype = Super.prototype;
        var prototype = new E();

        function Class() {
          return Super.apply(this, arguments);
        }

        _extends(prototype, Class.prototype);

        Class.prototype = prototype;
        Class.prototype.constructor = Class;
        Class.Interface = _extends({}, Super.Interface, Interface);
        Class.extend = Super.extend;
        addEventPoolingTo(Class);
        return Class;
      };

      addEventPoolingTo(SyntheticEvent);

      function getPooledWarningPropertyDefinition(propName, getVal) {
        var isFunction = typeof getVal === "function";
        return {
          configurable: true,
          set: set,
          get: get
        };

        function set(val) {
          var action = isFunction ? "setting the method" : "setting the property";
          warn(action, "This is effectively a no-op");
          return val;
        }

        function get() {
          var action = isFunction ? "accessing the method" : "accessing the property";
          var result = isFunction ? "This is a no-op function" : "This is set to null";
          warn(action, result);
          return getVal;
        }

        function warn(action, result) {
          var warningCondition = false;
          !warningCondition ? warningWithoutStack$1(false, "This synthetic event is reused for performance reasons. If you're seeing this, " + "you're %s `%s` on a released/nullified synthetic event. %s. " + "If you must keep the original synthetic event around, use event.persist(). " + "See https://fb.me/react-event-pooling for more information.", action, propName, result) : void 0;
        }
      }

      function getPooledEvent(dispatchConfig, targetInst, nativeEvent, nativeInst) {
        var EventConstructor = this;

        if (EventConstructor.eventPool.length) {
          var instance = EventConstructor.eventPool.pop();
          EventConstructor.call(instance, dispatchConfig, targetInst, nativeEvent, nativeInst);
          return instance;
        }

        return new EventConstructor(dispatchConfig, targetInst, nativeEvent, nativeInst);
      }

      function releasePooledEvent(event) {
        var EventConstructor = this;

        (function () {
          if (!(event instanceof EventConstructor)) {
            throw ReactError(Error("Trying to release an event instance into a pool of a different type."));
          }
        })();

        event.destructor();

        if (EventConstructor.eventPool.length < EVENT_POOL_SIZE) {
          EventConstructor.eventPool.push(event);
        }
      }

      function addEventPoolingTo(EventConstructor) {
        EventConstructor.eventPool = [];
        EventConstructor.getPooled = getPooledEvent;
        EventConstructor.release = releasePooledEvent;
      }

      var ResponderSyntheticEvent = SyntheticEvent.extend({
        touchHistory: function touchHistory(nativeEvent) {
          return null;
        }
      });
      var TOP_TOUCH_START = "topTouchStart";
      var TOP_TOUCH_MOVE = "topTouchMove";
      var TOP_TOUCH_END = "topTouchEnd";
      var TOP_TOUCH_CANCEL = "topTouchCancel";
      var TOP_SCROLL = "topScroll";
      var TOP_SELECTION_CHANGE = "topSelectionChange";

      function isStartish(topLevelType) {
        return topLevelType === TOP_TOUCH_START;
      }

      function isMoveish(topLevelType) {
        return topLevelType === TOP_TOUCH_MOVE;
      }

      function isEndish(topLevelType) {
        return topLevelType === TOP_TOUCH_END || topLevelType === TOP_TOUCH_CANCEL;
      }

      var startDependencies = [TOP_TOUCH_START];
      var moveDependencies = [TOP_TOUCH_MOVE];
      var endDependencies = [TOP_TOUCH_CANCEL, TOP_TOUCH_END];
      var MAX_TOUCH_BANK = 20;
      var touchBank = [];
      var touchHistory = {
        touchBank: touchBank,
        numberActiveTouches: 0,
        indexOfSingleActiveTouch: -1,
        mostRecentTimeStamp: 0
      };

      function timestampForTouch(touch) {
        return touch.timeStamp || touch.timestamp;
      }

      function createTouchRecord(touch) {
        return {
          touchActive: true,
          startPageX: touch.pageX,
          startPageY: touch.pageY,
          startTimeStamp: timestampForTouch(touch),
          currentPageX: touch.pageX,
          currentPageY: touch.pageY,
          currentTimeStamp: timestampForTouch(touch),
          previousPageX: touch.pageX,
          previousPageY: touch.pageY,
          previousTimeStamp: timestampForTouch(touch)
        };
      }

      function resetTouchRecord(touchRecord, touch) {
        touchRecord.touchActive = true;
        touchRecord.startPageX = touch.pageX;
        touchRecord.startPageY = touch.pageY;
        touchRecord.startTimeStamp = timestampForTouch(touch);
        touchRecord.currentPageX = touch.pageX;
        touchRecord.currentPageY = touch.pageY;
        touchRecord.currentTimeStamp = timestampForTouch(touch);
        touchRecord.previousPageX = touch.pageX;
        touchRecord.previousPageY = touch.pageY;
        touchRecord.previousTimeStamp = timestampForTouch(touch);
      }

      function getTouchIdentifier(_ref) {
        var identifier = _ref.identifier;

        (function () {
          if (!(identifier != null)) {
            throw ReactError(Error("Touch object is missing identifier."));
          }
        })();

        {
          !(identifier <= MAX_TOUCH_BANK) ? warningWithoutStack$1(false, "Touch identifier %s is greater than maximum supported %s which causes " + "performance issues backfilling array locations for all of the indices.", identifier, MAX_TOUCH_BANK) : void 0;
        }
        return identifier;
      }

      function recordTouchStart(touch) {
        var identifier = getTouchIdentifier(touch);
        var touchRecord = touchBank[identifier];

        if (touchRecord) {
          resetTouchRecord(touchRecord, touch);
        } else {
          touchBank[identifier] = createTouchRecord(touch);
        }

        touchHistory.mostRecentTimeStamp = timestampForTouch(touch);
      }

      function recordTouchMove(touch) {
        var touchRecord = touchBank[getTouchIdentifier(touch)];

        if (touchRecord) {
          touchRecord.touchActive = true;
          touchRecord.previousPageX = touchRecord.currentPageX;
          touchRecord.previousPageY = touchRecord.currentPageY;
          touchRecord.previousTimeStamp = touchRecord.currentTimeStamp;
          touchRecord.currentPageX = touch.pageX;
          touchRecord.currentPageY = touch.pageY;
          touchRecord.currentTimeStamp = timestampForTouch(touch);
          touchHistory.mostRecentTimeStamp = timestampForTouch(touch);
        } else {
          console.warn("Cannot record touch move without a touch start.\n" + "Touch Move: %s\n", "Touch Bank: %s", printTouch(touch), printTouchBank());
        }
      }

      function recordTouchEnd(touch) {
        var touchRecord = touchBank[getTouchIdentifier(touch)];

        if (touchRecord) {
          touchRecord.touchActive = false;
          touchRecord.previousPageX = touchRecord.currentPageX;
          touchRecord.previousPageY = touchRecord.currentPageY;
          touchRecord.previousTimeStamp = touchRecord.currentTimeStamp;
          touchRecord.currentPageX = touch.pageX;
          touchRecord.currentPageY = touch.pageY;
          touchRecord.currentTimeStamp = timestampForTouch(touch);
          touchHistory.mostRecentTimeStamp = timestampForTouch(touch);
        } else {
          console.warn("Cannot record touch end without a touch start.\n" + "Touch End: %s\n", "Touch Bank: %s", printTouch(touch), printTouchBank());
        }
      }

      function printTouch(touch) {
        return JSON.stringify({
          identifier: touch.identifier,
          pageX: touch.pageX,
          pageY: touch.pageY,
          timestamp: timestampForTouch(touch)
        });
      }

      function printTouchBank() {
        var printed = JSON.stringify(touchBank.slice(0, MAX_TOUCH_BANK));

        if (touchBank.length > MAX_TOUCH_BANK) {
          printed += " (original size: " + touchBank.length + ")";
        }

        return printed;
      }

      var ResponderTouchHistoryStore = {
        recordTouchTrack: function recordTouchTrack(topLevelType, nativeEvent) {
          if (isMoveish(topLevelType)) {
            nativeEvent.changedTouches.forEach(recordTouchMove);
          } else if (isStartish(topLevelType)) {
            nativeEvent.changedTouches.forEach(recordTouchStart);
            touchHistory.numberActiveTouches = nativeEvent.touches.length;

            if (touchHistory.numberActiveTouches === 1) {
              touchHistory.indexOfSingleActiveTouch = nativeEvent.touches[0].identifier;
            }
          } else if (isEndish(topLevelType)) {
            nativeEvent.changedTouches.forEach(recordTouchEnd);
            touchHistory.numberActiveTouches = nativeEvent.touches.length;

            if (touchHistory.numberActiveTouches === 1) {
              for (var i = 0; i < touchBank.length; i++) {
                var touchTrackToCheck = touchBank[i];

                if (touchTrackToCheck != null && touchTrackToCheck.touchActive) {
                  touchHistory.indexOfSingleActiveTouch = i;
                  break;
                }
              }

              {
                var activeRecord = touchBank[touchHistory.indexOfSingleActiveTouch];
                !(activeRecord != null && activeRecord.touchActive) ? warningWithoutStack$1(false, "Cannot find single active touch.") : void 0;
              }
            }
          }
        },
        touchHistory: touchHistory
      };

      function accumulate(current, next) {
        (function () {
          if (!(next != null)) {
            throw ReactError(Error("accumulate(...): Accumulated items must not be null or undefined."));
          }
        })();

        if (current == null) {
          return next;
        }

        if (Array.isArray(current)) {
          return current.concat(next);
        }

        if (Array.isArray(next)) {
          return [current].concat(next);
        }

        return [current, next];
      }

      var responderInst = null;
      var trackedTouchCount = 0;

      var changeResponder = function changeResponder(nextResponderInst, blockHostResponder) {
        var oldResponderInst = responderInst;
        responderInst = nextResponderInst;

        if (ResponderEventPlugin.GlobalResponderHandler !== null) {
          ResponderEventPlugin.GlobalResponderHandler.onChange(oldResponderInst, nextResponderInst, blockHostResponder);
        }
      };

      var eventTypes = {
        startShouldSetResponder: {
          phasedRegistrationNames: {
            bubbled: "onStartShouldSetResponder",
            captured: "onStartShouldSetResponderCapture"
          },
          dependencies: startDependencies
        },
        scrollShouldSetResponder: {
          phasedRegistrationNames: {
            bubbled: "onScrollShouldSetResponder",
            captured: "onScrollShouldSetResponderCapture"
          },
          dependencies: [TOP_SCROLL]
        },
        selectionChangeShouldSetResponder: {
          phasedRegistrationNames: {
            bubbled: "onSelectionChangeShouldSetResponder",
            captured: "onSelectionChangeShouldSetResponderCapture"
          },
          dependencies: [TOP_SELECTION_CHANGE]
        },
        moveShouldSetResponder: {
          phasedRegistrationNames: {
            bubbled: "onMoveShouldSetResponder",
            captured: "onMoveShouldSetResponderCapture"
          },
          dependencies: moveDependencies
        },
        responderStart: {
          registrationName: "onResponderStart",
          dependencies: startDependencies
        },
        responderMove: {
          registrationName: "onResponderMove",
          dependencies: moveDependencies
        },
        responderEnd: {
          registrationName: "onResponderEnd",
          dependencies: endDependencies
        },
        responderRelease: {
          registrationName: "onResponderRelease",
          dependencies: endDependencies
        },
        responderTerminationRequest: {
          registrationName: "onResponderTerminationRequest",
          dependencies: []
        },
        responderGrant: {
          registrationName: "onResponderGrant",
          dependencies: []
        },
        responderReject: {
          registrationName: "onResponderReject",
          dependencies: []
        },
        responderTerminate: {
          registrationName: "onResponderTerminate",
          dependencies: []
        }
      };

      function setResponderAndExtractTransfer(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
        var shouldSetEventType = isStartish(topLevelType) ? eventTypes.startShouldSetResponder : isMoveish(topLevelType) ? eventTypes.moveShouldSetResponder : topLevelType === TOP_SELECTION_CHANGE ? eventTypes.selectionChangeShouldSetResponder : eventTypes.scrollShouldSetResponder;
        var bubbleShouldSetFrom = !responderInst ? targetInst : getLowestCommonAncestor(responderInst, targetInst);
        var skipOverBubbleShouldSetFrom = bubbleShouldSetFrom === responderInst;
        var shouldSetEvent = ResponderSyntheticEvent.getPooled(shouldSetEventType, bubbleShouldSetFrom, nativeEvent, nativeEventTarget);
        shouldSetEvent.touchHistory = ResponderTouchHistoryStore.touchHistory;

        if (skipOverBubbleShouldSetFrom) {
          accumulateTwoPhaseDispatchesSkipTarget(shouldSetEvent);
        } else {
          accumulateTwoPhaseDispatches(shouldSetEvent);
        }

        var wantsResponderInst = executeDispatchesInOrderStopAtTrue(shouldSetEvent);

        if (!shouldSetEvent.isPersistent()) {
          shouldSetEvent.constructor.release(shouldSetEvent);
        }

        if (!wantsResponderInst || wantsResponderInst === responderInst) {
          return null;
        }

        var extracted = void 0;
        var grantEvent = ResponderSyntheticEvent.getPooled(eventTypes.responderGrant, wantsResponderInst, nativeEvent, nativeEventTarget);
        grantEvent.touchHistory = ResponderTouchHistoryStore.touchHistory;
        accumulateDirectDispatches(grantEvent);
        var blockHostResponder = executeDirectDispatch(grantEvent) === true;

        if (responderInst) {
          var terminationRequestEvent = ResponderSyntheticEvent.getPooled(eventTypes.responderTerminationRequest, responderInst, nativeEvent, nativeEventTarget);
          terminationRequestEvent.touchHistory = ResponderTouchHistoryStore.touchHistory;
          accumulateDirectDispatches(terminationRequestEvent);
          var shouldSwitch = !hasDispatches(terminationRequestEvent) || executeDirectDispatch(terminationRequestEvent);

          if (!terminationRequestEvent.isPersistent()) {
            terminationRequestEvent.constructor.release(terminationRequestEvent);
          }

          if (shouldSwitch) {
            var terminateEvent = ResponderSyntheticEvent.getPooled(eventTypes.responderTerminate, responderInst, nativeEvent, nativeEventTarget);
            terminateEvent.touchHistory = ResponderTouchHistoryStore.touchHistory;
            accumulateDirectDispatches(terminateEvent);
            extracted = accumulate(extracted, [grantEvent, terminateEvent]);
            changeResponder(wantsResponderInst, blockHostResponder);
          } else {
            var rejectEvent = ResponderSyntheticEvent.getPooled(eventTypes.responderReject, wantsResponderInst, nativeEvent, nativeEventTarget);
            rejectEvent.touchHistory = ResponderTouchHistoryStore.touchHistory;
            accumulateDirectDispatches(rejectEvent);
            extracted = accumulate(extracted, rejectEvent);
          }
        } else {
          extracted = accumulate(extracted, grantEvent);
          changeResponder(wantsResponderInst, blockHostResponder);
        }

        return extracted;
      }

      function canTriggerTransfer(topLevelType, topLevelInst, nativeEvent) {
        return topLevelInst && (topLevelType === TOP_SCROLL && !nativeEvent.responderIgnoreScroll || trackedTouchCount > 0 && topLevelType === TOP_SELECTION_CHANGE || isStartish(topLevelType) || isMoveish(topLevelType));
      }

      function noResponderTouches(nativeEvent) {
        var touches = nativeEvent.touches;

        if (!touches || touches.length === 0) {
          return true;
        }

        for (var i = 0; i < touches.length; i++) {
          var activeTouch = touches[i];
          var target = activeTouch.target;

          if (target !== null && target !== undefined && target !== 0) {
            var targetInst = getInstanceFromNode(target);

            if (isAncestor(responderInst, targetInst)) {
              return false;
            }
          }
        }

        return true;
      }

      var ResponderEventPlugin = {
        _getResponder: function _getResponder() {
          return responderInst;
        },
        eventTypes: eventTypes,
        extractEvents: function extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
          if (isStartish(topLevelType)) {
            trackedTouchCount += 1;
          } else if (isEndish(topLevelType)) {
            if (trackedTouchCount >= 0) {
              trackedTouchCount -= 1;
            } else {
              console.error("Ended a touch event which was not counted in `trackedTouchCount`.");
              return null;
            }
          }

          ResponderTouchHistoryStore.recordTouchTrack(topLevelType, nativeEvent);
          var extracted = canTriggerTransfer(topLevelType, targetInst, nativeEvent) ? setResponderAndExtractTransfer(topLevelType, targetInst, nativeEvent, nativeEventTarget) : null;
          var isResponderTouchStart = responderInst && isStartish(topLevelType);
          var isResponderTouchMove = responderInst && isMoveish(topLevelType);
          var isResponderTouchEnd = responderInst && isEndish(topLevelType);
          var incrementalTouch = isResponderTouchStart ? eventTypes.responderStart : isResponderTouchMove ? eventTypes.responderMove : isResponderTouchEnd ? eventTypes.responderEnd : null;

          if (incrementalTouch) {
            var gesture = ResponderSyntheticEvent.getPooled(incrementalTouch, responderInst, nativeEvent, nativeEventTarget);
            gesture.touchHistory = ResponderTouchHistoryStore.touchHistory;
            accumulateDirectDispatches(gesture);
            extracted = accumulate(extracted, gesture);
          }

          var isResponderTerminate = responderInst && topLevelType === TOP_TOUCH_CANCEL;
          var isResponderRelease = responderInst && !isResponderTerminate && isEndish(topLevelType) && noResponderTouches(nativeEvent);
          var finalTouch = isResponderTerminate ? eventTypes.responderTerminate : isResponderRelease ? eventTypes.responderRelease : null;

          if (finalTouch) {
            var finalEvent = ResponderSyntheticEvent.getPooled(finalTouch, responderInst, nativeEvent, nativeEventTarget);
            finalEvent.touchHistory = ResponderTouchHistoryStore.touchHistory;
            accumulateDirectDispatches(finalEvent);
            extracted = accumulate(extracted, finalEvent);
            changeResponder(null);
          }

          return extracted;
        },
        GlobalResponderHandler: null,
        injection: {
          injectGlobalResponderHandler: function injectGlobalResponderHandler(GlobalResponderHandler) {
            ResponderEventPlugin.GlobalResponderHandler = GlobalResponderHandler;
          }
        }
      };
      var customBubblingEventTypes = ReactNativePrivateInterface.ReactNativeViewConfigRegistry.customBubblingEventTypes;
      var customDirectEventTypes = ReactNativePrivateInterface.ReactNativeViewConfigRegistry.customDirectEventTypes;
      var ReactNativeBridgeEventPlugin = {
        eventTypes: {},
        extractEvents: function extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
          if (targetInst == null) {
            return null;
          }

          var bubbleDispatchConfig = customBubblingEventTypes[topLevelType];
          var directDispatchConfig = customDirectEventTypes[topLevelType];

          (function () {
            if (!(bubbleDispatchConfig || directDispatchConfig)) {
              throw ReactError(Error('Unsupported top level event type "' + topLevelType + '" dispatched'));
            }
          })();

          var event = SyntheticEvent.getPooled(bubbleDispatchConfig || directDispatchConfig, targetInst, nativeEvent, nativeEventTarget);

          if (bubbleDispatchConfig) {
            accumulateTwoPhaseDispatches(event);
          } else if (directDispatchConfig) {
            accumulateDirectDispatches(event);
          } else {
            return null;
          }

          return event;
        }
      };
      var ReactNativeEventPluginOrder = ["ResponderEventPlugin", "ReactNativeBridgeEventPlugin"];
      injection.injectEventPluginOrder(ReactNativeEventPluginOrder);
      injection.injectEventPluginsByName({
        ResponderEventPlugin: ResponderEventPlugin,
        ReactNativeBridgeEventPlugin: ReactNativeBridgeEventPlugin
      });

      function getInstanceFromInstance(instanceHandle) {
        return instanceHandle;
      }

      function getTagFromInstance(inst) {
        var tag = inst.stateNode.canonical._nativeTag;

        (function () {
          if (!tag) {
            throw ReactError(Error("All native instances should have a tag."));
          }
        })();

        return tag;
      }

      function getFiberCurrentPropsFromNode$1(inst) {
        return inst.canonical.currentProps;
      }

      var ReactFabricGlobalResponderHandler = {
        onChange: function onChange(from, to, blockNativeResponder) {
          if (to !== null) {
            var tag = to.stateNode.canonical._nativeTag;
            ReactNativePrivateInterface.UIManager.setJSResponder(tag, blockNativeResponder);
          } else {
            ReactNativePrivateInterface.UIManager.clearJSResponder();
          }
        }
      };
      setComponentTree(getFiberCurrentPropsFromNode$1, getInstanceFromInstance, getTagFromInstance);
      ResponderEventPlugin.injection.injectGlobalResponderHandler(ReactFabricGlobalResponderHandler);

      function get(key) {
        return key._reactInternalFiber;
      }

      function set(key, value) {
        key._reactInternalFiber = value;
      }

      var ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;

      if (!ReactSharedInternals.hasOwnProperty("ReactCurrentDispatcher")) {
        ReactSharedInternals.ReactCurrentDispatcher = {
          current: null
        };
      }

      if (!ReactSharedInternals.hasOwnProperty("ReactCurrentBatchConfig")) {
        ReactSharedInternals.ReactCurrentBatchConfig = {
          suspense: null
        };
      }

      var hasSymbol = typeof Symbol === "function" && (typeof Symbol === "function" ? Symbol.for : "@@for");
      var REACT_ELEMENT_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.element") : 0xeac7;
      var REACT_PORTAL_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.portal") : 0xeaca;
      var REACT_FRAGMENT_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.fragment") : 0xeacb;
      var REACT_STRICT_MODE_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.strict_mode") : 0xeacc;
      var REACT_PROFILER_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.profiler") : 0xead2;
      var REACT_PROVIDER_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.provider") : 0xeacd;
      var REACT_CONTEXT_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.context") : 0xeace;
      var REACT_CONCURRENT_MODE_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.concurrent_mode") : 0xeacf;
      var REACT_FORWARD_REF_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.forward_ref") : 0xead0;
      var REACT_SUSPENSE_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.suspense") : 0xead1;
      var REACT_SUSPENSE_LIST_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.suspense_list") : 0xead8;
      var REACT_MEMO_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.memo") : 0xead3;
      var REACT_LAZY_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.lazy") : 0xead4;
      var REACT_FUNDAMENTAL_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.fundamental") : 0xead5;
      var REACT_RESPONDER_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.responder") : 0xead6;
      var MAYBE_ITERATOR_SYMBOL = typeof Symbol === "function" && (typeof Symbol === "function" ? Symbol.iterator : "@@iterator");
      var FAUX_ITERATOR_SYMBOL = "@@iterator";

      function getIteratorFn(maybeIterable) {
        if (maybeIterable === null || typeof maybeIterable !== "object") {
          return null;
        }

        var maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];

        if (typeof maybeIterator === "function") {
          return maybeIterator;
        }

        return null;
      }

      var Pending = 0;
      var Resolved = 1;
      var Rejected = 2;

      function refineResolvedLazyComponent(lazyComponent) {
        return lazyComponent._status === Resolved ? lazyComponent._result : null;
      }

      function getWrappedName(outerType, innerType, wrapperName) {
        var functionName = innerType.displayName || innerType.name || "";
        return outerType.displayName || (functionName !== "" ? wrapperName + "(" + functionName + ")" : wrapperName);
      }

      function getComponentName(type) {
        if (type == null) {
          return null;
        }

        {
          if (typeof type.tag === "number") {
            warningWithoutStack$1(false, "Received an unexpected object in getComponentName(). " + "This is likely a bug in React. Please file an issue.");
          }
        }

        if (typeof type === "function") {
          return type.displayName || type.name || null;
        }

        if (typeof type === "string") {
          return type;
        }

        switch (type) {
          case REACT_FRAGMENT_TYPE:
            return "Fragment";

          case REACT_PORTAL_TYPE:
            return "Portal";

          case REACT_PROFILER_TYPE:
            return "Profiler";

          case REACT_STRICT_MODE_TYPE:
            return "StrictMode";

          case REACT_SUSPENSE_TYPE:
            return "Suspense";

          case REACT_SUSPENSE_LIST_TYPE:
            return "SuspenseList";
        }

        if (typeof type === "object") {
          switch (type.$$typeof) {
            case REACT_CONTEXT_TYPE:
              return "Context.Consumer";

            case REACT_PROVIDER_TYPE:
              return "Context.Provider";

            case REACT_FORWARD_REF_TYPE:
              return getWrappedName(type, type.render, "ForwardRef");

            case REACT_MEMO_TYPE:
              return getComponentName(type.type);

            case REACT_LAZY_TYPE:
              {
                var thenable = type;
                var resolvedThenable = refineResolvedLazyComponent(thenable);

                if (resolvedThenable) {
                  return getComponentName(resolvedThenable);
                }

                break;
              }
          }
        }

        return null;
      }

      var NoEffect = 0;
      var PerformedWork = 1;
      var Placement = 2;
      var Update = 4;
      var PlacementAndUpdate = 6;
      var Deletion = 8;
      var ContentReset = 16;
      var Callback = 32;
      var DidCapture = 64;
      var Ref = 128;
      var Snapshot = 256;
      var Passive = 512;
      var LifecycleEffectMask = 932;
      var HostEffectMask = 1023;
      var Incomplete = 1024;
      var ShouldCapture = 2048;
      var debugRenderPhaseSideEffects = false;
      var debugRenderPhaseSideEffectsForStrictMode = false;
      var enableUserTimingAPI = true;
      var replayFailedUnitOfWorkWithInvokeGuardedCallback = true;
      var warnAboutDeprecatedLifecycles = true;
      var enableProfilerTimer = true;
      var enableSchedulerTracing = true;
      var enableSuspenseServerRenderer = false;
      var warnAboutDeprecatedSetNativeProps = false;
      var enableFlareAPI = false;
      var enableFundamentalAPI = false;
      var warnAboutUnmockedScheduler = false;
      var revertPassiveEffectsChange = false;
      var flushSuspenseFallbacksInTests = true;
      var enableUserBlockingEvents = false;
      var enableSuspenseCallback = false;
      var warnAboutDefaultPropsOnFunctionComponents = false;
      var warnAboutStringRefs = false;
      var disableLegacyContext = false;
      var disableSchedulerTimeoutBasedOnReactExpirationTime = false;
      var ReactCurrentOwner$1 = ReactSharedInternals.ReactCurrentOwner;
      var MOUNTING = 1;
      var MOUNTED = 2;
      var UNMOUNTED = 3;

      function isFiberMountedImpl(fiber) {
        var node = fiber;

        if (!fiber.alternate) {
          if ((node.effectTag & Placement) !== NoEffect) {
            return MOUNTING;
          }

          while (node.return) {
            node = node.return;

            if ((node.effectTag & Placement) !== NoEffect) {
              return MOUNTING;
            }
          }
        } else {
          while (node.return) {
            node = node.return;
          }
        }

        if (node.tag === HostRoot) {
          return MOUNTED;
        }

        return UNMOUNTED;
      }

      function isFiberMounted(fiber) {
        return isFiberMountedImpl(fiber) === MOUNTED;
      }

      function isMounted(component) {
        {
          var owner = ReactCurrentOwner$1.current;

          if (owner !== null && owner.tag === ClassComponent) {
            var ownerFiber = owner;
            var instance = ownerFiber.stateNode;
            !instance._warnedAboutRefsInRender ? warningWithoutStack$1(false, "%s is accessing isMounted inside its render() function. " + "render() should be a pure function of props and state. It should " + "never access something that requires stale data from the previous " + "render, such as refs. Move this logic to componentDidMount and " + "componentDidUpdate instead.", getComponentName(ownerFiber.type) || "A component") : void 0;
            instance._warnedAboutRefsInRender = true;
          }
        }
        var fiber = get(component);

        if (!fiber) {
          return false;
        }

        return isFiberMountedImpl(fiber) === MOUNTED;
      }

      function assertIsMounted(fiber) {
        (function () {
          if (!(isFiberMountedImpl(fiber) === MOUNTED)) {
            throw ReactError(Error("Unable to find node on an unmounted component."));
          }
        })();
      }

      function findCurrentFiberUsingSlowPath(fiber) {
        var alternate = fiber.alternate;

        if (!alternate) {
          var state = isFiberMountedImpl(fiber);

          (function () {
            if (!(state !== UNMOUNTED)) {
              throw ReactError(Error("Unable to find node on an unmounted component."));
            }
          })();

          if (state === MOUNTING) {
            return null;
          }

          return fiber;
        }

        var a = fiber;
        var b = alternate;

        while (true) {
          var parentA = a.return;

          if (parentA === null) {
            break;
          }

          var parentB = parentA.alternate;

          if (parentB === null) {
            var nextParent = parentA.return;

            if (nextParent !== null) {
              a = b = nextParent;
              continue;
            }

            break;
          }

          if (parentA.child === parentB.child) {
            var child = parentA.child;

            while (child) {
              if (child === a) {
                assertIsMounted(parentA);
                return fiber;
              }

              if (child === b) {
                assertIsMounted(parentA);
                return alternate;
              }

              child = child.sibling;
            }

            (function () {
              {
                throw ReactError(Error("Unable to find node on an unmounted component."));
              }
            })();
          }

          if (a.return !== b.return) {
            a = parentA;
            b = parentB;
          } else {
            var didFindChild = false;
            var _child = parentA.child;

            while (_child) {
              if (_child === a) {
                didFindChild = true;
                a = parentA;
                b = parentB;
                break;
              }

              if (_child === b) {
                didFindChild = true;
                b = parentA;
                a = parentB;
                break;
              }

              _child = _child.sibling;
            }

            if (!didFindChild) {
              _child = parentB.child;

              while (_child) {
                if (_child === a) {
                  didFindChild = true;
                  a = parentB;
                  b = parentA;
                  break;
                }

                if (_child === b) {
                  didFindChild = true;
                  b = parentB;
                  a = parentA;
                  break;
                }

                _child = _child.sibling;
              }

              (function () {
                if (!didFindChild) {
                  throw ReactError(Error("Child was not found in either parent set. This indicates a bug in React related to the return pointer. Please file an issue."));
                }
              })();
            }
          }

          (function () {
            if (!(a.alternate === b)) {
              throw ReactError(Error("Return fibers should always be each others' alternates. This error is likely caused by a bug in React. Please file an issue."));
            }
          })();
        }

        (function () {
          if (!(a.tag === HostRoot)) {
            throw ReactError(Error("Unable to find node on an unmounted component."));
          }
        })();

        if (a.stateNode.current === a) {
          return fiber;
        }

        return alternate;
      }

      function findCurrentHostFiber(parent) {
        var currentParent = findCurrentFiberUsingSlowPath(parent);

        if (!currentParent) {
          return null;
        }

        var node = currentParent;

        while (true) {
          if (node.tag === HostComponent || node.tag === HostText) {
            return node;
          } else if (node.child) {
            node.child.return = node;
            node = node.child;
            continue;
          }

          if (node === currentParent) {
            return null;
          }

          while (!node.sibling) {
            if (!node.return || node.return === currentParent) {
              return null;
            }

            node = node.return;
          }

          node.sibling.return = node.return;
          node = node.sibling;
        }

        return null;
      }

      function mountSafeCallback_NOT_REALLY_SAFE(context, callback) {
        return function () {
          if (!callback) {
            return undefined;
          }

          if (typeof context.__isMounted === "boolean") {
            if (!context.__isMounted) {
              return undefined;
            }
          }

          return callback.apply(context, arguments);
        };
      }

      function throwOnStylesProp(component, props) {
        if (props.styles !== undefined) {
          var owner = component._owner || null;
          var name = component.constructor.displayName;
          var msg = "`styles` is not a supported property of `" + name + "`, did " + "you mean `style` (singular)?";

          if (owner && owner.constructor && owner.constructor.displayName) {
            msg += "\n\nCheck the `" + owner.constructor.displayName + "` parent " + " component.";
          }

          throw new Error(msg);
        }
      }

      function warnForStyleProps(props, validAttributes) {
        for (var key in validAttributes.style) {
          if (!(validAttributes[key] || props[key] === undefined)) {
            console.error("You are setting the style `{ " + key + ": ... }` as a prop. You " + "should nest it in a style object. " + "E.g. `{ style: { " + key + ": ... } }`");
          }
        }
      }

      var emptyObject = {};
      var removedKeys = null;
      var removedKeyCount = 0;

      function defaultDiffer(prevProp, nextProp) {
        if (typeof nextProp !== "object" || nextProp === null) {
          return true;
        } else {
          return ReactNativePrivateInterface.deepDiffer(prevProp, nextProp);
        }
      }

      function restoreDeletedValuesInNestedArray(updatePayload, node, validAttributes) {
        if (Array.isArray(node)) {
          var i = node.length;

          while (i-- && removedKeyCount > 0) {
            restoreDeletedValuesInNestedArray(updatePayload, node[i], validAttributes);
          }
        } else if (node && removedKeyCount > 0) {
          var obj = node;

          for (var propKey in removedKeys) {
            if (!removedKeys[propKey]) {
              continue;
            }

            var nextProp = obj[propKey];

            if (nextProp === undefined) {
              continue;
            }

            var attributeConfig = validAttributes[propKey];

            if (!attributeConfig) {
              continue;
            }

            if (typeof nextProp === "function") {
              nextProp = true;
            }

            if (typeof nextProp === "undefined") {
              nextProp = null;
            }

            if (typeof attributeConfig !== "object") {
              updatePayload[propKey] = nextProp;
            } else if (typeof attributeConfig.diff === "function" || typeof attributeConfig.process === "function") {
              var nextValue = typeof attributeConfig.process === "function" ? attributeConfig.process(nextProp) : nextProp;
              updatePayload[propKey] = nextValue;
            }

            removedKeys[propKey] = false;
            removedKeyCount--;
          }
        }
      }

      function diffNestedArrayProperty(updatePayload, prevArray, nextArray, validAttributes) {
        var minLength = prevArray.length < nextArray.length ? prevArray.length : nextArray.length;
        var i = void 0;

        for (i = 0; i < minLength; i++) {
          updatePayload = diffNestedProperty(updatePayload, prevArray[i], nextArray[i], validAttributes);
        }

        for (; i < prevArray.length; i++) {
          updatePayload = clearNestedProperty(updatePayload, prevArray[i], validAttributes);
        }

        for (; i < nextArray.length; i++) {
          updatePayload = addNestedProperty(updatePayload, nextArray[i], validAttributes);
        }

        return updatePayload;
      }

      function diffNestedProperty(updatePayload, prevProp, nextProp, validAttributes) {
        if (!updatePayload && prevProp === nextProp) {
          return updatePayload;
        }

        if (!prevProp || !nextProp) {
          if (nextProp) {
            return addNestedProperty(updatePayload, nextProp, validAttributes);
          }

          if (prevProp) {
            return clearNestedProperty(updatePayload, prevProp, validAttributes);
          }

          return updatePayload;
        }

        if (!Array.isArray(prevProp) && !Array.isArray(nextProp)) {
          return diffProperties(updatePayload, prevProp, nextProp, validAttributes);
        }

        if (Array.isArray(prevProp) && Array.isArray(nextProp)) {
          return diffNestedArrayProperty(updatePayload, prevProp, nextProp, validAttributes);
        }

        if (Array.isArray(prevProp)) {
          return diffProperties(updatePayload, ReactNativePrivateInterface.flattenStyle(prevProp), nextProp, validAttributes);
        }

        return diffProperties(updatePayload, prevProp, ReactNativePrivateInterface.flattenStyle(nextProp), validAttributes);
      }

      function addNestedProperty(updatePayload, nextProp, validAttributes) {
        if (!nextProp) {
          return updatePayload;
        }

        if (!Array.isArray(nextProp)) {
          return addProperties(updatePayload, nextProp, validAttributes);
        }

        for (var i = 0; i < nextProp.length; i++) {
          updatePayload = addNestedProperty(updatePayload, nextProp[i], validAttributes);
        }

        return updatePayload;
      }

      function clearNestedProperty(updatePayload, prevProp, validAttributes) {
        if (!prevProp) {
          return updatePayload;
        }

        if (!Array.isArray(prevProp)) {
          return clearProperties(updatePayload, prevProp, validAttributes);
        }

        for (var i = 0; i < prevProp.length; i++) {
          updatePayload = clearNestedProperty(updatePayload, prevProp[i], validAttributes);
        }

        return updatePayload;
      }

      function diffProperties(updatePayload, prevProps, nextProps, validAttributes) {
        var attributeConfig = void 0;
        var nextProp = void 0;
        var prevProp = void 0;

        for (var propKey in nextProps) {
          attributeConfig = validAttributes[propKey];

          if (!attributeConfig) {
            continue;
          }

          prevProp = prevProps[propKey];
          nextProp = nextProps[propKey];

          if (typeof nextProp === "function") {
            nextProp = true;

            if (typeof prevProp === "function") {
              prevProp = true;
            }
          }

          if (typeof nextProp === "undefined") {
            nextProp = null;

            if (typeof prevProp === "undefined") {
              prevProp = null;
            }
          }

          if (removedKeys) {
            removedKeys[propKey] = false;
          }

          if (updatePayload && updatePayload[propKey] !== undefined) {
            if (typeof attributeConfig !== "object") {
              updatePayload[propKey] = nextProp;
            } else if (typeof attributeConfig.diff === "function" || typeof attributeConfig.process === "function") {
              var nextValue = typeof attributeConfig.process === "function" ? attributeConfig.process(nextProp) : nextProp;
              updatePayload[propKey] = nextValue;
            }

            continue;
          }

          if (prevProp === nextProp) {
            continue;
          }

          if (typeof attributeConfig !== "object") {
            if (defaultDiffer(prevProp, nextProp)) {
              (updatePayload || (updatePayload = {}))[propKey] = nextProp;
            }
          } else if (typeof attributeConfig.diff === "function" || typeof attributeConfig.process === "function") {
            var shouldUpdate = prevProp === undefined || (typeof attributeConfig.diff === "function" ? attributeConfig.diff(prevProp, nextProp) : defaultDiffer(prevProp, nextProp));

            if (shouldUpdate) {
              var _nextValue = typeof attributeConfig.process === "function" ? attributeConfig.process(nextProp) : nextProp;

              (updatePayload || (updatePayload = {}))[propKey] = _nextValue;
            }
          } else {
            removedKeys = null;
            removedKeyCount = 0;
            updatePayload = diffNestedProperty(updatePayload, prevProp, nextProp, attributeConfig);

            if (removedKeyCount > 0 && updatePayload) {
              restoreDeletedValuesInNestedArray(updatePayload, nextProp, attributeConfig);
              removedKeys = null;
            }
          }
        }

        for (var _propKey in prevProps) {
          if (nextProps[_propKey] !== undefined) {
            continue;
          }

          attributeConfig = validAttributes[_propKey];

          if (!attributeConfig) {
            continue;
          }

          if (updatePayload && updatePayload[_propKey] !== undefined) {
            continue;
          }

          prevProp = prevProps[_propKey];

          if (prevProp === undefined) {
            continue;
          }

          if (typeof attributeConfig !== "object" || typeof attributeConfig.diff === "function" || typeof attributeConfig.process === "function") {
            (updatePayload || (updatePayload = {}))[_propKey] = null;

            if (!removedKeys) {
              removedKeys = {};
            }

            if (!removedKeys[_propKey]) {
              removedKeys[_propKey] = true;
              removedKeyCount++;
            }
          } else {
            updatePayload = clearNestedProperty(updatePayload, prevProp, attributeConfig);
          }
        }

        return updatePayload;
      }

      function addProperties(updatePayload, props, validAttributes) {
        return diffProperties(updatePayload, emptyObject, props, validAttributes);
      }

      function clearProperties(updatePayload, prevProps, validAttributes) {
        return diffProperties(updatePayload, prevProps, emptyObject, validAttributes);
      }

      function create(props, validAttributes) {
        return addProperties(null, props, validAttributes);
      }

      function diff(prevProps, nextProps, validAttributes) {
        return diffProperties(null, prevProps, nextProps, validAttributes);
      }

      var restoreImpl = null;
      var restoreTarget = null;
      var restoreQueue = null;

      function restoreStateOfTarget(target) {
        var internalInstance = getInstanceFromNode(target);

        if (!internalInstance) {
          return;
        }

        (function () {
          if (!(typeof restoreImpl === "function")) {
            throw ReactError(Error("setRestoreImplementation() needs to be called to handle a target for controlled events. This error is likely caused by a bug in React. Please file an issue."));
          }
        })();

        var props = getFiberCurrentPropsFromNode(internalInstance.stateNode);
        restoreImpl(internalInstance.stateNode, internalInstance.type, props);
      }

      function needsStateRestore() {
        return restoreTarget !== null || restoreQueue !== null;
      }

      function restoreStateIfNeeded() {
        if (!restoreTarget) {
          return;
        }

        var target = restoreTarget;
        var queuedTargets = restoreQueue;
        restoreTarget = null;
        restoreQueue = null;
        restoreStateOfTarget(target);

        if (queuedTargets) {
          for (var i = 0; i < queuedTargets.length; i++) {
            restoreStateOfTarget(queuedTargets[i]);
          }
        }
      }

      var batchedUpdatesImpl = function batchedUpdatesImpl(fn, bookkeeping) {
        return fn(bookkeeping);
      };

      var discreteUpdatesImpl = function discreteUpdatesImpl(fn, a, b, c) {
        return fn(a, b, c);
      };

      var flushDiscreteUpdatesImpl = function flushDiscreteUpdatesImpl() {};

      var batchedEventUpdatesImpl = batchedUpdatesImpl;
      var isInsideEventHandler = false;

      function finishEventHandler() {
        var controlledComponentsHavePendingUpdates = needsStateRestore();

        if (controlledComponentsHavePendingUpdates) {
          flushDiscreteUpdatesImpl();
          restoreStateIfNeeded();
        }
      }

      function batchedUpdates(fn, bookkeeping) {
        if (isInsideEventHandler) {
          return fn(bookkeeping);
        }

        isInsideEventHandler = true;

        try {
          return batchedUpdatesImpl(fn, bookkeeping);
        } finally {
          isInsideEventHandler = false;
          finishEventHandler();
        }
      }

      function batchedEventUpdates(fn, a, b) {
        if (isInsideEventHandler) {
          return fn(a, b);
        }

        isInsideEventHandler = true;

        try {
          return batchedEventUpdatesImpl(fn, a, b);
        } finally {
          isInsideEventHandler = false;
          finishEventHandler();
        }
      }

      function discreteUpdates(fn, a, b, c) {
        var prevIsInsideEventHandler = isInsideEventHandler;
        isInsideEventHandler = true;

        try {
          return discreteUpdatesImpl(fn, a, b, c);
        } finally {
          isInsideEventHandler = prevIsInsideEventHandler;

          if (!isInsideEventHandler) {
            finishEventHandler();
          }
        }
      }

      var lastFlushedEventTimeStamp = 0;

      function flushDiscreteUpdatesIfNeeded(timeStamp) {
        if (!isInsideEventHandler && (!enableFlareAPI || timeStamp === 0 || lastFlushedEventTimeStamp !== timeStamp)) {
          lastFlushedEventTimeStamp = timeStamp;
          flushDiscreteUpdatesImpl();
        }
      }

      function setBatchingImplementation(_batchedUpdatesImpl, _discreteUpdatesImpl, _flushDiscreteUpdatesImpl, _batchedEventUpdatesImpl) {
        batchedUpdatesImpl = _batchedUpdatesImpl;
        discreteUpdatesImpl = _discreteUpdatesImpl;
        flushDiscreteUpdatesImpl = _flushDiscreteUpdatesImpl;
        batchedEventUpdatesImpl = _batchedEventUpdatesImpl;
      }

      function _classCallCheck$1(instance, Constructor) {
        if (!(instance instanceof Constructor)) {
          throw new TypeError("Cannot call a class as a function");
        }
      }

      function _possibleConstructorReturn(self, call) {
        if (!self) {
          throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
        }

        return call && (typeof call === "object" || typeof call === "function") ? call : self;
      }

      function _inherits(subClass, superClass) {
        if (typeof superClass !== "function" && superClass !== null) {
          throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
        }

        subClass.prototype = Object.create(superClass && superClass.prototype, {
          constructor: {
            value: subClass,
            enumerable: false,
            writable: true,
            configurable: true
          }
        });
        if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
      }

      var ReactNativeComponent = function (_React$Component) {
        _inherits(ReactNativeComponent, _React$Component);

        function ReactNativeComponent() {
          _classCallCheck$1(this, ReactNativeComponent);

          return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
        }

        ReactNativeComponent.prototype.blur = function blur() {};

        ReactNativeComponent.prototype.focus = function focus() {};

        ReactNativeComponent.prototype.measure = function measure(callback) {};

        ReactNativeComponent.prototype.measureInWindow = function measureInWindow(callback) {};

        ReactNativeComponent.prototype.measureLayout = function measureLayout(relativeToNativeNode, onSuccess, onFail) {};

        ReactNativeComponent.prototype.setNativeProps = function setNativeProps(nativeProps) {};

        return ReactNativeComponent;
      }(React.Component);

      var DiscreteEvent = 0;
      var UserBlockingEvent = 1;
      var ContinuousEvent = 2;
      var warning = warningWithoutStack$1;
      {
        warning = function warning(condition, format) {
          if (condition) {
            return;
          }

          var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
          var stack = ReactDebugCurrentFrame.getStackAddendum();

          for (var _len = arguments.length, args = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
            args[_key - 2] = arguments[_key];
          }

          warningWithoutStack$1.apply(undefined, [false, format + "%s"].concat(args, [stack]));
        };
      }
      var warning$1 = warning;
      var UserBlockingPriority = Scheduler.unstable_UserBlockingPriority;
      var runWithPriority = Scheduler.unstable_runWithPriority;
      var _nativeFabricUIManage$2 = nativeFabricUIManager;
      var measureInWindow = _nativeFabricUIManage$2.measureInWindow;
      var activeTimeouts = new Map();
      var rootEventTypesToEventResponderInstances = new Map();
      var ownershipChangeListeners = new Set();
      var globalOwner = null;
      var currentTimeStamp = 0;
      var currentTimers = new Map();
      var currentInstance = null;
      var currentEventQueue = null;
      var currentEventQueuePriority = ContinuousEvent;
      var currentTimerIDCounter = 0;
      var eventResponderContext = {
        dispatchEvent: function dispatchEvent(eventValue, eventListener, eventPriority) {
          validateResponderContext();
          validateEventValue(eventValue);

          if (eventPriority < currentEventQueuePriority) {
            currentEventQueuePriority = eventPriority;
          }

          currentEventQueue.push(createEventQueueItem(eventValue, eventListener));
        },
        isTargetWithinNode: function isTargetWithinNode(childTarget, parentTarget) {
          validateResponderContext();
          var childFiber = getFiberFromTarget(childTarget);
          var parentFiber = getFiberFromTarget(parentTarget);
          var node = childFiber;

          while (node !== null) {
            if (node === parentFiber) {
              return true;
            }

            node = node.return;
          }

          return false;
        },
        getTargetBoundingRect: function getTargetBoundingRect(target, callback) {
          measureInWindow(target.node, function (x, y, width, height) {
            callback({
              left: x,
              right: x + width,
              top: y,
              bottom: y + height
            });
          });
        },
        addRootEventTypes: function addRootEventTypes(rootEventTypes) {
          validateResponderContext();

          for (var i = 0; i < rootEventTypes.length; i++) {
            var rootEventType = rootEventTypes[i];
            var eventResponderInstance = currentInstance;
            registerRootEventType(rootEventType, eventResponderInstance);
          }
        },
        removeRootEventTypes: function removeRootEventTypes(rootEventTypes) {
          validateResponderContext();

          for (var i = 0; i < rootEventTypes.length; i++) {
            var rootEventType = rootEventTypes[i];
            var rootEventResponders = rootEventTypesToEventResponderInstances.get(rootEventType);
            var rootEventTypesSet = currentInstance.rootEventTypes;

            if (rootEventTypesSet !== null) {
              rootEventTypesSet.delete(rootEventType);
            }

            if (rootEventResponders !== undefined) {
              rootEventResponders.delete(currentInstance);
            }
          }
        },
        setTimeout: function (_setTimeout) {
          function setTimeout(_x, _x2) {
            return _setTimeout.apply(this, arguments);
          }

          setTimeout.toString = function () {
            return _setTimeout.toString();
          };

          return setTimeout;
        }(function (func, delay) {
          validateResponderContext();

          if (currentTimers === null) {
            currentTimers = new Map();
          }

          var timeout = currentTimers.get(delay);
          var timerId = currentTimerIDCounter++;

          if (timeout === undefined) {
            var _timers = new Map();

            var _id = setTimeout(function () {
              processTimers(_timers, delay);
            }, delay);

            timeout = {
              id: _id,
              timers: _timers
            };
            currentTimers.set(delay, timeout);
          }

          timeout.timers.set(timerId, {
            instance: currentInstance,
            func: func,
            id: timerId,
            timeStamp: currentTimeStamp
          });
          activeTimeouts.set(timerId, timeout);
          return timerId;
        }),
        clearTimeout: function (_clearTimeout) {
          function clearTimeout(_x3) {
            return _clearTimeout.apply(this, arguments);
          }

          clearTimeout.toString = function () {
            return _clearTimeout.toString();
          };

          return clearTimeout;
        }(function (timerId) {
          validateResponderContext();
          var timeout = activeTimeouts.get(timerId);

          if (timeout !== undefined) {
            var _timers2 = timeout.timers;

            _timers2.delete(timerId);

            if (_timers2.size === 0) {
              clearTimeout(timeout.id);
            }
          }
        }),
        getTimeStamp: function getTimeStamp() {
          validateResponderContext();
          return currentTimeStamp;
        }
      };

      function createEventQueueItem(value, listener) {
        return {
          value: value,
          listener: listener
        };
      }

      function validateEventValue(eventValue) {
        if (typeof eventValue === "object" && eventValue !== null) {
          var target = eventValue.target,
              type = eventValue.type,
              _timeStamp = eventValue.timeStamp;

          if (target == null || type == null || _timeStamp == null) {
            throw new Error('context.dispatchEvent: "target", "timeStamp", and "type" fields on event object are required.');
          }

          var showWarning = function showWarning(name) {
            {
              warning$1(false, "%s is not available on event objects created from event responder modules (React Flare). " + 'Try wrapping in a conditional, i.e. `if (event.type !== "press") { event.%s }`', name, name);
            }
          };

          eventValue.preventDefault = function () {
            {
              showWarning("preventDefault()");
            }
          };

          eventValue.stopPropagation = function () {
            {
              showWarning("stopPropagation()");
            }
          };

          eventValue.isDefaultPrevented = function () {
            {
              showWarning("isDefaultPrevented()");
            }
          };

          eventValue.isPropagationStopped = function () {
            {
              showWarning("isPropagationStopped()");
            }
          };

          Object.defineProperty(eventValue, "nativeEvent", {
            get: function get() {
              {
                showWarning("nativeEvent");
              }
            }
          });
        }
      }

      function getFiberFromTarget(target) {
        if (target === null) {
          return null;
        }

        return target.canonical._internalInstanceHandle || null;
      }

      function processTimers(timers, delay) {
        var timersArr = Array.from(timers.values());
        currentEventQueuePriority = ContinuousEvent;

        try {
          for (var i = 0; i < timersArr.length; i++) {
            var _timersArr$i = timersArr[i],
                _instance = _timersArr$i.instance,
                _func = _timersArr$i.func,
                _id2 = _timersArr$i.id,
                _timeStamp2 = _timersArr$i.timeStamp;
            currentInstance = _instance;
            currentEventQueue = [];
            currentTimeStamp = _timeStamp2 + delay;

            try {
              _func();
            } finally {
              activeTimeouts.delete(_id2);
            }
          }

          processEventQueue();
        } finally {
          currentTimers = null;
          currentInstance = null;
          currentEventQueue = null;
          currentTimeStamp = 0;
        }
      }

      function createFabricResponderEvent(topLevelType, nativeEvent, target) {
        return {
          nativeEvent: nativeEvent,
          responderTarget: target,
          target: target,
          type: topLevelType
        };
      }

      function validateResponderContext() {
        (function () {
          if (!(currentEventQueue && currentInstance)) {
            throw ReactError(Error("An event responder context was used outside of an event cycle. Use context.setTimeout() to use asynchronous responder context outside of event cycle ."));
          }
        })();
      }

      function processEventQueue() {
        var eventQueue = currentEventQueue;

        if (eventQueue.length === 0) {
          return;
        }

        switch (currentEventQueuePriority) {
          case DiscreteEvent:
            {
              flushDiscreteUpdatesIfNeeded(currentTimeStamp);
              discreteUpdates(function () {
                batchedEventUpdates(processEvents, eventQueue);
              });
              break;
            }

          case UserBlockingEvent:
            {
              if (enableUserBlockingEvents) {
                runWithPriority(UserBlockingPriority, batchedEventUpdates.bind(null, processEvents, eventQueue));
              } else {
                batchedEventUpdates(processEvents, eventQueue);
              }

              break;
            }

          case ContinuousEvent:
            {
              batchedEventUpdates(processEvents, eventQueue);
              break;
            }
        }
      }

      function releaseOwnershipForEventResponderInstance(eventResponderInstance) {
        if (globalOwner === eventResponderInstance) {
          globalOwner = null;
          triggerOwnershipListeners();
          return true;
        }

        return false;
      }

      function processEvents(eventQueue) {
        for (var i = 0, length = eventQueue.length; i < length; i++) {
          var _eventQueue$i = eventQueue[i],
              _value = _eventQueue$i.value,
              _listener = _eventQueue$i.listener;
          var type = typeof _value === "object" && _value !== null ? _value.type : "";
          invokeGuardedCallbackAndCatchFirstError(type, _listener, undefined, _value);
        }
      }

      function responderEventTypesContainType(eventTypes, type) {
        for (var i = 0, len = eventTypes.length; i < len; i++) {
          if (eventTypes[i] === type) {
            return true;
          }
        }

        return false;
      }

      function validateResponderTargetEventTypes(eventType, responder) {
        var targetEventTypes = responder.targetEventTypes;

        if (targetEventTypes !== null) {
          return responderEventTypesContainType(targetEventTypes, eventType);
        }

        return false;
      }

      function validateOwnership(responderInstance) {
        return globalOwner === null || globalOwner === responderInstance;
      }

      function traverseAndHandleEventResponderInstances(eventType, targetFiber, nativeEvent) {
        var responderEvent = createFabricResponderEvent(eventType, nativeEvent, targetFiber !== null ? targetFiber.stateNode : null);
        var visitedResponders = new Set();
        var node = targetFiber;

        while (node !== null) {
          var _node = node,
              dependencies = _node.dependencies,
              tag = _node.tag;

          if (tag === HostComponent && dependencies !== null) {
            var respondersMap = dependencies.responders;

            if (respondersMap !== null) {
              var responderInstances = Array.from(respondersMap.values());

              for (var i = 0, length = responderInstances.length; i < length; i++) {
                var responderInstance = responderInstances[i];

                if (validateOwnership(responderInstance)) {
                  var props = responderInstance.props,
                      responder = responderInstance.responder,
                      state = responderInstance.state,
                      target = responderInstance.target;

                  if (!visitedResponders.has(responder) && validateResponderTargetEventTypes(eventType, responder)) {
                    var onEvent = responder.onEvent;
                    visitedResponders.add(responder);

                    if (onEvent !== null) {
                      currentInstance = responderInstance;
                      responderEvent.responderTarget = target;
                      onEvent(responderEvent, eventResponderContext, props, state);
                    }
                  }
                }
              }
            }
          }

          node = node.return;
        }

        var rootEventResponderInstances = rootEventTypesToEventResponderInstances.get(eventType);

        if (rootEventResponderInstances !== undefined) {
          var _responderInstances = Array.from(rootEventResponderInstances);

          for (var _i = 0; _i < _responderInstances.length; _i++) {
            var _responderInstance = _responderInstances[_i];

            if (!validateOwnership(_responderInstance)) {
              continue;
            }

            var _props = _responderInstance.props,
                _responder = _responderInstance.responder,
                _state = _responderInstance.state,
                _target = _responderInstance.target;
            var onRootEvent = _responder.onRootEvent;

            if (onRootEvent !== null) {
              currentInstance = _responderInstance;
              responderEvent.responderTarget = _target;
              onRootEvent(responderEvent, eventResponderContext, _props, _state);
            }
          }
        }
      }

      function dispatchEventForResponderEventSystem(topLevelType, targetFiber, nativeEvent) {
        var previousEventQueue = currentEventQueue;
        var previousInstance = currentInstance;
        var previousTimers = currentTimers;
        var previousTimeStamp = currentTimeStamp;
        var previousEventQueuePriority = currentEventQueuePriority;
        currentTimers = null;
        currentEventQueue = [];
        currentEventQueuePriority = ContinuousEvent;
        currentTimeStamp = Date.now();

        try {
          traverseAndHandleEventResponderInstances(topLevelType, targetFiber, nativeEvent);
          processEventQueue();
        } finally {
          currentTimers = previousTimers;
          currentInstance = previousInstance;
          currentEventQueue = previousEventQueue;
          currentTimeStamp = previousTimeStamp;
          currentEventQueuePriority = previousEventQueuePriority;
        }
      }

      function triggerOwnershipListeners() {
        var listeningInstances = Array.from(ownershipChangeListeners);
        var previousInstance = currentInstance;
        var previousEventQueuePriority = currentEventQueuePriority;
        var previousEventQueue = currentEventQueue;

        try {
          for (var i = 0; i < listeningInstances.length; i++) {
            var _instance2 = listeningInstances[i];
            var props = _instance2.props,
                responder = _instance2.responder,
                state = _instance2.state;
            currentInstance = _instance2;
            currentEventQueuePriority = ContinuousEvent;
            currentEventQueue = [];
            var onOwnershipChange = responder.onOwnershipChange;

            if (onOwnershipChange !== null) {
              onOwnershipChange(eventResponderContext, props, state);
            }
          }

          processEventQueue();
        } finally {
          currentInstance = previousInstance;
          currentEventQueue = previousEventQueue;
          currentEventQueuePriority = previousEventQueuePriority;
        }
      }

      function mountEventResponder(responder, responderInstance, props, state) {
        if (responder.onOwnershipChange !== null) {
          ownershipChangeListeners.add(responderInstance);
        }

        var onMount = responder.onMount;

        if (onMount !== null) {
          currentEventQueuePriority = ContinuousEvent;
          currentInstance = responderInstance;
          currentEventQueue = [];

          try {
            onMount(eventResponderContext, props, state);
            processEventQueue();
          } finally {
            currentEventQueue = null;
            currentInstance = null;
            currentTimers = null;
          }
        }
      }

      function unmountEventResponder(responderInstance) {
        var responder = responderInstance.responder;
        var onUnmount = responder.onUnmount;

        if (onUnmount !== null) {
          var props = responderInstance.props,
              state = responderInstance.state;
          currentEventQueue = [];
          currentEventQueuePriority = ContinuousEvent;
          currentInstance = responderInstance;

          try {
            onUnmount(eventResponderContext, props, state);
            processEventQueue();
          } finally {
            currentEventQueue = null;
            currentInstance = null;
            currentTimers = null;
          }
        }

        releaseOwnershipForEventResponderInstance(responderInstance);

        if (responder.onOwnershipChange !== null) {
          ownershipChangeListeners.delete(responderInstance);
        }

        var rootEventTypesSet = responderInstance.rootEventTypes;

        if (rootEventTypesSet !== null) {
          var rootEventTypes = Array.from(rootEventTypesSet);

          for (var i = 0; i < rootEventTypes.length; i++) {
            var topLevelEventType = rootEventTypes[i];
            var rootEventResponderInstances = rootEventTypesToEventResponderInstances.get(topLevelEventType);

            if (rootEventResponderInstances !== undefined) {
              rootEventResponderInstances.delete(responderInstance);
            }
          }
        }
      }

      function registerRootEventType(rootEventType, responderInstance) {
        var rootEventResponderInstances = rootEventTypesToEventResponderInstances.get(rootEventType);

        if (rootEventResponderInstances === undefined) {
          rootEventResponderInstances = new Set();
          rootEventTypesToEventResponderInstances.set(rootEventType, rootEventResponderInstances);
        }

        var rootEventTypesSet = responderInstance.rootEventTypes;

        if (rootEventTypesSet === null) {
          rootEventTypesSet = responderInstance.rootEventTypes = new Set();
        }

        (function () {
          if (!!rootEventTypesSet.has(rootEventType)) {
            throw ReactError(Error('addRootEventTypes() found a duplicate root event type of "' + rootEventType + '". This might be because the event type exists in the event responder "rootEventTypes" array or because of a previous addRootEventTypes() using this root event type.'));
          }
        })();

        rootEventTypesSet.add(rootEventType);
        rootEventResponderInstances.add(responderInstance);
      }

      function addRootEventTypesForResponderInstance(responderInstance, rootEventTypes) {
        for (var i = 0; i < rootEventTypes.length; i++) {
          var rootEventType = rootEventTypes[i];
          registerRootEventType(rootEventType, responderInstance);
        }
      }

      function dispatchEvent(target, topLevelType, nativeEvent) {
        var targetFiber = target;

        if (enableFlareAPI) {
          dispatchEventForResponderEventSystem(topLevelType, target, nativeEvent);
        }

        batchedUpdates(function () {
          runExtractedPluginEventsInBatch(topLevelType, targetFiber, nativeEvent, nativeEvent.target);
        });
      }

      function shim() {
        (function () {
          {
            throw ReactError(Error("The current renderer does not support mutation. This error is likely caused by a bug in React. Please file an issue."));
          }
        })();
      }

      var supportsMutation = false;
      var appendChild = shim;
      var appendChildToContainer = shim;
      var commitTextUpdate = shim;
      var commitMount = shim;
      var commitUpdate = shim;
      var insertBefore = shim;
      var insertInContainerBefore = shim;
      var removeChild = shim;
      var removeChildFromContainer = shim;
      var resetTextContent = shim;
      var hideInstance = shim;
      var hideTextInstance = shim;
      var unhideInstance = shim;
      var unhideTextInstance = shim;

      function shim$1() {
        (function () {
          {
            throw ReactError(Error("The current renderer does not support hydration. This error is likely caused by a bug in React. Please file an issue."));
          }
        })();
      }

      var supportsHydration = false;
      var canHydrateInstance = shim$1;
      var canHydrateTextInstance = shim$1;
      var canHydrateSuspenseInstance = shim$1;
      var isSuspenseInstancePending = shim$1;
      var isSuspenseInstanceFallback = shim$1;
      var registerSuspenseInstanceRetry = shim$1;
      var getNextHydratableSibling = shim$1;
      var getFirstHydratableChild = shim$1;
      var hydrateInstance = shim$1;
      var hydrateTextInstance = shim$1;
      var getNextHydratableInstanceAfterSuspenseInstance = shim$1;
      var clearSuspenseBoundary = shim$1;
      var clearSuspenseBoundaryFromContainer = shim$1;
      var didNotMatchHydratedContainerTextInstance = shim$1;
      var didNotMatchHydratedTextInstance = shim$1;
      var didNotHydrateContainerInstance = shim$1;
      var didNotHydrateInstance = shim$1;
      var didNotFindHydratableContainerInstance = shim$1;
      var didNotFindHydratableContainerTextInstance = shim$1;
      var didNotFindHydratableContainerSuspenseInstance = shim$1;
      var didNotFindHydratableInstance = shim$1;
      var didNotFindHydratableTextInstance = shim$1;
      var didNotFindHydratableSuspenseInstance = shim$1;

      function _classCallCheck(instance, Constructor) {
        if (!(instance instanceof Constructor)) {
          throw new TypeError("Cannot call a class as a function");
        }
      }

      var _nativeFabricUIManage$1 = nativeFabricUIManager;
      var createNode = _nativeFabricUIManage$1.createNode;
      var cloneNode = _nativeFabricUIManage$1.cloneNode;
      var cloneNodeWithNewChildren = _nativeFabricUIManage$1.cloneNodeWithNewChildren;
      var cloneNodeWithNewChildrenAndProps = _nativeFabricUIManage$1.cloneNodeWithNewChildrenAndProps;
      var cloneNodeWithNewProps = _nativeFabricUIManage$1.cloneNodeWithNewProps;
      var createChildNodeSet = _nativeFabricUIManage$1.createChildSet;
      var appendChildNode = _nativeFabricUIManage$1.appendChild;
      var appendChildNodeToSet = _nativeFabricUIManage$1.appendChildToSet;
      var completeRoot = _nativeFabricUIManage$1.completeRoot;
      var registerEventHandler = _nativeFabricUIManage$1.registerEventHandler;
      var fabricMeasure = _nativeFabricUIManage$1.measure;
      var fabricMeasureInWindow = _nativeFabricUIManage$1.measureInWindow;
      var fabricMeasureLayout = _nativeFabricUIManage$1.measureLayout;
      var getViewConfigForType = ReactNativePrivateInterface.ReactNativeViewConfigRegistry.get;
      var nextReactTag = 2;

      if (registerEventHandler) {
        registerEventHandler(dispatchEvent);
      }

      var ReactFabricHostComponent = function () {
        function ReactFabricHostComponent(tag, viewConfig, props, internalInstanceHandle) {
          _classCallCheck(this, ReactFabricHostComponent);

          this._nativeTag = tag;
          this.viewConfig = viewConfig;
          this.currentProps = props;
          this._internalInstanceHandle = internalInstanceHandle;
        }

        ReactFabricHostComponent.prototype.blur = function blur() {
          ReactNativePrivateInterface.TextInputState.blurTextInput(this._nativeTag);
        };

        ReactFabricHostComponent.prototype.focus = function focus() {
          ReactNativePrivateInterface.TextInputState.focusTextInput(this._nativeTag);
        };

        ReactFabricHostComponent.prototype.measure = function measure(callback) {
          fabricMeasure(this._internalInstanceHandle.stateNode.node, mountSafeCallback_NOT_REALLY_SAFE(this, callback));
        };

        ReactFabricHostComponent.prototype.measureInWindow = function measureInWindow(callback) {
          fabricMeasureInWindow(this._internalInstanceHandle.stateNode.node, mountSafeCallback_NOT_REALLY_SAFE(this, callback));
        };

        ReactFabricHostComponent.prototype.measureLayout = function measureLayout(relativeToNativeNode, onSuccess, onFail) {
          if (typeof relativeToNativeNode === "number" || !(relativeToNativeNode instanceof ReactFabricHostComponent)) {
            warningWithoutStack$1(false, "Warning: ref.measureLayout must be called with a ref to a native component.");
            return;
          }

          fabricMeasureLayout(this._internalInstanceHandle.stateNode.node, relativeToNativeNode._internalInstanceHandle.stateNode.node, mountSafeCallback_NOT_REALLY_SAFE(this, onFail), mountSafeCallback_NOT_REALLY_SAFE(this, onSuccess));
        };

        ReactFabricHostComponent.prototype.setNativeProps = function setNativeProps(nativeProps) {
          warningWithoutStack$1(false, "Warning: setNativeProps is not currently supported in Fabric");
          return;
        };

        return ReactFabricHostComponent;
      }();

      function appendInitialChild(parentInstance, child) {
        appendChildNode(parentInstance.node, child.node);
      }

      function createInstance(type, props, rootContainerInstance, hostContext, internalInstanceHandle) {
        var tag = nextReactTag;
        nextReactTag += 2;
        var viewConfig = getViewConfigForType(type);
        {
          for (var key in viewConfig.validAttributes) {
            if (props.hasOwnProperty(key)) {
              ReactNativePrivateInterface.deepFreezeAndThrowOnMutationInDev(props[key]);
            }
          }
        }
        var updatePayload = create(props, viewConfig.validAttributes);
        var node = createNode(tag, viewConfig.uiViewClassName, rootContainerInstance, updatePayload, internalInstanceHandle);
        var component = new ReactFabricHostComponent(tag, viewConfig, props, internalInstanceHandle);
        return {
          node: node,
          canonical: component
        };
      }

      function createTextInstance(text, rootContainerInstance, hostContext, internalInstanceHandle) {
        (function () {
          if (!hostContext.isInAParentText) {
            throw ReactError(Error("Text strings must be rendered within a <Text> component."));
          }
        })();

        var tag = nextReactTag;
        nextReactTag += 2;
        var node = createNode(tag, "RCTRawText", rootContainerInstance, {
          text: text
        }, internalInstanceHandle);
        return {
          node: node
        };
      }

      function finalizeInitialChildren(parentInstance, type, props, rootContainerInstance, hostContext) {
        return false;
      }

      function getRootHostContext(rootContainerInstance) {
        return {
          isInAParentText: false
        };
      }

      function getChildHostContext(parentHostContext, type, rootContainerInstance) {
        var prevIsInAParentText = parentHostContext.isInAParentText;
        var isInAParentText = type === "AndroidTextInput" || type === "RCTMultilineTextInputView" || type === "RCTSinglelineTextInputView" || type === "RCTText" || type === "RCTVirtualText";

        if (prevIsInAParentText !== isInAParentText) {
          return {
            isInAParentText: isInAParentText
          };
        } else {
          return parentHostContext;
        }
      }

      function getPublicInstance(instance) {
        return instance.canonical;
      }

      function prepareForCommit(containerInfo) {}

      function prepareUpdate(instance, type, oldProps, newProps, rootContainerInstance, hostContext) {
        var viewConfig = instance.canonical.viewConfig;
        var updatePayload = diff(oldProps, newProps, viewConfig.validAttributes);
        instance.canonical.currentProps = newProps;
        return updatePayload;
      }

      function resetAfterCommit(containerInfo) {}

      function shouldDeprioritizeSubtree(type, props) {
        return false;
      }

      function shouldSetTextContent(type, props) {
        return false;
      }

      var isPrimaryRenderer = false;
      var warnsIfNotActing = false;
      var scheduleTimeout = setTimeout;
      var cancelTimeout = clearTimeout;
      var noTimeout = -1;
      var supportsPersistence = true;

      function cloneInstance(instance, updatePayload, type, oldProps, newProps, internalInstanceHandle, keepChildren, recyclableInstance) {
        var node = instance.node;
        var clone = void 0;

        if (keepChildren) {
          if (updatePayload !== null) {
            clone = cloneNodeWithNewProps(node, updatePayload);
          } else {
            clone = cloneNode(node);
          }
        } else {
          if (updatePayload !== null) {
            clone = cloneNodeWithNewChildrenAndProps(node, updatePayload);
          } else {
            clone = cloneNodeWithNewChildren(node);
          }
        }

        return {
          node: clone,
          canonical: instance.canonical
        };
      }

      function cloneHiddenInstance(instance, type, props, internalInstanceHandle) {
        var viewConfig = instance.canonical.viewConfig;
        var node = instance.node;
        var updatePayload = create({
          style: {
            display: "none"
          }
        }, viewConfig.validAttributes);
        return {
          node: cloneNodeWithNewProps(node, updatePayload),
          canonical: instance.canonical
        };
      }

      function cloneHiddenTextInstance(instance, text, internalInstanceHandle) {
        throw new Error("Not yet implemented.");
      }

      function createContainerChildSet(container) {
        return createChildNodeSet(container);
      }

      function appendChildToContainerChildSet(childSet, child) {
        appendChildNodeToSet(childSet, child.node);
      }

      function finalizeContainerChildren(container, newChildren) {
        completeRoot(container, newChildren);
      }

      function mountResponderInstance(responder, responderInstance, props, state, instance, rootContainerInstance) {
        if (enableFlareAPI) {
          var rootEventTypes = responder.rootEventTypes;

          if (rootEventTypes !== null) {
            addRootEventTypesForResponderInstance(responderInstance, rootEventTypes);
          }

          mountEventResponder(responder, responderInstance, props, state);
        }
      }

      function unmountResponderInstance(responderInstance) {
        if (enableFlareAPI) {
          unmountEventResponder(responderInstance);
        }
      }

      function getFundamentalComponentInstance(fundamentalInstance) {
        throw new Error("Not yet implemented.");
      }

      function mountFundamentalComponent(fundamentalInstance) {
        throw new Error("Not yet implemented.");
      }

      function shouldUpdateFundamentalComponent(fundamentalInstance) {
        throw new Error("Not yet implemented.");
      }

      function updateFundamentalComponent(fundamentalInstance) {
        throw new Error("Not yet implemented.");
      }

      function unmountFundamentalComponent(fundamentalInstance) {
        throw new Error("Not yet implemented.");
      }

      function cloneFundamentalInstance(fundamentalInstance) {
        throw new Error("Not yet implemented.");
      }

      var BEFORE_SLASH_RE = /^(.*)[\\\/]/;

      var describeComponentFrame = function describeComponentFrame(name, source, ownerName) {
        var sourceInfo = "";

        if (source) {
          var path = source.fileName;
          var fileName = path.replace(BEFORE_SLASH_RE, "");
          {
            if (/^index\./.test(fileName)) {
              var match = path.match(BEFORE_SLASH_RE);

              if (match) {
                var pathBeforeSlash = match[1];

                if (pathBeforeSlash) {
                  var folderName = pathBeforeSlash.replace(BEFORE_SLASH_RE, "");
                  fileName = folderName + "/" + fileName;
                }
              }
            }
          }
          sourceInfo = " (at " + fileName + ":" + source.lineNumber + ")";
        } else if (ownerName) {
          sourceInfo = " (created by " + ownerName + ")";
        }

        return "\n    in " + (name || "Unknown") + sourceInfo;
      };

      var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;

      function describeFiber(fiber) {
        switch (fiber.tag) {
          case HostRoot:
          case HostPortal:
          case HostText:
          case Fragment:
          case ContextProvider:
          case ContextConsumer:
            return "";

          default:
            var owner = fiber._debugOwner;
            var source = fiber._debugSource;
            var name = getComponentName(fiber.type);
            var ownerName = null;

            if (owner) {
              ownerName = getComponentName(owner.type);
            }

            return describeComponentFrame(name, source, ownerName);
        }
      }

      function getStackByFiberInDevAndProd(workInProgress) {
        var info = "";
        var node = workInProgress;

        do {
          info += describeFiber(node);
          node = node.return;
        } while (node);

        return info;
      }

      var current = null;
      var phase = null;

      function getCurrentFiberOwnerNameInDevOrNull() {
        {
          if (current === null) {
            return null;
          }

          var owner = current._debugOwner;

          if (owner !== null && typeof owner !== "undefined") {
            return getComponentName(owner.type);
          }
        }
        return null;
      }

      function getCurrentFiberStackInDev() {
        {
          if (current === null) {
            return "";
          }

          return getStackByFiberInDevAndProd(current);
        }
        return "";
      }

      function resetCurrentFiber() {
        {
          ReactDebugCurrentFrame.getCurrentStack = null;
          current = null;
          phase = null;
        }
      }

      function setCurrentFiber(fiber) {
        {
          ReactDebugCurrentFrame.getCurrentStack = getCurrentFiberStackInDev;
          current = fiber;
          phase = null;
        }
      }

      function setCurrentPhase(lifeCyclePhase) {
        {
          phase = lifeCyclePhase;
        }
      }

      var reactEmoji = "\u269B";
      var warningEmoji = "\u26D4";
      var supportsUserTiming = typeof performance !== "undefined" && typeof performance.mark === "function" && typeof performance.clearMarks === "function" && typeof performance.measure === "function" && typeof performance.clearMeasures === "function";
      var currentFiber = null;
      var currentPhase = null;
      var currentPhaseFiber = null;
      var isCommitting = false;
      var hasScheduledUpdateInCurrentCommit = false;
      var hasScheduledUpdateInCurrentPhase = false;
      var commitCountInCurrentWorkLoop = 0;
      var effectCountInCurrentCommit = 0;
      var isWaitingForCallback = false;
      var labelsInCurrentCommit = new Set();

      var formatMarkName = function formatMarkName(markName) {
        return reactEmoji + " " + markName;
      };

      var formatLabel = function formatLabel(label, warning) {
        var prefix = warning ? warningEmoji + " " : reactEmoji + " ";
        var suffix = warning ? " Warning: " + warning : "";
        return "" + prefix + label + suffix;
      };

      var beginMark = function beginMark(markName) {
        performance.mark(formatMarkName(markName));
      };

      var clearMark = function clearMark(markName) {
        performance.clearMarks(formatMarkName(markName));
      };

      var endMark = function endMark(label, markName, warning) {
        var formattedMarkName = formatMarkName(markName);
        var formattedLabel = formatLabel(label, warning);

        try {
          performance.measure(formattedLabel, formattedMarkName);
        } catch (err) {}

        performance.clearMarks(formattedMarkName);
        performance.clearMeasures(formattedLabel);
      };

      var getFiberMarkName = function getFiberMarkName(label, debugID) {
        return label + " (#" + debugID + ")";
      };

      var getFiberLabel = function getFiberLabel(componentName, isMounted, phase) {
        if (phase === null) {
          return componentName + " [" + (isMounted ? "update" : "mount") + "]";
        } else {
          return componentName + "." + phase;
        }
      };

      var beginFiberMark = function beginFiberMark(fiber, phase) {
        var componentName = getComponentName(fiber.type) || "Unknown";
        var debugID = fiber._debugID;
        var isMounted = fiber.alternate !== null;
        var label = getFiberLabel(componentName, isMounted, phase);

        if (isCommitting && labelsInCurrentCommit.has(label)) {
          return false;
        }

        labelsInCurrentCommit.add(label);
        var markName = getFiberMarkName(label, debugID);
        beginMark(markName);
        return true;
      };

      var clearFiberMark = function clearFiberMark(fiber, phase) {
        var componentName = getComponentName(fiber.type) || "Unknown";
        var debugID = fiber._debugID;
        var isMounted = fiber.alternate !== null;
        var label = getFiberLabel(componentName, isMounted, phase);
        var markName = getFiberMarkName(label, debugID);
        clearMark(markName);
      };

      var endFiberMark = function endFiberMark(fiber, phase, warning) {
        var componentName = getComponentName(fiber.type) || "Unknown";
        var debugID = fiber._debugID;
        var isMounted = fiber.alternate !== null;
        var label = getFiberLabel(componentName, isMounted, phase);
        var markName = getFiberMarkName(label, debugID);
        endMark(label, markName, warning);
      };

      var shouldIgnoreFiber = function shouldIgnoreFiber(fiber) {
        switch (fiber.tag) {
          case HostRoot:
          case HostComponent:
          case HostText:
          case HostPortal:
          case Fragment:
          case ContextProvider:
          case ContextConsumer:
          case Mode:
            return true;

          default:
            return false;
        }
      };

      var clearPendingPhaseMeasurement = function clearPendingPhaseMeasurement() {
        if (currentPhase !== null && currentPhaseFiber !== null) {
          clearFiberMark(currentPhaseFiber, currentPhase);
        }

        currentPhaseFiber = null;
        currentPhase = null;
        hasScheduledUpdateInCurrentPhase = false;
      };

      var pauseTimers = function pauseTimers() {
        var fiber = currentFiber;

        while (fiber) {
          if (fiber._debugIsCurrentlyTiming) {
            endFiberMark(fiber, null, null);
          }

          fiber = fiber.return;
        }
      };

      var resumeTimersRecursively = function resumeTimersRecursively(fiber) {
        if (fiber.return !== null) {
          resumeTimersRecursively(fiber.return);
        }

        if (fiber._debugIsCurrentlyTiming) {
          beginFiberMark(fiber, null);
        }
      };

      var resumeTimers = function resumeTimers() {
        if (currentFiber !== null) {
          resumeTimersRecursively(currentFiber);
        }
      };

      function recordEffect() {
        if (enableUserTimingAPI) {
          effectCountInCurrentCommit++;
        }
      }

      function recordScheduleUpdate() {
        if (enableUserTimingAPI) {
          if (isCommitting) {
            hasScheduledUpdateInCurrentCommit = true;
          }

          if (currentPhase !== null && currentPhase !== "componentWillMount" && currentPhase !== "componentWillReceiveProps") {
            hasScheduledUpdateInCurrentPhase = true;
          }
        }
      }

      function startRequestCallbackTimer() {
        if (enableUserTimingAPI) {
          if (supportsUserTiming && !isWaitingForCallback) {
            isWaitingForCallback = true;
            beginMark("(Waiting for async callback...)");
          }
        }
      }

      function stopRequestCallbackTimer(didExpire) {
        if (enableUserTimingAPI) {
          if (supportsUserTiming) {
            isWaitingForCallback = false;
            var warning = didExpire ? "Update expired; will flush synchronously" : null;
            endMark("(Waiting for async callback...)", "(Waiting for async callback...)", warning);
          }
        }
      }

      function startWorkTimer(fiber) {
        if (enableUserTimingAPI) {
          if (!supportsUserTiming || shouldIgnoreFiber(fiber)) {
            return;
          }

          currentFiber = fiber;

          if (!beginFiberMark(fiber, null)) {
            return;
          }

          fiber._debugIsCurrentlyTiming = true;
        }
      }

      function cancelWorkTimer(fiber) {
        if (enableUserTimingAPI) {
          if (!supportsUserTiming || shouldIgnoreFiber(fiber)) {
            return;
          }

          fiber._debugIsCurrentlyTiming = false;
          clearFiberMark(fiber, null);
        }
      }

      function stopWorkTimer(fiber) {
        if (enableUserTimingAPI) {
          if (!supportsUserTiming || shouldIgnoreFiber(fiber)) {
            return;
          }

          currentFiber = fiber.return;

          if (!fiber._debugIsCurrentlyTiming) {
            return;
          }

          fiber._debugIsCurrentlyTiming = false;
          endFiberMark(fiber, null, null);
        }
      }

      function stopFailedWorkTimer(fiber) {
        if (enableUserTimingAPI) {
          if (!supportsUserTiming || shouldIgnoreFiber(fiber)) {
            return;
          }

          currentFiber = fiber.return;

          if (!fiber._debugIsCurrentlyTiming) {
            return;
          }

          fiber._debugIsCurrentlyTiming = false;
          var warning = fiber.tag === SuspenseComponent || fiber.tag === DehydratedSuspenseComponent ? "Rendering was suspended" : "An error was thrown inside this error boundary";
          endFiberMark(fiber, null, warning);
        }
      }

      function startPhaseTimer(fiber, phase) {
        if (enableUserTimingAPI) {
          if (!supportsUserTiming) {
            return;
          }

          clearPendingPhaseMeasurement();

          if (!beginFiberMark(fiber, phase)) {
            return;
          }

          currentPhaseFiber = fiber;
          currentPhase = phase;
        }
      }

      function stopPhaseTimer() {
        if (enableUserTimingAPI) {
          if (!supportsUserTiming) {
            return;
          }

          if (currentPhase !== null && currentPhaseFiber !== null) {
            var warning = hasScheduledUpdateInCurrentPhase ? "Scheduled a cascading update" : null;
            endFiberMark(currentPhaseFiber, currentPhase, warning);
          }

          currentPhase = null;
          currentPhaseFiber = null;
        }
      }

      function startWorkLoopTimer(nextUnitOfWork) {
        if (enableUserTimingAPI) {
          currentFiber = nextUnitOfWork;

          if (!supportsUserTiming) {
            return;
          }

          commitCountInCurrentWorkLoop = 0;
          beginMark("(React Tree Reconciliation)");
          resumeTimers();
        }
      }

      function stopWorkLoopTimer(interruptedBy, didCompleteRoot) {
        if (enableUserTimingAPI) {
          if (!supportsUserTiming) {
            return;
          }

          var warning = null;

          if (interruptedBy !== null) {
            if (interruptedBy.tag === HostRoot) {
              warning = "A top-level update interrupted the previous render";
            } else {
              var componentName = getComponentName(interruptedBy.type) || "Unknown";
              warning = "An update to " + componentName + " interrupted the previous render";
            }
          } else if (commitCountInCurrentWorkLoop > 1) {
            warning = "There were cascading updates";
          }

          commitCountInCurrentWorkLoop = 0;
          var label = didCompleteRoot ? "(React Tree Reconciliation: Completed Root)" : "(React Tree Reconciliation: Yielded)";
          pauseTimers();
          endMark(label, "(React Tree Reconciliation)", warning);
        }
      }

      function startCommitTimer() {
        if (enableUserTimingAPI) {
          if (!supportsUserTiming) {
            return;
          }

          isCommitting = true;
          hasScheduledUpdateInCurrentCommit = false;
          labelsInCurrentCommit.clear();
          beginMark("(Committing Changes)");
        }
      }

      function stopCommitTimer() {
        if (enableUserTimingAPI) {
          if (!supportsUserTiming) {
            return;
          }

          var warning = null;

          if (hasScheduledUpdateInCurrentCommit) {
            warning = "Lifecycle hook scheduled a cascading update";
          } else if (commitCountInCurrentWorkLoop > 0) {
            warning = "Caused by a cascading update in earlier commit";
          }

          hasScheduledUpdateInCurrentCommit = false;
          commitCountInCurrentWorkLoop++;
          isCommitting = false;
          labelsInCurrentCommit.clear();
          endMark("(Committing Changes)", "(Committing Changes)", warning);
        }
      }

      function startCommitSnapshotEffectsTimer() {
        if (enableUserTimingAPI) {
          if (!supportsUserTiming) {
            return;
          }

          effectCountInCurrentCommit = 0;
          beginMark("(Committing Snapshot Effects)");
        }
      }

      function stopCommitSnapshotEffectsTimer() {
        if (enableUserTimingAPI) {
          if (!supportsUserTiming) {
            return;
          }

          var count = effectCountInCurrentCommit;
          effectCountInCurrentCommit = 0;
          endMark("(Committing Snapshot Effects: " + count + " Total)", "(Committing Snapshot Effects)", null);
        }
      }

      function startCommitHostEffectsTimer() {
        if (enableUserTimingAPI) {
          if (!supportsUserTiming) {
            return;
          }

          effectCountInCurrentCommit = 0;
          beginMark("(Committing Host Effects)");
        }
      }

      function stopCommitHostEffectsTimer() {
        if (enableUserTimingAPI) {
          if (!supportsUserTiming) {
            return;
          }

          var count = effectCountInCurrentCommit;
          effectCountInCurrentCommit = 0;
          endMark("(Committing Host Effects: " + count + " Total)", "(Committing Host Effects)", null);
        }
      }

      function startCommitLifeCyclesTimer() {
        if (enableUserTimingAPI) {
          if (!supportsUserTiming) {
            return;
          }

          effectCountInCurrentCommit = 0;
          beginMark("(Calling Lifecycle Methods)");
        }
      }

      function stopCommitLifeCyclesTimer() {
        if (enableUserTimingAPI) {
          if (!supportsUserTiming) {
            return;
          }

          var count = effectCountInCurrentCommit;
          effectCountInCurrentCommit = 0;
          endMark("(Calling Lifecycle Methods: " + count + " Total)", "(Calling Lifecycle Methods)", null);
        }
      }

      var valueStack = [];
      var fiberStack = void 0;
      {
        fiberStack = [];
      }
      var index = -1;

      function createCursor(defaultValue) {
        return {
          current: defaultValue
        };
      }

      function pop(cursor, fiber) {
        if (index < 0) {
          {
            warningWithoutStack$1(false, "Unexpected pop.");
          }
          return;
        }

        {
          if (fiber !== fiberStack[index]) {
            warningWithoutStack$1(false, "Unexpected Fiber popped.");
          }
        }
        cursor.current = valueStack[index];
        valueStack[index] = null;
        {
          fiberStack[index] = null;
        }
        index--;
      }

      function push(cursor, value, fiber) {
        index++;
        valueStack[index] = cursor.current;
        {
          fiberStack[index] = fiber;
        }
        cursor.current = value;
      }

      var warnedAboutMissingGetChildContext = void 0;
      {
        warnedAboutMissingGetChildContext = {};
      }
      var emptyContextObject = {};
      {
        Object.freeze(emptyContextObject);
      }
      var contextStackCursor = createCursor(emptyContextObject);
      var didPerformWorkStackCursor = createCursor(false);
      var previousContext = emptyContextObject;

      function getUnmaskedContext(workInProgress, Component, didPushOwnContextIfProvider) {
        if (disableLegacyContext) {
          return emptyContextObject;
        } else {
          if (didPushOwnContextIfProvider && isContextProvider(Component)) {
            return previousContext;
          }

          return contextStackCursor.current;
        }
      }

      function cacheContext(workInProgress, unmaskedContext, maskedContext) {
        if (disableLegacyContext) {
          return;
        } else {
          var instance = workInProgress.stateNode;
          instance.__reactInternalMemoizedUnmaskedChildContext = unmaskedContext;
          instance.__reactInternalMemoizedMaskedChildContext = maskedContext;
        }
      }

      function getMaskedContext(workInProgress, unmaskedContext) {
        if (disableLegacyContext) {
          return emptyContextObject;
        } else {
          var type = workInProgress.type;
          var contextTypes = type.contextTypes;

          if (!contextTypes) {
            return emptyContextObject;
          }

          var instance = workInProgress.stateNode;

          if (instance && instance.__reactInternalMemoizedUnmaskedChildContext === unmaskedContext) {
            return instance.__reactInternalMemoizedMaskedChildContext;
          }

          var context = {};

          for (var key in contextTypes) {
            context[key] = unmaskedContext[key];
          }

          {
            var name = getComponentName(type) || "Unknown";
            checkPropTypes(contextTypes, context, "context", name, getCurrentFiberStackInDev);
          }

          if (instance) {
            cacheContext(workInProgress, unmaskedContext, context);
          }

          return context;
        }
      }

      function hasContextChanged() {
        if (disableLegacyContext) {
          return false;
        } else {
          return didPerformWorkStackCursor.current;
        }
      }

      function isContextProvider(type) {
        if (disableLegacyContext) {
          return false;
        } else {
          var childContextTypes = type.childContextTypes;
          return childContextTypes !== null && childContextTypes !== undefined;
        }
      }

      function popContext(fiber) {
        if (disableLegacyContext) {
          return;
        } else {
          pop(didPerformWorkStackCursor, fiber);
          pop(contextStackCursor, fiber);
        }
      }

      function popTopLevelContextObject(fiber) {
        if (disableLegacyContext) {
          return;
        } else {
          pop(didPerformWorkStackCursor, fiber);
          pop(contextStackCursor, fiber);
        }
      }

      function pushTopLevelContextObject(fiber, context, didChange) {
        if (disableLegacyContext) {
          return;
        } else {
          (function () {
            if (!(contextStackCursor.current === emptyContextObject)) {
              throw ReactError(Error("Unexpected context found on stack. This error is likely caused by a bug in React. Please file an issue."));
            }
          })();

          push(contextStackCursor, context, fiber);
          push(didPerformWorkStackCursor, didChange, fiber);
        }
      }

      function processChildContext(fiber, type, parentContext) {
        if (disableLegacyContext) {
          return parentContext;
        } else {
          var instance = fiber.stateNode;
          var childContextTypes = type.childContextTypes;

          if (typeof instance.getChildContext !== "function") {
            {
              var componentName = getComponentName(type) || "Unknown";

              if (!warnedAboutMissingGetChildContext[componentName]) {
                warnedAboutMissingGetChildContext[componentName] = true;
                warningWithoutStack$1(false, "%s.childContextTypes is specified but there is no getChildContext() method " + "on the instance. You can either define getChildContext() on %s or remove " + "childContextTypes from it.", componentName, componentName);
              }
            }
            return parentContext;
          }

          var childContext = void 0;
          {
            setCurrentPhase("getChildContext");
          }
          startPhaseTimer(fiber, "getChildContext");
          childContext = instance.getChildContext();
          stopPhaseTimer();
          {
            setCurrentPhase(null);
          }

          for (var contextKey in childContext) {
            (function () {
              if (!(contextKey in childContextTypes)) {
                throw ReactError(Error((getComponentName(type) || "Unknown") + '.getChildContext(): key "' + contextKey + '" is not defined in childContextTypes.'));
              }
            })();
          }

          {
            var name = getComponentName(type) || "Unknown";
            checkPropTypes(childContextTypes, childContext, "child context", name, getCurrentFiberStackInDev);
          }
          return _extends({}, parentContext, childContext);
        }
      }

      function pushContextProvider(workInProgress) {
        if (disableLegacyContext) {
          return false;
        } else {
          var instance = workInProgress.stateNode;
          var memoizedMergedChildContext = instance && instance.__reactInternalMemoizedMergedChildContext || emptyContextObject;
          previousContext = contextStackCursor.current;
          push(contextStackCursor, memoizedMergedChildContext, workInProgress);
          push(didPerformWorkStackCursor, didPerformWorkStackCursor.current, workInProgress);
          return true;
        }
      }

      function invalidateContextProvider(workInProgress, type, didChange) {
        if (disableLegacyContext) {
          return;
        } else {
          var instance = workInProgress.stateNode;

          (function () {
            if (!instance) {
              throw ReactError(Error("Expected to have an instance by this point. This error is likely caused by a bug in React. Please file an issue."));
            }
          })();

          if (didChange) {
            var mergedContext = processChildContext(workInProgress, type, previousContext);
            instance.__reactInternalMemoizedMergedChildContext = mergedContext;
            pop(didPerformWorkStackCursor, workInProgress);
            pop(contextStackCursor, workInProgress);
            push(contextStackCursor, mergedContext, workInProgress);
            push(didPerformWorkStackCursor, didChange, workInProgress);
          } else {
            pop(didPerformWorkStackCursor, workInProgress);
            push(didPerformWorkStackCursor, didChange, workInProgress);
          }
        }
      }

      function findCurrentUnmaskedContext(fiber) {
        if (disableLegacyContext) {
          return emptyContextObject;
        } else {
          (function () {
            if (!(isFiberMounted(fiber) && fiber.tag === ClassComponent)) {
              throw ReactError(Error("Expected subtree parent to be a mounted class component. This error is likely caused by a bug in React. Please file an issue."));
            }
          })();

          var node = fiber;

          do {
            switch (node.tag) {
              case HostRoot:
                return node.stateNode.context;

              case ClassComponent:
                {
                  var Component = node.type;

                  if (isContextProvider(Component)) {
                    return node.stateNode.__reactInternalMemoizedMergedChildContext;
                  }

                  break;
                }
            }

            node = node.return;
          } while (node !== null);

          (function () {
            {
              throw ReactError(Error("Found unexpected detached subtree parent. This error is likely caused by a bug in React. Please file an issue."));
            }
          })();
        }
      }

      var LegacyRoot = 0;
      var BatchedRoot = 1;
      var ConcurrentRoot = 2;
      var Scheduler_runWithPriority = Scheduler.unstable_runWithPriority;
      var Scheduler_scheduleCallback = Scheduler.unstable_scheduleCallback;
      var Scheduler_cancelCallback = Scheduler.unstable_cancelCallback;
      var Scheduler_shouldYield = Scheduler.unstable_shouldYield;
      var Scheduler_requestPaint = Scheduler.unstable_requestPaint;
      var Scheduler_now = Scheduler.unstable_now;
      var Scheduler_getCurrentPriorityLevel = Scheduler.unstable_getCurrentPriorityLevel;
      var Scheduler_ImmediatePriority = Scheduler.unstable_ImmediatePriority;
      var Scheduler_UserBlockingPriority = Scheduler.unstable_UserBlockingPriority;
      var Scheduler_NormalPriority = Scheduler.unstable_NormalPriority;
      var Scheduler_LowPriority = Scheduler.unstable_LowPriority;
      var Scheduler_IdlePriority = Scheduler.unstable_IdlePriority;

      if (enableSchedulerTracing) {
        (function () {
          if (!(tracing.__interactionsRef != null && tracing.__interactionsRef.current != null)) {
            throw ReactError(Error("It is not supported to run the profiling version of a renderer (for example, `react-dom/profiling`) without also replacing the `scheduler/tracing` module with `scheduler/tracing-profiling`. Your bundler might have a setting for aliasing both modules. Learn more at http://fb.me/react-profiling"));
          }
        })();
      }

      var fakeCallbackNode = {};
      var ImmediatePriority = 99;
      var UserBlockingPriority$1 = 98;
      var NormalPriority = 97;
      var LowPriority = 96;
      var IdlePriority = 95;
      var NoPriority = 90;
      var shouldYield = Scheduler_shouldYield;
      var requestPaint = Scheduler_requestPaint !== undefined ? Scheduler_requestPaint : function () {};
      var syncQueue = null;
      var immediateQueueCallbackNode = null;
      var isFlushingSyncQueue = false;
      var initialTimeMs = Scheduler_now();
      var now = initialTimeMs < 10000 ? Scheduler_now : function () {
        return Scheduler_now() - initialTimeMs;
      };

      function getCurrentPriorityLevel() {
        switch (Scheduler_getCurrentPriorityLevel()) {
          case Scheduler_ImmediatePriority:
            return ImmediatePriority;

          case Scheduler_UserBlockingPriority:
            return UserBlockingPriority$1;

          case Scheduler_NormalPriority:
            return NormalPriority;

          case Scheduler_LowPriority:
            return LowPriority;

          case Scheduler_IdlePriority:
            return IdlePriority;

          default:
            (function () {
              {
                throw ReactError(Error("Unknown priority level."));
              }
            })();

        }
      }

      function reactPriorityToSchedulerPriority(reactPriorityLevel) {
        switch (reactPriorityLevel) {
          case ImmediatePriority:
            return Scheduler_ImmediatePriority;

          case UserBlockingPriority$1:
            return Scheduler_UserBlockingPriority;

          case NormalPriority:
            return Scheduler_NormalPriority;

          case LowPriority:
            return Scheduler_LowPriority;

          case IdlePriority:
            return Scheduler_IdlePriority;

          default:
            (function () {
              {
                throw ReactError(Error("Unknown priority level."));
              }
            })();

        }
      }

      function runWithPriority$1(reactPriorityLevel, fn) {
        var priorityLevel = reactPriorityToSchedulerPriority(reactPriorityLevel);
        return Scheduler_runWithPriority(priorityLevel, fn);
      }

      function scheduleCallback(reactPriorityLevel, callback, options) {
        var priorityLevel = reactPriorityToSchedulerPriority(reactPriorityLevel);
        return Scheduler_scheduleCallback(priorityLevel, callback, options);
      }

      function scheduleSyncCallback(callback) {
        if (syncQueue === null) {
          syncQueue = [callback];
          immediateQueueCallbackNode = Scheduler_scheduleCallback(Scheduler_ImmediatePriority, flushSyncCallbackQueueImpl);
        } else {
          syncQueue.push(callback);
        }

        return fakeCallbackNode;
      }

      function cancelCallback(callbackNode) {
        if (callbackNode !== fakeCallbackNode) {
          Scheduler_cancelCallback(callbackNode);
        }
      }

      function flushSyncCallbackQueue() {
        if (immediateQueueCallbackNode !== null) {
          Scheduler_cancelCallback(immediateQueueCallbackNode);
        }

        flushSyncCallbackQueueImpl();
      }

      function flushSyncCallbackQueueImpl() {
        if (!isFlushingSyncQueue && syncQueue !== null) {
          isFlushingSyncQueue = true;
          var i = 0;

          try {
            var _isSync = true;
            var queue = syncQueue;
            runWithPriority$1(ImmediatePriority, function () {
              for (; i < queue.length; i++) {
                var callback = queue[i];

                do {
                  callback = callback(_isSync);
                } while (callback !== null);
              }
            });
            syncQueue = null;
          } catch (error) {
            if (syncQueue !== null) {
              syncQueue = syncQueue.slice(i + 1);
            }

            Scheduler_scheduleCallback(Scheduler_ImmediatePriority, flushSyncCallbackQueue);
            throw error;
          } finally {
            isFlushingSyncQueue = false;
          }
        }
      }

      var NoMode = 0;
      var StrictMode = 1;
      var BatchedMode = 2;
      var ConcurrentMode = 4;
      var ProfileMode = 8;
      var MAX_SIGNED_31_BIT_INT = 1073741823;
      var NoWork = 0;
      var Never = 1;
      var Sync = MAX_SIGNED_31_BIT_INT;
      var Batched = Sync - 1;
      var UNIT_SIZE = 10;
      var MAGIC_NUMBER_OFFSET = Batched - 1;

      function msToExpirationTime(ms) {
        return MAGIC_NUMBER_OFFSET - (ms / UNIT_SIZE | 0);
      }

      function expirationTimeToMs(expirationTime) {
        return (MAGIC_NUMBER_OFFSET - expirationTime) * UNIT_SIZE;
      }

      function ceiling(num, precision) {
        return ((num / precision | 0) + 1) * precision;
      }

      function computeExpirationBucket(currentTime, expirationInMs, bucketSizeMs) {
        return MAGIC_NUMBER_OFFSET - ceiling(MAGIC_NUMBER_OFFSET - currentTime + expirationInMs / UNIT_SIZE, bucketSizeMs / UNIT_SIZE);
      }

      var LOW_PRIORITY_EXPIRATION = 5000;
      var LOW_PRIORITY_BATCH_SIZE = 250;

      function computeAsyncExpiration(currentTime) {
        return computeExpirationBucket(currentTime, LOW_PRIORITY_EXPIRATION, LOW_PRIORITY_BATCH_SIZE);
      }

      function computeSuspenseExpiration(currentTime, timeoutMs) {
        return computeExpirationBucket(currentTime, timeoutMs, LOW_PRIORITY_BATCH_SIZE);
      }

      var HIGH_PRIORITY_EXPIRATION = 500;
      var HIGH_PRIORITY_BATCH_SIZE = 100;

      function computeInteractiveExpiration(currentTime) {
        return computeExpirationBucket(currentTime, HIGH_PRIORITY_EXPIRATION, HIGH_PRIORITY_BATCH_SIZE);
      }

      function inferPriorityFromExpirationTime(currentTime, expirationTime) {
        if (expirationTime === Sync) {
          return ImmediatePriority;
        }

        if (expirationTime === Never) {
          return IdlePriority;
        }

        var msUntil = expirationTimeToMs(expirationTime) - expirationTimeToMs(currentTime);

        if (msUntil <= 0) {
          return ImmediatePriority;
        }

        if (msUntil <= HIGH_PRIORITY_EXPIRATION + HIGH_PRIORITY_BATCH_SIZE) {
          return UserBlockingPriority$1;
        }

        if (msUntil <= LOW_PRIORITY_EXPIRATION + LOW_PRIORITY_BATCH_SIZE) {
          return NormalPriority;
        }

        return IdlePriority;
      }

      function is(x, y) {
        return x === y && (x !== 0 || 1 / x === 1 / y) || x !== x && y !== y;
      }

      var hasOwnProperty = Object.prototype.hasOwnProperty;

      function shallowEqual(objA, objB) {
        if (is(objA, objB)) {
          return true;
        }

        if (typeof objA !== "object" || objA === null || typeof objB !== "object" || objB === null) {
          return false;
        }

        var keysA = Object.keys(objA);
        var keysB = Object.keys(objB);

        if (keysA.length !== keysB.length) {
          return false;
        }

        for (var i = 0; i < keysA.length; i++) {
          if (!hasOwnProperty.call(objB, keysA[i]) || !is(objA[keysA[i]], objB[keysA[i]])) {
            return false;
          }
        }

        return true;
      }

      var lowPriorityWarning = function lowPriorityWarning() {};

      {
        var printWarning = function printWarning(format) {
          for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
            args[_key - 1] = arguments[_key];
          }

          var argIndex = 0;
          var message = "Warning: " + format.replace(/%s/g, function () {
            return args[argIndex++];
          });

          if (typeof console !== "undefined") {
            console.warn(message);
          }

          try {
            throw new Error(message);
          } catch (x) {}
        };

        lowPriorityWarning = function lowPriorityWarning(condition, format) {
          if (format === undefined) {
            throw new Error("`lowPriorityWarning(condition, format, ...args)` requires a warning " + "message argument");
          }

          if (!condition) {
            for (var _len2 = arguments.length, args = Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
              args[_key2 - 2] = arguments[_key2];
            }

            printWarning.apply(undefined, [format].concat(args));
          }
        };
      }
      var lowPriorityWarning$1 = lowPriorityWarning;
      var ReactStrictModeWarnings = {
        recordUnsafeLifecycleWarnings: function recordUnsafeLifecycleWarnings(fiber, instance) {},
        flushPendingUnsafeLifecycleWarnings: function flushPendingUnsafeLifecycleWarnings() {},
        recordLegacyContextWarning: function recordLegacyContextWarning(fiber, instance) {},
        flushLegacyContextWarning: function flushLegacyContextWarning() {},
        discardPendingWarnings: function discardPendingWarnings() {}
      };
      {
        var findStrictRoot = function findStrictRoot(fiber) {
          var maybeStrictRoot = null;
          var node = fiber;

          while (node !== null) {
            if (node.mode & StrictMode) {
              maybeStrictRoot = node;
            }

            node = node.return;
          }

          return maybeStrictRoot;
        };

        var setToSortedString = function setToSortedString(set) {
          var array = [];
          set.forEach(function (value) {
            array.push(value);
          });
          return array.sort().join(", ");
        };

        var pendingComponentWillMountWarnings = [];
        var pendingUNSAFE_ComponentWillMountWarnings = [];
        var pendingComponentWillReceivePropsWarnings = [];
        var pendingUNSAFE_ComponentWillReceivePropsWarnings = [];
        var pendingComponentWillUpdateWarnings = [];
        var pendingUNSAFE_ComponentWillUpdateWarnings = [];
        var didWarnAboutUnsafeLifecycles = new Set();

        ReactStrictModeWarnings.recordUnsafeLifecycleWarnings = function (fiber, instance) {
          if (didWarnAboutUnsafeLifecycles.has(fiber.type)) {
            return;
          }

          if (typeof instance.componentWillMount === "function" && instance.componentWillMount.__suppressDeprecationWarning !== true) {
            pendingComponentWillMountWarnings.push(fiber);
          }

          if (fiber.mode & StrictMode && typeof instance.UNSAFE_componentWillMount === "function") {
            pendingUNSAFE_ComponentWillMountWarnings.push(fiber);
          }

          if (typeof instance.componentWillReceiveProps === "function" && instance.componentWillReceiveProps.__suppressDeprecationWarning !== true) {
            pendingComponentWillReceivePropsWarnings.push(fiber);
          }

          if (fiber.mode & StrictMode && typeof instance.UNSAFE_componentWillReceiveProps === "function") {
            pendingUNSAFE_ComponentWillReceivePropsWarnings.push(fiber);
          }

          if (typeof instance.componentWillUpdate === "function" && instance.componentWillUpdate.__suppressDeprecationWarning !== true) {
            pendingComponentWillUpdateWarnings.push(fiber);
          }

          if (fiber.mode & StrictMode && typeof instance.UNSAFE_componentWillUpdate === "function") {
            pendingUNSAFE_ComponentWillUpdateWarnings.push(fiber);
          }
        };

        ReactStrictModeWarnings.flushPendingUnsafeLifecycleWarnings = function () {
          var componentWillMountUniqueNames = new Set();

          if (pendingComponentWillMountWarnings.length > 0) {
            pendingComponentWillMountWarnings.forEach(function (fiber) {
              componentWillMountUniqueNames.add(getComponentName(fiber.type) || "Component");
              didWarnAboutUnsafeLifecycles.add(fiber.type);
            });
            pendingComponentWillMountWarnings = [];
          }

          var UNSAFE_componentWillMountUniqueNames = new Set();

          if (pendingUNSAFE_ComponentWillMountWarnings.length > 0) {
            pendingUNSAFE_ComponentWillMountWarnings.forEach(function (fiber) {
              UNSAFE_componentWillMountUniqueNames.add(getComponentName(fiber.type) || "Component");
              didWarnAboutUnsafeLifecycles.add(fiber.type);
            });
            pendingUNSAFE_ComponentWillMountWarnings = [];
          }

          var componentWillReceivePropsUniqueNames = new Set();

          if (pendingComponentWillReceivePropsWarnings.length > 0) {
            pendingComponentWillReceivePropsWarnings.forEach(function (fiber) {
              componentWillReceivePropsUniqueNames.add(getComponentName(fiber.type) || "Component");
              didWarnAboutUnsafeLifecycles.add(fiber.type);
            });
            pendingComponentWillReceivePropsWarnings = [];
          }

          var UNSAFE_componentWillReceivePropsUniqueNames = new Set();

          if (pendingUNSAFE_ComponentWillReceivePropsWarnings.length > 0) {
            pendingUNSAFE_ComponentWillReceivePropsWarnings.forEach(function (fiber) {
              UNSAFE_componentWillReceivePropsUniqueNames.add(getComponentName(fiber.type) || "Component");
              didWarnAboutUnsafeLifecycles.add(fiber.type);
            });
            pendingUNSAFE_ComponentWillReceivePropsWarnings = [];
          }

          var componentWillUpdateUniqueNames = new Set();

          if (pendingComponentWillUpdateWarnings.length > 0) {
            pendingComponentWillUpdateWarnings.forEach(function (fiber) {
              componentWillUpdateUniqueNames.add(getComponentName(fiber.type) || "Component");
              didWarnAboutUnsafeLifecycles.add(fiber.type);
            });
            pendingComponentWillUpdateWarnings = [];
          }

          var UNSAFE_componentWillUpdateUniqueNames = new Set();

          if (pendingUNSAFE_ComponentWillUpdateWarnings.length > 0) {
            pendingUNSAFE_ComponentWillUpdateWarnings.forEach(function (fiber) {
              UNSAFE_componentWillUpdateUniqueNames.add(getComponentName(fiber.type) || "Component");
              didWarnAboutUnsafeLifecycles.add(fiber.type);
            });
            pendingUNSAFE_ComponentWillUpdateWarnings = [];
          }

          if (UNSAFE_componentWillMountUniqueNames.size > 0) {
            var sortedNames = setToSortedString(UNSAFE_componentWillMountUniqueNames);
            warningWithoutStack$1(false, "Using UNSAFE_componentWillMount in strict mode is not recommended and may indicate bugs in your code. " + "See https://fb.me/react-async-component-lifecycle-hooks for details.\n\n" + "* Move code with side effects to componentDidMount, and set initial state in the constructor.\n" + "\nPlease update the following components: %s", sortedNames);
          }

          if (UNSAFE_componentWillReceivePropsUniqueNames.size > 0) {
            var _sortedNames = setToSortedString(UNSAFE_componentWillReceivePropsUniqueNames);

            warningWithoutStack$1(false, "Using UNSAFE_componentWillReceiveProps in strict mode is not recommended " + "and may indicate bugs in your code. " + "See https://fb.me/react-async-component-lifecycle-hooks for details.\n\n" + "* Move data fetching code or side effects to componentDidUpdate.\n" + "* If you're updating state whenever props change, " + "refactor your code to use memoization techniques or move it to " + "static getDerivedStateFromProps. Learn more at: https://fb.me/react-derived-state\n" + "\nPlease update the following components: %s", _sortedNames);
          }

          if (UNSAFE_componentWillUpdateUniqueNames.size > 0) {
            var _sortedNames2 = setToSortedString(UNSAFE_componentWillUpdateUniqueNames);

            warningWithoutStack$1(false, "Using UNSAFE_componentWillUpdate in strict mode is not recommended " + "and may indicate bugs in your code. " + "See https://fb.me/react-async-component-lifecycle-hooks for details.\n\n" + "* Move data fetching code or side effects to componentDidUpdate.\n" + "\nPlease update the following components: %s", _sortedNames2);
          }

          if (componentWillMountUniqueNames.size > 0) {
            var _sortedNames3 = setToSortedString(componentWillMountUniqueNames);

            lowPriorityWarning$1(false, "componentWillMount has been renamed, and is not recommended for use. " + "See https://fb.me/react-async-component-lifecycle-hooks for details.\n\n" + "* Move code with side effects to componentDidMount, and set initial state in the constructor.\n" + "* Rename componentWillMount to UNSAFE_componentWillMount to suppress " + "this warning in non-strict mode. In React 17.x, only the UNSAFE_ name will work. " + "To rename all deprecated lifecycles to their new names, you can run " + "`npx react-codemod rename-unsafe-lifecycles` in your project source folder.\n" + "\nPlease update the following components: %s", _sortedNames3);
          }

          if (componentWillReceivePropsUniqueNames.size > 0) {
            var _sortedNames4 = setToSortedString(componentWillReceivePropsUniqueNames);

            lowPriorityWarning$1(false, "componentWillReceiveProps has been renamed, and is not recommended for use. " + "See https://fb.me/react-async-component-lifecycle-hooks for details.\n\n" + "* Move data fetching code or side effects to componentDidUpdate.\n" + "* If you're updating state whenever props change, refactor your " + "code to use memoization techniques or move it to " + "static getDerivedStateFromProps. Learn more at: https://fb.me/react-derived-state\n" + "* Rename componentWillReceiveProps to UNSAFE_componentWillReceiveProps to suppress " + "this warning in non-strict mode. In React 17.x, only the UNSAFE_ name will work. " + "To rename all deprecated lifecycles to their new names, you can run " + "`npx react-codemod rename-unsafe-lifecycles` in your project source folder.\n" + "\nPlease update the following components: %s", _sortedNames4);
          }

          if (componentWillUpdateUniqueNames.size > 0) {
            var _sortedNames5 = setToSortedString(componentWillUpdateUniqueNames);

            lowPriorityWarning$1(false, "componentWillUpdate has been renamed, and is not recommended for use. " + "See https://fb.me/react-async-component-lifecycle-hooks for details.\n\n" + "* Move data fetching code or side effects to componentDidUpdate.\n" + "* Rename componentWillUpdate to UNSAFE_componentWillUpdate to suppress " + "this warning in non-strict mode. In React 17.x, only the UNSAFE_ name will work. " + "To rename all deprecated lifecycles to their new names, you can run " + "`npx react-codemod rename-unsafe-lifecycles` in your project source folder.\n" + "\nPlease update the following components: %s", _sortedNames5);
          }
        };

        var pendingLegacyContextWarning = new Map();
        var didWarnAboutLegacyContext = new Set();

        ReactStrictModeWarnings.recordLegacyContextWarning = function (fiber, instance) {
          var strictRoot = findStrictRoot(fiber);

          if (strictRoot === null) {
            warningWithoutStack$1(false, "Expected to find a StrictMode component in a strict mode tree. " + "This error is likely caused by a bug in React. Please file an issue.");
            return;
          }

          if (didWarnAboutLegacyContext.has(fiber.type)) {
            return;
          }

          var warningsForRoot = pendingLegacyContextWarning.get(strictRoot);

          if (fiber.type.contextTypes != null || fiber.type.childContextTypes != null || instance !== null && typeof instance.getChildContext === "function") {
            if (warningsForRoot === undefined) {
              warningsForRoot = [];
              pendingLegacyContextWarning.set(strictRoot, warningsForRoot);
            }

            warningsForRoot.push(fiber);
          }
        };

        ReactStrictModeWarnings.flushLegacyContextWarning = function () {
          pendingLegacyContextWarning.forEach(function (fiberArray, strictRoot) {
            var uniqueNames = new Set();
            fiberArray.forEach(function (fiber) {
              uniqueNames.add(getComponentName(fiber.type) || "Component");
              didWarnAboutLegacyContext.add(fiber.type);
            });
            var sortedNames = setToSortedString(uniqueNames);
            var strictRootComponentStack = getStackByFiberInDevAndProd(strictRoot);
            warningWithoutStack$1(false, "Legacy context API has been detected within a strict-mode tree: %s" + "\n\nThe old API will be supported in all 16.x releases, but applications " + "using it should migrate to the new version." + "\n\nPlease update the following components: %s" + "\n\nLearn more about this warning here:" + "\nhttps://fb.me/react-legacy-context", strictRootComponentStack, sortedNames);
          });
        };

        ReactStrictModeWarnings.discardPendingWarnings = function () {
          pendingComponentWillMountWarnings = [];
          pendingUNSAFE_ComponentWillMountWarnings = [];
          pendingComponentWillReceivePropsWarnings = [];
          pendingUNSAFE_ComponentWillReceivePropsWarnings = [];
          pendingComponentWillUpdateWarnings = [];
          pendingUNSAFE_ComponentWillUpdateWarnings = [];
          pendingLegacyContextWarning = new Map();
        };
      }
      var resolveFamily = null;
      var failedBoundaries = null;

      var setRefreshHandler = function setRefreshHandler(handler) {
        {
          resolveFamily = handler;
        }
      };

      function resolveFunctionForHotReloading(type) {
        {
          if (resolveFamily === null) {
            return type;
          }

          var family = resolveFamily(type);

          if (family === undefined) {
            return type;
          }

          return family.current;
        }
      }

      function resolveClassForHotReloading(type) {
        return resolveFunctionForHotReloading(type);
      }

      function resolveForwardRefForHotReloading(type) {
        {
          if (resolveFamily === null) {
            return type;
          }

          var family = resolveFamily(type);

          if (family === undefined) {
            if (type !== null && type !== undefined && typeof type.render === "function") {
              var currentRender = resolveFunctionForHotReloading(type.render);

              if (type.render !== currentRender) {
                var syntheticType = {
                  $$typeof: REACT_FORWARD_REF_TYPE,
                  render: currentRender
                };

                if (type.displayName !== undefined) {
                  syntheticType.displayName = type.displayName;
                }

                return syntheticType;
              }
            }

            return type;
          }

          return family.current;
        }
      }

      function isCompatibleFamilyForHotReloading(fiber, element) {
        {
          if (resolveFamily === null) {
            return false;
          }

          var prevType = fiber.elementType;
          var nextType = element.type;
          var needsCompareFamilies = false;
          var $$typeofNextType = typeof nextType === "object" && nextType !== null ? nextType.$$typeof : null;

          switch (fiber.tag) {
            case ClassComponent:
              {
                if (typeof nextType === "function") {
                  needsCompareFamilies = true;
                }

                break;
              }

            case FunctionComponent:
              {
                if (typeof nextType === "function") {
                  needsCompareFamilies = true;
                } else if ($$typeofNextType === REACT_LAZY_TYPE) {
                  needsCompareFamilies = true;
                }

                break;
              }

            case ForwardRef:
              {
                if ($$typeofNextType === REACT_FORWARD_REF_TYPE) {
                  needsCompareFamilies = true;
                } else if ($$typeofNextType === REACT_LAZY_TYPE) {
                  needsCompareFamilies = true;
                }

                break;
              }

            case MemoComponent:
            case SimpleMemoComponent:
              {
                if ($$typeofNextType === REACT_MEMO_TYPE) {
                  needsCompareFamilies = true;
                } else if ($$typeofNextType === REACT_LAZY_TYPE) {
                  needsCompareFamilies = true;
                }

                break;
              }

            default:
              return false;
          }

          if (needsCompareFamilies) {
            var prevFamily = resolveFamily(prevType);

            if (prevFamily !== undefined && prevFamily === resolveFamily(nextType)) {
              return true;
            }
          }

          return false;
        }
      }

      function markFailedErrorBoundaryForHotReloading(fiber) {
        {
          if (resolveFamily === null) {
            return;
          }

          if (typeof WeakSet !== "function") {
            return;
          }

          if (failedBoundaries === null) {
            failedBoundaries = new WeakSet();
          }

          failedBoundaries.add(fiber);
        }
      }

      var scheduleRefresh = function scheduleRefresh(root, update) {
        {
          if (resolveFamily === null) {
            return;
          }

          var _staleFamilies = update.staleFamilies,
              _updatedFamilies = update.updatedFamilies;
          flushPassiveEffects();
          flushSync(function () {
            scheduleFibersWithFamiliesRecursively(root.current, _updatedFamilies, _staleFamilies);
          });
        }
      };

      var scheduleRoot = function scheduleRoot(root, element) {
        {
          if (root.context !== emptyContextObject) {
            return;
          }

          flushPassiveEffects();
          updateContainerAtExpirationTime(element, root, null, Sync, null);
        }
      };

      function scheduleFibersWithFamiliesRecursively(fiber, updatedFamilies, staleFamilies) {
        {
          var alternate = fiber.alternate,
              child = fiber.child,
              sibling = fiber.sibling,
              tag = fiber.tag,
              type = fiber.type;
          var candidateType = null;

          switch (tag) {
            case FunctionComponent:
            case SimpleMemoComponent:
            case ClassComponent:
              candidateType = type;
              break;

            case ForwardRef:
              candidateType = type.render;
              break;

            default:
              break;
          }

          if (resolveFamily === null) {
            throw new Error("Expected resolveFamily to be set during hot reload.");
          }

          var needsRender = false;
          var needsRemount = false;

          if (candidateType !== null) {
            var family = resolveFamily(candidateType);

            if (family !== undefined) {
              if (staleFamilies.has(family)) {
                needsRemount = true;
              } else if (updatedFamilies.has(family)) {
                if (tag === ClassComponent) {
                  needsRemount = true;
                } else {
                  needsRender = true;
                }
              }
            }
          }

          if (failedBoundaries !== null) {
            if (failedBoundaries.has(fiber) || alternate !== null && failedBoundaries.has(alternate)) {
              needsRemount = true;
            }
          }

          if (needsRemount) {
            fiber._debugNeedsRemount = true;
          }

          if (needsRemount || needsRender) {
            scheduleWork(fiber, Sync);
          }

          if (child !== null && !needsRemount) {
            scheduleFibersWithFamiliesRecursively(child, updatedFamilies, staleFamilies);
          }

          if (sibling !== null) {
            scheduleFibersWithFamiliesRecursively(sibling, updatedFamilies, staleFamilies);
          }
        }
      }

      var findHostInstancesForRefresh = function findHostInstancesForRefresh(root, families) {
        {
          var hostInstances = new Set();
          var types = new Set(families.map(function (family) {
            return family.current;
          }));
          findHostInstancesForMatchingFibersRecursively(root.current, types, hostInstances);
          return hostInstances;
        }
      };

      function findHostInstancesForMatchingFibersRecursively(fiber, types, hostInstances) {
        {
          var child = fiber.child,
              sibling = fiber.sibling,
              tag = fiber.tag,
              type = fiber.type;
          var candidateType = null;

          switch (tag) {
            case FunctionComponent:
            case SimpleMemoComponent:
            case ClassComponent:
              candidateType = type;
              break;

            case ForwardRef:
              candidateType = type.render;
              break;

            default:
              break;
          }

          var didMatch = false;

          if (candidateType !== null) {
            if (types.has(candidateType)) {
              didMatch = true;
            }
          }

          if (didMatch) {
            findHostInstancesForFiberShallowly(fiber, hostInstances);
          } else {
            if (child !== null) {
              findHostInstancesForMatchingFibersRecursively(child, types, hostInstances);
            }
          }

          if (sibling !== null) {
            findHostInstancesForMatchingFibersRecursively(sibling, types, hostInstances);
          }
        }
      }

      function findHostInstancesForFiberShallowly(fiber, hostInstances) {
        {
          var foundHostInstances = findChildHostInstancesForFiberShallowly(fiber, hostInstances);

          if (foundHostInstances) {
            return;
          }

          var node = fiber;

          while (true) {
            switch (node.tag) {
              case HostComponent:
                hostInstances.add(node.stateNode);
                return;

              case HostPortal:
                hostInstances.add(node.stateNode.containerInfo);
                return;

              case HostRoot:
                hostInstances.add(node.stateNode.containerInfo);
                return;
            }

            if (node.return === null) {
              throw new Error("Expected to reach root first.");
            }

            node = node.return;
          }
        }
      }

      function findChildHostInstancesForFiberShallowly(fiber, hostInstances) {
        {
          var node = fiber;
          var foundHostInstances = false;

          while (true) {
            if (node.tag === HostComponent) {
              foundHostInstances = true;
              hostInstances.add(node.stateNode);
            } else if (node.child !== null) {
              node.child.return = node;
              node = node.child;
              continue;
            }

            if (node === fiber) {
              return foundHostInstances;
            }

            while (node.sibling === null) {
              if (node.return === null || node.return === fiber) {
                return foundHostInstances;
              }

              node = node.return;
            }

            node.sibling.return = node.return;
            node = node.sibling;
          }
        }
        return false;
      }

      function resolveDefaultProps(Component, baseProps) {
        if (Component && Component.defaultProps) {
          var props = _extends({}, baseProps);

          var defaultProps = Component.defaultProps;

          for (var propName in defaultProps) {
            if (props[propName] === undefined) {
              props[propName] = defaultProps[propName];
            }
          }

          return props;
        }

        return baseProps;
      }

      function readLazyComponentType(lazyComponent) {
        var status = lazyComponent._status;
        var result = lazyComponent._result;

        switch (status) {
          case Resolved:
            {
              var Component = result;
              return Component;
            }

          case Rejected:
            {
              var error = result;
              throw error;
            }

          case Pending:
            {
              var thenable = result;
              throw thenable;
            }

          default:
            {
              lazyComponent._status = Pending;
              var ctor = lazyComponent._ctor;

              var _thenable = ctor();

              _thenable.then(function (moduleObject) {
                if (lazyComponent._status === Pending) {
                  var defaultExport = moduleObject.default;
                  {
                    if (defaultExport === undefined) {
                      warning$1(false, "lazy: Expected the result of a dynamic import() call. " + "Instead received: %s\n\nYour code should look like: \n  " + "const MyComponent = lazy(() => import('./MyComponent'))", moduleObject);
                    }
                  }
                  lazyComponent._status = Resolved;
                  lazyComponent._result = defaultExport;
                }
              }, function (error) {
                if (lazyComponent._status === Pending) {
                  lazyComponent._status = Rejected;
                  lazyComponent._result = error;
                }
              });

              switch (lazyComponent._status) {
                case Resolved:
                  return lazyComponent._result;

                case Rejected:
                  throw lazyComponent._result;
              }

              lazyComponent._result = _thenable;
              throw _thenable;
            }
        }
      }

      var valueCursor = createCursor(null);
      var rendererSigil = void 0;
      {
        rendererSigil = {};
      }
      var currentlyRenderingFiber = null;
      var lastContextDependency = null;
      var lastContextWithAllBitsObserved = null;
      var isDisallowedContextReadInDEV = false;

      function resetContextDependencies() {
        currentlyRenderingFiber = null;
        lastContextDependency = null;
        lastContextWithAllBitsObserved = null;
        {
          isDisallowedContextReadInDEV = false;
        }
      }

      function enterDisallowedContextReadInDEV() {
        {
          isDisallowedContextReadInDEV = true;
        }
      }

      function exitDisallowedContextReadInDEV() {
        {
          isDisallowedContextReadInDEV = false;
        }
      }

      function pushProvider(providerFiber, nextValue) {
        var context = providerFiber.type._context;

        if (isPrimaryRenderer) {
          push(valueCursor, context._currentValue, providerFiber);
          context._currentValue = nextValue;
          {
            !(context._currentRenderer === undefined || context._currentRenderer === null || context._currentRenderer === rendererSigil) ? warningWithoutStack$1(false, "Detected multiple renderers concurrently rendering the " + "same context provider. This is currently unsupported.") : void 0;
            context._currentRenderer = rendererSigil;
          }
        } else {
          push(valueCursor, context._currentValue2, providerFiber);
          context._currentValue2 = nextValue;
          {
            !(context._currentRenderer2 === undefined || context._currentRenderer2 === null || context._currentRenderer2 === rendererSigil) ? warningWithoutStack$1(false, "Detected multiple renderers concurrently rendering the " + "same context provider. This is currently unsupported.") : void 0;
            context._currentRenderer2 = rendererSigil;
          }
        }
      }

      function popProvider(providerFiber) {
        var currentValue = valueCursor.current;
        pop(valueCursor, providerFiber);
        var context = providerFiber.type._context;

        if (isPrimaryRenderer) {
          context._currentValue = currentValue;
        } else {
          context._currentValue2 = currentValue;
        }
      }

      function calculateChangedBits(context, newValue, oldValue) {
        if (is(oldValue, newValue)) {
          return 0;
        } else {
          var changedBits = typeof context._calculateChangedBits === "function" ? context._calculateChangedBits(oldValue, newValue) : MAX_SIGNED_31_BIT_INT;
          {
            !((changedBits & MAX_SIGNED_31_BIT_INT) === changedBits) ? warning$1(false, "calculateChangedBits: Expected the return value to be a " + "31-bit integer. Instead received: %s", changedBits) : void 0;
          }
          return changedBits | 0;
        }
      }

      function scheduleWorkOnParentPath(parent, renderExpirationTime) {
        var node = parent;

        while (node !== null) {
          var alternate = node.alternate;

          if (node.childExpirationTime < renderExpirationTime) {
            node.childExpirationTime = renderExpirationTime;

            if (alternate !== null && alternate.childExpirationTime < renderExpirationTime) {
              alternate.childExpirationTime = renderExpirationTime;
            }
          } else if (alternate !== null && alternate.childExpirationTime < renderExpirationTime) {
            alternate.childExpirationTime = renderExpirationTime;
          } else {
            break;
          }

          node = node.return;
        }
      }

      function propagateContextChange(workInProgress, context, changedBits, renderExpirationTime) {
        var fiber = workInProgress.child;

        if (fiber !== null) {
          fiber.return = workInProgress;
        }

        while (fiber !== null) {
          var nextFiber = void 0;
          var list = fiber.dependencies;

          if (list !== null) {
            nextFiber = fiber.child;
            var dependency = list.firstContext;

            while (dependency !== null) {
              if (dependency.context === context && (dependency.observedBits & changedBits) !== 0) {
                if (fiber.tag === ClassComponent) {
                  var update = createUpdate(renderExpirationTime, null);
                  update.tag = ForceUpdate;
                  enqueueUpdate(fiber, update);
                }

                if (fiber.expirationTime < renderExpirationTime) {
                  fiber.expirationTime = renderExpirationTime;
                }

                var alternate = fiber.alternate;

                if (alternate !== null && alternate.expirationTime < renderExpirationTime) {
                  alternate.expirationTime = renderExpirationTime;
                }

                scheduleWorkOnParentPath(fiber.return, renderExpirationTime);

                if (list.expirationTime < renderExpirationTime) {
                  list.expirationTime = renderExpirationTime;
                }

                break;
              }

              dependency = dependency.next;
            }
          } else if (fiber.tag === ContextProvider) {
            nextFiber = fiber.type === workInProgress.type ? null : fiber.child;
          } else if (enableSuspenseServerRenderer && fiber.tag === DehydratedSuspenseComponent) {
            if (fiber.expirationTime < renderExpirationTime) {
              fiber.expirationTime = renderExpirationTime;
            }

            var _alternate = fiber.alternate;

            if (_alternate !== null && _alternate.expirationTime < renderExpirationTime) {
              _alternate.expirationTime = renderExpirationTime;
            }

            scheduleWorkOnParentPath(fiber, renderExpirationTime);
            nextFiber = fiber.sibling;
          } else {
            nextFiber = fiber.child;
          }

          if (nextFiber !== null) {
            nextFiber.return = fiber;
          } else {
            nextFiber = fiber;

            while (nextFiber !== null) {
              if (nextFiber === workInProgress) {
                nextFiber = null;
                break;
              }

              var sibling = nextFiber.sibling;

              if (sibling !== null) {
                sibling.return = nextFiber.return;
                nextFiber = sibling;
                break;
              }

              nextFiber = nextFiber.return;
            }
          }

          fiber = nextFiber;
        }
      }

      function prepareToReadContext(workInProgress, renderExpirationTime) {
        currentlyRenderingFiber = workInProgress;
        lastContextDependency = null;
        lastContextWithAllBitsObserved = null;
        var dependencies = workInProgress.dependencies;

        if (dependencies !== null) {
          var firstContext = dependencies.firstContext;

          if (firstContext !== null) {
            if (dependencies.expirationTime >= renderExpirationTime) {
              markWorkInProgressReceivedUpdate();
            }

            dependencies.firstContext = null;
          }
        }
      }

      function _readContext(context, observedBits) {
        {
          !!isDisallowedContextReadInDEV ? warning$1(false, "Context can only be read while React is rendering. " + "In classes, you can read it in the render method or getDerivedStateFromProps. " + "In function components, you can read it directly in the function body, but not " + "inside Hooks like useReducer() or useMemo().") : void 0;
        }

        if (lastContextWithAllBitsObserved === context) {} else if (observedBits === false || observedBits === 0) {} else {
          var resolvedObservedBits = void 0;

          if (typeof observedBits !== "number" || observedBits === MAX_SIGNED_31_BIT_INT) {
            lastContextWithAllBitsObserved = context;
            resolvedObservedBits = MAX_SIGNED_31_BIT_INT;
          } else {
            resolvedObservedBits = observedBits;
          }

          var contextItem = {
            context: context,
            observedBits: resolvedObservedBits,
            next: null
          };

          if (lastContextDependency === null) {
            (function () {
              if (!(currentlyRenderingFiber !== null)) {
                throw ReactError(Error("Context can only be read while React is rendering. In classes, you can read it in the render method or getDerivedStateFromProps. In function components, you can read it directly in the function body, but not inside Hooks like useReducer() or useMemo()."));
              }
            })();

            lastContextDependency = contextItem;
            currentlyRenderingFiber.dependencies = {
              expirationTime: NoWork,
              firstContext: contextItem,
              responders: null
            };
          } else {
            lastContextDependency = lastContextDependency.next = contextItem;
          }
        }

        return isPrimaryRenderer ? context._currentValue : context._currentValue2;
      }

      var UpdateState = 0;
      var ReplaceState = 1;
      var ForceUpdate = 2;
      var CaptureUpdate = 3;
      var hasForceUpdate = false;
      var didWarnUpdateInsideUpdate = void 0;
      var currentlyProcessingQueue = void 0;
      {
        didWarnUpdateInsideUpdate = false;
        currentlyProcessingQueue = null;
      }

      function createUpdateQueue(baseState) {
        var queue = {
          baseState: baseState,
          firstUpdate: null,
          lastUpdate: null,
          firstCapturedUpdate: null,
          lastCapturedUpdate: null,
          firstEffect: null,
          lastEffect: null,
          firstCapturedEffect: null,
          lastCapturedEffect: null
        };
        return queue;
      }

      function cloneUpdateQueue(currentQueue) {
        var queue = {
          baseState: currentQueue.baseState,
          firstUpdate: currentQueue.firstUpdate,
          lastUpdate: currentQueue.lastUpdate,
          firstCapturedUpdate: null,
          lastCapturedUpdate: null,
          firstEffect: null,
          lastEffect: null,
          firstCapturedEffect: null,
          lastCapturedEffect: null
        };
        return queue;
      }

      function createUpdate(expirationTime, suspenseConfig) {
        var update = {
          expirationTime: expirationTime,
          suspenseConfig: suspenseConfig,
          tag: UpdateState,
          payload: null,
          callback: null,
          next: null,
          nextEffect: null
        };
        {
          update.priority = getCurrentPriorityLevel();
        }
        return update;
      }

      function appendUpdateToQueue(queue, update) {
        if (queue.lastUpdate === null) {
          queue.firstUpdate = queue.lastUpdate = update;
        } else {
          queue.lastUpdate.next = update;
          queue.lastUpdate = update;
        }
      }

      function enqueueUpdate(fiber, update) {
        var alternate = fiber.alternate;
        var queue1 = void 0;
        var queue2 = void 0;

        if (alternate === null) {
          queue1 = fiber.updateQueue;
          queue2 = null;

          if (queue1 === null) {
            queue1 = fiber.updateQueue = createUpdateQueue(fiber.memoizedState);
          }
        } else {
          queue1 = fiber.updateQueue;
          queue2 = alternate.updateQueue;

          if (queue1 === null) {
            if (queue2 === null) {
              queue1 = fiber.updateQueue = createUpdateQueue(fiber.memoizedState);
              queue2 = alternate.updateQueue = createUpdateQueue(alternate.memoizedState);
            } else {
              queue1 = fiber.updateQueue = cloneUpdateQueue(queue2);
            }
          } else {
            if (queue2 === null) {
              queue2 = alternate.updateQueue = cloneUpdateQueue(queue1);
            } else {}
          }
        }

        if (queue2 === null || queue1 === queue2) {
          appendUpdateToQueue(queue1, update);
        } else {
          if (queue1.lastUpdate === null || queue2.lastUpdate === null) {
            appendUpdateToQueue(queue1, update);
            appendUpdateToQueue(queue2, update);
          } else {
            appendUpdateToQueue(queue1, update);
            queue2.lastUpdate = update;
          }
        }

        {
          if (fiber.tag === ClassComponent && (currentlyProcessingQueue === queue1 || queue2 !== null && currentlyProcessingQueue === queue2) && !didWarnUpdateInsideUpdate) {
            warningWithoutStack$1(false, "An update (setState, replaceState, or forceUpdate) was scheduled " + "from inside an update function. Update functions should be pure, " + "with zero side-effects. Consider using componentDidUpdate or a " + "callback.");
            didWarnUpdateInsideUpdate = true;
          }
        }
      }

      function enqueueCapturedUpdate(workInProgress, update) {
        var workInProgressQueue = workInProgress.updateQueue;

        if (workInProgressQueue === null) {
          workInProgressQueue = workInProgress.updateQueue = createUpdateQueue(workInProgress.memoizedState);
        } else {
          workInProgressQueue = ensureWorkInProgressQueueIsAClone(workInProgress, workInProgressQueue);
        }

        if (workInProgressQueue.lastCapturedUpdate === null) {
          workInProgressQueue.firstCapturedUpdate = workInProgressQueue.lastCapturedUpdate = update;
        } else {
          workInProgressQueue.lastCapturedUpdate.next = update;
          workInProgressQueue.lastCapturedUpdate = update;
        }
      }

      function ensureWorkInProgressQueueIsAClone(workInProgress, queue) {
        var current = workInProgress.alternate;

        if (current !== null) {
          if (queue === current.updateQueue) {
            queue = workInProgress.updateQueue = cloneUpdateQueue(queue);
          }
        }

        return queue;
      }

      function getStateFromUpdate(workInProgress, queue, update, prevState, nextProps, instance) {
        switch (update.tag) {
          case ReplaceState:
            {
              var _payload = update.payload;

              if (typeof _payload === "function") {
                {
                  enterDisallowedContextReadInDEV();

                  if (debugRenderPhaseSideEffects || debugRenderPhaseSideEffectsForStrictMode && workInProgress.mode & StrictMode) {
                    _payload.call(instance, prevState, nextProps);
                  }
                }

                var nextState = _payload.call(instance, prevState, nextProps);

                {
                  exitDisallowedContextReadInDEV();
                }
                return nextState;
              }

              return _payload;
            }

          case CaptureUpdate:
            {
              workInProgress.effectTag = workInProgress.effectTag & ~ShouldCapture | DidCapture;
            }

          case UpdateState:
            {
              var _payload2 = update.payload;
              var partialState = void 0;

              if (typeof _payload2 === "function") {
                {
                  enterDisallowedContextReadInDEV();

                  if (debugRenderPhaseSideEffects || debugRenderPhaseSideEffectsForStrictMode && workInProgress.mode & StrictMode) {
                    _payload2.call(instance, prevState, nextProps);
                  }
                }
                partialState = _payload2.call(instance, prevState, nextProps);
                {
                  exitDisallowedContextReadInDEV();
                }
              } else {
                partialState = _payload2;
              }

              if (partialState === null || partialState === undefined) {
                return prevState;
              }

              return _extends({}, prevState, partialState);
            }

          case ForceUpdate:
            {
              hasForceUpdate = true;
              return prevState;
            }
        }

        return prevState;
      }

      function processUpdateQueue(workInProgress, queue, props, instance, renderExpirationTime) {
        hasForceUpdate = false;
        queue = ensureWorkInProgressQueueIsAClone(workInProgress, queue);
        {
          currentlyProcessingQueue = queue;
        }
        var newBaseState = queue.baseState;
        var newFirstUpdate = null;
        var newExpirationTime = NoWork;
        var update = queue.firstUpdate;
        var resultState = newBaseState;

        while (update !== null) {
          var updateExpirationTime = update.expirationTime;

          if (updateExpirationTime < renderExpirationTime) {
            if (newFirstUpdate === null) {
              newFirstUpdate = update;
              newBaseState = resultState;
            }

            if (newExpirationTime < updateExpirationTime) {
              newExpirationTime = updateExpirationTime;
            }
          } else {
            markRenderEventTimeAndConfig(updateExpirationTime, update.suspenseConfig);
            resultState = getStateFromUpdate(workInProgress, queue, update, resultState, props, instance);
            var _callback = update.callback;

            if (_callback !== null) {
              workInProgress.effectTag |= Callback;
              update.nextEffect = null;

              if (queue.lastEffect === null) {
                queue.firstEffect = queue.lastEffect = update;
              } else {
                queue.lastEffect.nextEffect = update;
                queue.lastEffect = update;
              }
            }
          }

          update = update.next;
        }

        var newFirstCapturedUpdate = null;
        update = queue.firstCapturedUpdate;

        while (update !== null) {
          var _updateExpirationTime = update.expirationTime;

          if (_updateExpirationTime < renderExpirationTime) {
            if (newFirstCapturedUpdate === null) {
              newFirstCapturedUpdate = update;

              if (newFirstUpdate === null) {
                newBaseState = resultState;
              }
            }

            if (newExpirationTime < _updateExpirationTime) {
              newExpirationTime = _updateExpirationTime;
            }
          } else {
            resultState = getStateFromUpdate(workInProgress, queue, update, resultState, props, instance);
            var _callback2 = update.callback;

            if (_callback2 !== null) {
              workInProgress.effectTag |= Callback;
              update.nextEffect = null;

              if (queue.lastCapturedEffect === null) {
                queue.firstCapturedEffect = queue.lastCapturedEffect = update;
              } else {
                queue.lastCapturedEffect.nextEffect = update;
                queue.lastCapturedEffect = update;
              }
            }
          }

          update = update.next;
        }

        if (newFirstUpdate === null) {
          queue.lastUpdate = null;
        }

        if (newFirstCapturedUpdate === null) {
          queue.lastCapturedUpdate = null;
        } else {
          workInProgress.effectTag |= Callback;
        }

        if (newFirstUpdate === null && newFirstCapturedUpdate === null) {
          newBaseState = resultState;
        }

        queue.baseState = newBaseState;
        queue.firstUpdate = newFirstUpdate;
        queue.firstCapturedUpdate = newFirstCapturedUpdate;
        workInProgress.expirationTime = newExpirationTime;
        workInProgress.memoizedState = resultState;
        {
          currentlyProcessingQueue = null;
        }
      }

      function callCallback(callback, context) {
        (function () {
          if (!(typeof callback === "function")) {
            throw ReactError(Error("Invalid argument passed as callback. Expected a function. Instead received: " + callback));
          }
        })();

        callback.call(context);
      }

      function resetHasForceUpdateBeforeProcessing() {
        hasForceUpdate = false;
      }

      function checkHasForceUpdateAfterProcessing() {
        return hasForceUpdate;
      }

      function commitUpdateQueue(finishedWork, finishedQueue, instance, renderExpirationTime) {
        if (finishedQueue.firstCapturedUpdate !== null) {
          if (finishedQueue.lastUpdate !== null) {
            finishedQueue.lastUpdate.next = finishedQueue.firstCapturedUpdate;
            finishedQueue.lastUpdate = finishedQueue.lastCapturedUpdate;
          }

          finishedQueue.firstCapturedUpdate = finishedQueue.lastCapturedUpdate = null;
        }

        commitUpdateEffects(finishedQueue.firstEffect, instance);
        finishedQueue.firstEffect = finishedQueue.lastEffect = null;
        commitUpdateEffects(finishedQueue.firstCapturedEffect, instance);
        finishedQueue.firstCapturedEffect = finishedQueue.lastCapturedEffect = null;
      }

      function commitUpdateEffects(effect, instance) {
        while (effect !== null) {
          var _callback3 = effect.callback;

          if (_callback3 !== null) {
            effect.callback = null;
            callCallback(_callback3, instance);
          }

          effect = effect.nextEffect;
        }
      }

      var ReactCurrentBatchConfig = ReactSharedInternals.ReactCurrentBatchConfig;

      function requestCurrentSuspenseConfig() {
        return ReactCurrentBatchConfig.suspense;
      }

      var fakeInternalInstance = {};
      var isArray$1 = Array.isArray;
      var emptyRefsObject = new React.Component().refs;
      var didWarnAboutStateAssignmentForComponent = void 0;
      var didWarnAboutUninitializedState = void 0;
      var didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate = void 0;
      var didWarnAboutLegacyLifecyclesAndDerivedState = void 0;
      var didWarnAboutUndefinedDerivedState = void 0;
      var warnOnUndefinedDerivedState = void 0;
      var warnOnInvalidCallback = void 0;
      var didWarnAboutDirectlyAssigningPropsToState = void 0;
      var didWarnAboutContextTypeAndContextTypes = void 0;
      var didWarnAboutInvalidateContextType = void 0;
      {
        didWarnAboutStateAssignmentForComponent = new Set();
        didWarnAboutUninitializedState = new Set();
        didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate = new Set();
        didWarnAboutLegacyLifecyclesAndDerivedState = new Set();
        didWarnAboutDirectlyAssigningPropsToState = new Set();
        didWarnAboutUndefinedDerivedState = new Set();
        didWarnAboutContextTypeAndContextTypes = new Set();
        didWarnAboutInvalidateContextType = new Set();
        var didWarnOnInvalidCallback = new Set();

        warnOnInvalidCallback = function warnOnInvalidCallback(callback, callerName) {
          if (callback === null || typeof callback === "function") {
            return;
          }

          var key = callerName + "_" + callback;

          if (!didWarnOnInvalidCallback.has(key)) {
            didWarnOnInvalidCallback.add(key);
            warningWithoutStack$1(false, "%s(...): Expected the last optional `callback` argument to be a " + "function. Instead received: %s.", callerName, callback);
          }
        };

        warnOnUndefinedDerivedState = function warnOnUndefinedDerivedState(type, partialState) {
          if (partialState === undefined) {
            var componentName = getComponentName(type) || "Component";

            if (!didWarnAboutUndefinedDerivedState.has(componentName)) {
              didWarnAboutUndefinedDerivedState.add(componentName);
              warningWithoutStack$1(false, "%s.getDerivedStateFromProps(): A valid state object (or null) must be returned. " + "You have returned undefined.", componentName);
            }
          }
        };

        Object.defineProperty(fakeInternalInstance, "_processChildContext", {
          enumerable: false,
          value: function value() {
            (function () {
              {
                throw ReactError(Error("_processChildContext is not available in React 16+. This likely means you have multiple copies of React and are attempting to nest a React 15 tree inside a React 16 tree using unstable_renderSubtreeIntoContainer, which isn't supported. Try to make sure you have only one copy of React (and ideally, switch to ReactDOM.createPortal)."));
              }
            })();
          }
        });
        Object.freeze(fakeInternalInstance);
      }

      function applyDerivedStateFromProps(workInProgress, ctor, getDerivedStateFromProps, nextProps) {
        var prevState = workInProgress.memoizedState;
        {
          if (debugRenderPhaseSideEffects || debugRenderPhaseSideEffectsForStrictMode && workInProgress.mode & StrictMode) {
            getDerivedStateFromProps(nextProps, prevState);
          }
        }
        var partialState = getDerivedStateFromProps(nextProps, prevState);
        {
          warnOnUndefinedDerivedState(ctor, partialState);
        }
        var memoizedState = partialState === null || partialState === undefined ? prevState : _extends({}, prevState, partialState);
        workInProgress.memoizedState = memoizedState;
        var updateQueue = workInProgress.updateQueue;

        if (updateQueue !== null && workInProgress.expirationTime === NoWork) {
          updateQueue.baseState = memoizedState;
        }
      }

      var classComponentUpdater = {
        isMounted: isMounted,
        enqueueSetState: function enqueueSetState(inst, payload, callback) {
          var fiber = get(inst);
          var currentTime = requestCurrentTime();
          var suspenseConfig = requestCurrentSuspenseConfig();
          var expirationTime = computeExpirationForFiber(currentTime, fiber, suspenseConfig);
          var update = createUpdate(expirationTime, suspenseConfig);
          update.payload = payload;

          if (callback !== undefined && callback !== null) {
            {
              warnOnInvalidCallback(callback, "setState");
            }
            update.callback = callback;
          }

          if (revertPassiveEffectsChange) {
            flushPassiveEffects();
          }

          enqueueUpdate(fiber, update);
          scheduleWork(fiber, expirationTime);
        },
        enqueueReplaceState: function enqueueReplaceState(inst, payload, callback) {
          var fiber = get(inst);
          var currentTime = requestCurrentTime();
          var suspenseConfig = requestCurrentSuspenseConfig();
          var expirationTime = computeExpirationForFiber(currentTime, fiber, suspenseConfig);
          var update = createUpdate(expirationTime, suspenseConfig);
          update.tag = ReplaceState;
          update.payload = payload;

          if (callback !== undefined && callback !== null) {
            {
              warnOnInvalidCallback(callback, "replaceState");
            }
            update.callback = callback;
          }

          if (revertPassiveEffectsChange) {
            flushPassiveEffects();
          }

          enqueueUpdate(fiber, update);
          scheduleWork(fiber, expirationTime);
        },
        enqueueForceUpdate: function enqueueForceUpdate(inst, callback) {
          var fiber = get(inst);
          var currentTime = requestCurrentTime();
          var suspenseConfig = requestCurrentSuspenseConfig();
          var expirationTime = computeExpirationForFiber(currentTime, fiber, suspenseConfig);
          var update = createUpdate(expirationTime, suspenseConfig);
          update.tag = ForceUpdate;

          if (callback !== undefined && callback !== null) {
            {
              warnOnInvalidCallback(callback, "forceUpdate");
            }
            update.callback = callback;
          }

          if (revertPassiveEffectsChange) {
            flushPassiveEffects();
          }

          enqueueUpdate(fiber, update);
          scheduleWork(fiber, expirationTime);
        }
      };

      function checkShouldComponentUpdate(workInProgress, ctor, oldProps, newProps, oldState, newState, nextContext) {
        var instance = workInProgress.stateNode;

        if (typeof instance.shouldComponentUpdate === "function") {
          startPhaseTimer(workInProgress, "shouldComponentUpdate");
          var shouldUpdate = instance.shouldComponentUpdate(newProps, newState, nextContext);
          stopPhaseTimer();
          {
            !(shouldUpdate !== undefined) ? warningWithoutStack$1(false, "%s.shouldComponentUpdate(): Returned undefined instead of a " + "boolean value. Make sure to return true or false.", getComponentName(ctor) || "Component") : void 0;
          }
          return shouldUpdate;
        }

        if (ctor.prototype && ctor.prototype.isPureReactComponent) {
          return !shallowEqual(oldProps, newProps) || !shallowEqual(oldState, newState);
        }

        return true;
      }

      function checkClassInstance(workInProgress, ctor, newProps) {
        var instance = workInProgress.stateNode;
        {
          var name = getComponentName(ctor) || "Component";
          var renderPresent = instance.render;

          if (!renderPresent) {
            if (ctor.prototype && typeof ctor.prototype.render === "function") {
              warningWithoutStack$1(false, "%s(...): No `render` method found on the returned component " + "instance: did you accidentally return an object from the constructor?", name);
            } else {
              warningWithoutStack$1(false, "%s(...): No `render` method found on the returned component " + "instance: you may have forgotten to define `render`.", name);
            }
          }

          var noGetInitialStateOnES6 = !instance.getInitialState || instance.getInitialState.isReactClassApproved || instance.state;
          !noGetInitialStateOnES6 ? warningWithoutStack$1(false, "getInitialState was defined on %s, a plain JavaScript class. " + "This is only supported for classes created using React.createClass. " + "Did you mean to define a state property instead?", name) : void 0;
          var noGetDefaultPropsOnES6 = !instance.getDefaultProps || instance.getDefaultProps.isReactClassApproved;
          !noGetDefaultPropsOnES6 ? warningWithoutStack$1(false, "getDefaultProps was defined on %s, a plain JavaScript class. " + "This is only supported for classes created using React.createClass. " + "Use a static property to define defaultProps instead.", name) : void 0;
          var noInstancePropTypes = !instance.propTypes;
          !noInstancePropTypes ? warningWithoutStack$1(false, "propTypes was defined as an instance property on %s. Use a static " + "property to define propTypes instead.", name) : void 0;
          var noInstanceContextType = !instance.contextType;
          !noInstanceContextType ? warningWithoutStack$1(false, "contextType was defined as an instance property on %s. Use a static " + "property to define contextType instead.", name) : void 0;

          if (disableLegacyContext) {
            if (ctor.childContextTypes) {
              warningWithoutStack$1(false, "%s uses the legacy childContextTypes API which is no longer supported. " + "Use React.createContext() instead.", name);
            }

            if (ctor.contextTypes) {
              warningWithoutStack$1(false, "%s uses the legacy contextTypes API which is no longer supported. " + "Use React.createContext() with static contextType instead.", name);
            }
          } else {
            var noInstanceContextTypes = !instance.contextTypes;
            !noInstanceContextTypes ? warningWithoutStack$1(false, "contextTypes was defined as an instance property on %s. Use a static " + "property to define contextTypes instead.", name) : void 0;

            if (ctor.contextType && ctor.contextTypes && !didWarnAboutContextTypeAndContextTypes.has(ctor)) {
              didWarnAboutContextTypeAndContextTypes.add(ctor);
              warningWithoutStack$1(false, "%s declares both contextTypes and contextType static properties. " + "The legacy contextTypes property will be ignored.", name);
            }
          }

          var noComponentShouldUpdate = typeof instance.componentShouldUpdate !== "function";
          !noComponentShouldUpdate ? warningWithoutStack$1(false, "%s has a method called " + "componentShouldUpdate(). Did you mean shouldComponentUpdate()? " + "The name is phrased as a question because the function is " + "expected to return a value.", name) : void 0;

          if (ctor.prototype && ctor.prototype.isPureReactComponent && typeof instance.shouldComponentUpdate !== "undefined") {
            warningWithoutStack$1(false, "%s has a method called shouldComponentUpdate(). " + "shouldComponentUpdate should not be used when extending React.PureComponent. " + "Please extend React.Component if shouldComponentUpdate is used.", getComponentName(ctor) || "A pure component");
          }

          var noComponentDidUnmount = typeof instance.componentDidUnmount !== "function";
          !noComponentDidUnmount ? warningWithoutStack$1(false, "%s has a method called " + "componentDidUnmount(). But there is no such lifecycle method. " + "Did you mean componentWillUnmount()?", name) : void 0;
          var noComponentDidReceiveProps = typeof instance.componentDidReceiveProps !== "function";
          !noComponentDidReceiveProps ? warningWithoutStack$1(false, "%s has a method called " + "componentDidReceiveProps(). But there is no such lifecycle method. " + "If you meant to update the state in response to changing props, " + "use componentWillReceiveProps(). If you meant to fetch data or " + "run side-effects or mutations after React has updated the UI, use componentDidUpdate().", name) : void 0;
          var noComponentWillRecieveProps = typeof instance.componentWillRecieveProps !== "function";
          !noComponentWillRecieveProps ? warningWithoutStack$1(false, "%s has a method called " + "componentWillRecieveProps(). Did you mean componentWillReceiveProps()?", name) : void 0;
          var noUnsafeComponentWillRecieveProps = typeof instance.UNSAFE_componentWillRecieveProps !== "function";
          !noUnsafeComponentWillRecieveProps ? warningWithoutStack$1(false, "%s has a method called " + "UNSAFE_componentWillRecieveProps(). Did you mean UNSAFE_componentWillReceiveProps()?", name) : void 0;
          var hasMutatedProps = instance.props !== newProps;
          !(instance.props === undefined || !hasMutatedProps) ? warningWithoutStack$1(false, "%s(...): When calling super() in `%s`, make sure to pass " + "up the same props that your component's constructor was passed.", name, name) : void 0;
          var noInstanceDefaultProps = !instance.defaultProps;
          !noInstanceDefaultProps ? warningWithoutStack$1(false, "Setting defaultProps as an instance property on %s is not supported and will be ignored." + " Instead, define defaultProps as a static property on %s.", name, name) : void 0;

          if (typeof instance.getSnapshotBeforeUpdate === "function" && typeof instance.componentDidUpdate !== "function" && !didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate.has(ctor)) {
            didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate.add(ctor);
            warningWithoutStack$1(false, "%s: getSnapshotBeforeUpdate() should be used with componentDidUpdate(). " + "This component defines getSnapshotBeforeUpdate() only.", getComponentName(ctor));
          }

          var noInstanceGetDerivedStateFromProps = typeof instance.getDerivedStateFromProps !== "function";
          !noInstanceGetDerivedStateFromProps ? warningWithoutStack$1(false, "%s: getDerivedStateFromProps() is defined as an instance method " + "and will be ignored. Instead, declare it as a static method.", name) : void 0;
          var noInstanceGetDerivedStateFromCatch = typeof instance.getDerivedStateFromError !== "function";
          !noInstanceGetDerivedStateFromCatch ? warningWithoutStack$1(false, "%s: getDerivedStateFromError() is defined as an instance method " + "and will be ignored. Instead, declare it as a static method.", name) : void 0;
          var noStaticGetSnapshotBeforeUpdate = typeof ctor.getSnapshotBeforeUpdate !== "function";
          !noStaticGetSnapshotBeforeUpdate ? warningWithoutStack$1(false, "%s: getSnapshotBeforeUpdate() is defined as a static method " + "and will be ignored. Instead, declare it as an instance method.", name) : void 0;
          var _state = instance.state;

          if (_state && (typeof _state !== "object" || isArray$1(_state))) {
            warningWithoutStack$1(false, "%s.state: must be set to an object or null", name);
          }

          if (typeof instance.getChildContext === "function") {
            !(typeof ctor.childContextTypes === "object") ? warningWithoutStack$1(false, "%s.getChildContext(): childContextTypes must be defined in order to " + "use getChildContext().", name) : void 0;
          }
        }
      }

      function adoptClassInstance(workInProgress, instance) {
        instance.updater = classComponentUpdater;
        workInProgress.stateNode = instance;
        set(instance, workInProgress);
        {
          instance._reactInternalInstance = fakeInternalInstance;
        }
      }

      function constructClassInstance(workInProgress, ctor, props, renderExpirationTime) {
        var isLegacyContextConsumer = false;
        var unmaskedContext = emptyContextObject;
        var context = emptyContextObject;
        var contextType = ctor.contextType;
        {
          if ("contextType" in ctor) {
            var isValid = contextType === null || contextType !== undefined && contextType.$$typeof === REACT_CONTEXT_TYPE && contextType._context === undefined;

            if (!isValid && !didWarnAboutInvalidateContextType.has(ctor)) {
              didWarnAboutInvalidateContextType.add(ctor);
              var addendum = "";

              if (contextType === undefined) {
                addendum = " However, it is set to undefined. " + "This can be caused by a typo or by mixing up named and default imports. " + "This can also happen due to a circular dependency, so " + "try moving the createContext() call to a separate file.";
              } else if (typeof contextType !== "object") {
                addendum = " However, it is set to a " + typeof contextType + ".";
              } else if (contextType.$$typeof === REACT_PROVIDER_TYPE) {
                addendum = " Did you accidentally pass the Context.Provider instead?";
              } else if (contextType._context !== undefined) {
                addendum = " Did you accidentally pass the Context.Consumer instead?";
              } else {
                addendum = " However, it is set to an object with keys {" + Object.keys(contextType).join(", ") + "}.";
              }

              warningWithoutStack$1(false, "%s defines an invalid contextType. " + "contextType should point to the Context object returned by React.createContext().%s", getComponentName(ctor) || "Component", addendum);
            }
          }
        }

        if (typeof contextType === "object" && contextType !== null) {
          context = _readContext(contextType);
        } else if (!disableLegacyContext) {
          unmaskedContext = getUnmaskedContext(workInProgress, ctor, true);
          var contextTypes = ctor.contextTypes;
          isLegacyContextConsumer = contextTypes !== null && contextTypes !== undefined;
          context = isLegacyContextConsumer ? getMaskedContext(workInProgress, unmaskedContext) : emptyContextObject;
        }

        {
          if (debugRenderPhaseSideEffects || debugRenderPhaseSideEffectsForStrictMode && workInProgress.mode & StrictMode) {
            new ctor(props, context);
          }
        }
        var instance = new ctor(props, context);
        var state = workInProgress.memoizedState = instance.state !== null && instance.state !== undefined ? instance.state : null;
        adoptClassInstance(workInProgress, instance);
        {
          if (typeof ctor.getDerivedStateFromProps === "function" && state === null) {
            var componentName = getComponentName(ctor) || "Component";

            if (!didWarnAboutUninitializedState.has(componentName)) {
              didWarnAboutUninitializedState.add(componentName);
              warningWithoutStack$1(false, "`%s` uses `getDerivedStateFromProps` but its initial state is " + "%s. This is not recommended. Instead, define the initial state by " + "assigning an object to `this.state` in the constructor of `%s`. " + "This ensures that `getDerivedStateFromProps` arguments have a consistent shape.", componentName, instance.state === null ? "null" : "undefined", componentName);
            }
          }

          if (typeof ctor.getDerivedStateFromProps === "function" || typeof instance.getSnapshotBeforeUpdate === "function") {
            var foundWillMountName = null;
            var foundWillReceivePropsName = null;
            var foundWillUpdateName = null;

            if (typeof instance.componentWillMount === "function" && instance.componentWillMount.__suppressDeprecationWarning !== true) {
              foundWillMountName = "componentWillMount";
            } else if (typeof instance.UNSAFE_componentWillMount === "function") {
              foundWillMountName = "UNSAFE_componentWillMount";
            }

            if (typeof instance.componentWillReceiveProps === "function" && instance.componentWillReceiveProps.__suppressDeprecationWarning !== true) {
              foundWillReceivePropsName = "componentWillReceiveProps";
            } else if (typeof instance.UNSAFE_componentWillReceiveProps === "function") {
              foundWillReceivePropsName = "UNSAFE_componentWillReceiveProps";
            }

            if (typeof instance.componentWillUpdate === "function" && instance.componentWillUpdate.__suppressDeprecationWarning !== true) {
              foundWillUpdateName = "componentWillUpdate";
            } else if (typeof instance.UNSAFE_componentWillUpdate === "function") {
              foundWillUpdateName = "UNSAFE_componentWillUpdate";
            }

            if (foundWillMountName !== null || foundWillReceivePropsName !== null || foundWillUpdateName !== null) {
              var _componentName = getComponentName(ctor) || "Component";

              var newApiName = typeof ctor.getDerivedStateFromProps === "function" ? "getDerivedStateFromProps()" : "getSnapshotBeforeUpdate()";

              if (!didWarnAboutLegacyLifecyclesAndDerivedState.has(_componentName)) {
                didWarnAboutLegacyLifecyclesAndDerivedState.add(_componentName);
                warningWithoutStack$1(false, "Unsafe legacy lifecycles will not be called for components using new component APIs.\n\n" + "%s uses %s but also contains the following legacy lifecycles:%s%s%s\n\n" + "The above lifecycles should be removed. Learn more about this warning here:\n" + "https://fb.me/react-async-component-lifecycle-hooks", _componentName, newApiName, foundWillMountName !== null ? "\n  " + foundWillMountName : "", foundWillReceivePropsName !== null ? "\n  " + foundWillReceivePropsName : "", foundWillUpdateName !== null ? "\n  " + foundWillUpdateName : "");
              }
            }
          }
        }

        if (isLegacyContextConsumer) {
          cacheContext(workInProgress, unmaskedContext, context);
        }

        return instance;
      }

      function callComponentWillMount(workInProgress, instance) {
        startPhaseTimer(workInProgress, "componentWillMount");
        var oldState = instance.state;

        if (typeof instance.componentWillMount === "function") {
          instance.componentWillMount();
        }

        if (typeof instance.UNSAFE_componentWillMount === "function") {
          instance.UNSAFE_componentWillMount();
        }

        stopPhaseTimer();

        if (oldState !== instance.state) {
          {
            warningWithoutStack$1(false, "%s.componentWillMount(): Assigning directly to this.state is " + "deprecated (except inside a component's " + "constructor). Use setState instead.", getComponentName(workInProgress.type) || "Component");
          }
          classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
        }
      }

      function callComponentWillReceiveProps(workInProgress, instance, newProps, nextContext) {
        var oldState = instance.state;
        startPhaseTimer(workInProgress, "componentWillReceiveProps");

        if (typeof instance.componentWillReceiveProps === "function") {
          instance.componentWillReceiveProps(newProps, nextContext);
        }

        if (typeof instance.UNSAFE_componentWillReceiveProps === "function") {
          instance.UNSAFE_componentWillReceiveProps(newProps, nextContext);
        }

        stopPhaseTimer();

        if (instance.state !== oldState) {
          {
            var componentName = getComponentName(workInProgress.type) || "Component";

            if (!didWarnAboutStateAssignmentForComponent.has(componentName)) {
              didWarnAboutStateAssignmentForComponent.add(componentName);
              warningWithoutStack$1(false, "%s.componentWillReceiveProps(): Assigning directly to " + "this.state is deprecated (except inside a component's " + "constructor). Use setState instead.", componentName);
            }
          }
          classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
        }
      }

      function mountClassInstance(workInProgress, ctor, newProps, renderExpirationTime) {
        {
          checkClassInstance(workInProgress, ctor, newProps);
        }
        var instance = workInProgress.stateNode;
        instance.props = newProps;
        instance.state = workInProgress.memoizedState;
        instance.refs = emptyRefsObject;
        var contextType = ctor.contextType;

        if (typeof contextType === "object" && contextType !== null) {
          instance.context = _readContext(contextType);
        } else if (disableLegacyContext) {
          instance.context = emptyContextObject;
        } else {
          var unmaskedContext = getUnmaskedContext(workInProgress, ctor, true);
          instance.context = getMaskedContext(workInProgress, unmaskedContext);
        }

        {
          if (instance.state === newProps) {
            var componentName = getComponentName(ctor) || "Component";

            if (!didWarnAboutDirectlyAssigningPropsToState.has(componentName)) {
              didWarnAboutDirectlyAssigningPropsToState.add(componentName);
              warningWithoutStack$1(false, "%s: It is not recommended to assign props directly to state " + "because updates to props won't be reflected in state. " + "In most cases, it is better to use props directly.", componentName);
            }
          }

          if (workInProgress.mode & StrictMode) {
            ReactStrictModeWarnings.recordLegacyContextWarning(workInProgress, instance);
          }

          if (warnAboutDeprecatedLifecycles) {
            ReactStrictModeWarnings.recordUnsafeLifecycleWarnings(workInProgress, instance);
          }
        }
        var updateQueue = workInProgress.updateQueue;

        if (updateQueue !== null) {
          processUpdateQueue(workInProgress, updateQueue, newProps, instance, renderExpirationTime);
          instance.state = workInProgress.memoizedState;
        }

        var getDerivedStateFromProps = ctor.getDerivedStateFromProps;

        if (typeof getDerivedStateFromProps === "function") {
          applyDerivedStateFromProps(workInProgress, ctor, getDerivedStateFromProps, newProps);
          instance.state = workInProgress.memoizedState;
        }

        if (typeof ctor.getDerivedStateFromProps !== "function" && typeof instance.getSnapshotBeforeUpdate !== "function" && (typeof instance.UNSAFE_componentWillMount === "function" || typeof instance.componentWillMount === "function")) {
          callComponentWillMount(workInProgress, instance);
          updateQueue = workInProgress.updateQueue;

          if (updateQueue !== null) {
            processUpdateQueue(workInProgress, updateQueue, newProps, instance, renderExpirationTime);
            instance.state = workInProgress.memoizedState;
          }
        }

        if (typeof instance.componentDidMount === "function") {
          workInProgress.effectTag |= Update;
        }
      }

      function resumeMountClassInstance(workInProgress, ctor, newProps, renderExpirationTime) {
        var instance = workInProgress.stateNode;
        var oldProps = workInProgress.memoizedProps;
        instance.props = oldProps;
        var oldContext = instance.context;
        var contextType = ctor.contextType;
        var nextContext = emptyContextObject;

        if (typeof contextType === "object" && contextType !== null) {
          nextContext = _readContext(contextType);
        } else if (!disableLegacyContext) {
          var nextLegacyUnmaskedContext = getUnmaskedContext(workInProgress, ctor, true);
          nextContext = getMaskedContext(workInProgress, nextLegacyUnmaskedContext);
        }

        var getDerivedStateFromProps = ctor.getDerivedStateFromProps;
        var hasNewLifecycles = typeof getDerivedStateFromProps === "function" || typeof instance.getSnapshotBeforeUpdate === "function";

        if (!hasNewLifecycles && (typeof instance.UNSAFE_componentWillReceiveProps === "function" || typeof instance.componentWillReceiveProps === "function")) {
          if (oldProps !== newProps || oldContext !== nextContext) {
            callComponentWillReceiveProps(workInProgress, instance, newProps, nextContext);
          }
        }

        resetHasForceUpdateBeforeProcessing();
        var oldState = workInProgress.memoizedState;
        var newState = instance.state = oldState;
        var updateQueue = workInProgress.updateQueue;

        if (updateQueue !== null) {
          processUpdateQueue(workInProgress, updateQueue, newProps, instance, renderExpirationTime);
          newState = workInProgress.memoizedState;
        }

        if (oldProps === newProps && oldState === newState && !hasContextChanged() && !checkHasForceUpdateAfterProcessing()) {
          if (typeof instance.componentDidMount === "function") {
            workInProgress.effectTag |= Update;
          }

          return false;
        }

        if (typeof getDerivedStateFromProps === "function") {
          applyDerivedStateFromProps(workInProgress, ctor, getDerivedStateFromProps, newProps);
          newState = workInProgress.memoizedState;
        }

        var shouldUpdate = checkHasForceUpdateAfterProcessing() || checkShouldComponentUpdate(workInProgress, ctor, oldProps, newProps, oldState, newState, nextContext);

        if (shouldUpdate) {
          if (!hasNewLifecycles && (typeof instance.UNSAFE_componentWillMount === "function" || typeof instance.componentWillMount === "function")) {
            startPhaseTimer(workInProgress, "componentWillMount");

            if (typeof instance.componentWillMount === "function") {
              instance.componentWillMount();
            }

            if (typeof instance.UNSAFE_componentWillMount === "function") {
              instance.UNSAFE_componentWillMount();
            }

            stopPhaseTimer();
          }

          if (typeof instance.componentDidMount === "function") {
            workInProgress.effectTag |= Update;
          }
        } else {
          if (typeof instance.componentDidMount === "function") {
            workInProgress.effectTag |= Update;
          }

          workInProgress.memoizedProps = newProps;
          workInProgress.memoizedState = newState;
        }

        instance.props = newProps;
        instance.state = newState;
        instance.context = nextContext;
        return shouldUpdate;
      }

      function updateClassInstance(current, workInProgress, ctor, newProps, renderExpirationTime) {
        var instance = workInProgress.stateNode;
        var oldProps = workInProgress.memoizedProps;
        instance.props = workInProgress.type === workInProgress.elementType ? oldProps : resolveDefaultProps(workInProgress.type, oldProps);
        var oldContext = instance.context;
        var contextType = ctor.contextType;
        var nextContext = emptyContextObject;

        if (typeof contextType === "object" && contextType !== null) {
          nextContext = _readContext(contextType);
        } else if (!disableLegacyContext) {
          var nextUnmaskedContext = getUnmaskedContext(workInProgress, ctor, true);
          nextContext = getMaskedContext(workInProgress, nextUnmaskedContext);
        }

        var getDerivedStateFromProps = ctor.getDerivedStateFromProps;
        var hasNewLifecycles = typeof getDerivedStateFromProps === "function" || typeof instance.getSnapshotBeforeUpdate === "function";

        if (!hasNewLifecycles && (typeof instance.UNSAFE_componentWillReceiveProps === "function" || typeof instance.componentWillReceiveProps === "function")) {
          if (oldProps !== newProps || oldContext !== nextContext) {
            callComponentWillReceiveProps(workInProgress, instance, newProps, nextContext);
          }
        }

        resetHasForceUpdateBeforeProcessing();
        var oldState = workInProgress.memoizedState;
        var newState = instance.state = oldState;
        var updateQueue = workInProgress.updateQueue;

        if (updateQueue !== null) {
          processUpdateQueue(workInProgress, updateQueue, newProps, instance, renderExpirationTime);
          newState = workInProgress.memoizedState;
        }

        if (oldProps === newProps && oldState === newState && !hasContextChanged() && !checkHasForceUpdateAfterProcessing()) {
          if (typeof instance.componentDidUpdate === "function") {
            if (oldProps !== current.memoizedProps || oldState !== current.memoizedState) {
              workInProgress.effectTag |= Update;
            }
          }

          if (typeof instance.getSnapshotBeforeUpdate === "function") {
            if (oldProps !== current.memoizedProps || oldState !== current.memoizedState) {
              workInProgress.effectTag |= Snapshot;
            }
          }

          return false;
        }

        if (typeof getDerivedStateFromProps === "function") {
          applyDerivedStateFromProps(workInProgress, ctor, getDerivedStateFromProps, newProps);
          newState = workInProgress.memoizedState;
        }

        var shouldUpdate = checkHasForceUpdateAfterProcessing() || checkShouldComponentUpdate(workInProgress, ctor, oldProps, newProps, oldState, newState, nextContext);

        if (shouldUpdate) {
          if (!hasNewLifecycles && (typeof instance.UNSAFE_componentWillUpdate === "function" || typeof instance.componentWillUpdate === "function")) {
            startPhaseTimer(workInProgress, "componentWillUpdate");

            if (typeof instance.componentWillUpdate === "function") {
              instance.componentWillUpdate(newProps, newState, nextContext);
            }

            if (typeof instance.UNSAFE_componentWillUpdate === "function") {
              instance.UNSAFE_componentWillUpdate(newProps, newState, nextContext);
            }

            stopPhaseTimer();
          }

          if (typeof instance.componentDidUpdate === "function") {
            workInProgress.effectTag |= Update;
          }

          if (typeof instance.getSnapshotBeforeUpdate === "function") {
            workInProgress.effectTag |= Snapshot;
          }
        } else {
          if (typeof instance.componentDidUpdate === "function") {
            if (oldProps !== current.memoizedProps || oldState !== current.memoizedState) {
              workInProgress.effectTag |= Update;
            }
          }

          if (typeof instance.getSnapshotBeforeUpdate === "function") {
            if (oldProps !== current.memoizedProps || oldState !== current.memoizedState) {
              workInProgress.effectTag |= Snapshot;
            }
          }

          workInProgress.memoizedProps = newProps;
          workInProgress.memoizedState = newState;
        }

        instance.props = newProps;
        instance.state = newState;
        instance.context = nextContext;
        return shouldUpdate;
      }

      var didWarnAboutMaps = void 0;
      var didWarnAboutGenerators = void 0;
      var didWarnAboutStringRefs = void 0;
      var ownerHasKeyUseWarning = void 0;
      var ownerHasFunctionTypeWarning = void 0;

      var warnForMissingKey = function warnForMissingKey(child) {};

      {
        didWarnAboutMaps = false;
        didWarnAboutGenerators = false;
        didWarnAboutStringRefs = {};
        ownerHasKeyUseWarning = {};
        ownerHasFunctionTypeWarning = {};

        warnForMissingKey = function warnForMissingKey(child) {
          if (child === null || typeof child !== "object") {
            return;
          }

          if (!child._store || child._store.validated || child.key != null) {
            return;
          }

          (function () {
            if (!(typeof child._store === "object")) {
              throw ReactError(Error("React Component in warnForMissingKey should have a _store. This error is likely caused by a bug in React. Please file an issue."));
            }
          })();

          child._store.validated = true;
          var currentComponentErrorInfo = "Each child in a list should have a unique " + '"key" prop. See https://fb.me/react-warning-keys for ' + "more information." + getCurrentFiberStackInDev();

          if (ownerHasKeyUseWarning[currentComponentErrorInfo]) {
            return;
          }

          ownerHasKeyUseWarning[currentComponentErrorInfo] = true;
          warning$1(false, "Each child in a list should have a unique " + '"key" prop. See https://fb.me/react-warning-keys for ' + "more information.");
        };
      }
      var isArray = Array.isArray;

      function coerceRef(returnFiber, current$$1, element) {
        var mixedRef = element.ref;

        if (mixedRef !== null && typeof mixedRef !== "function" && typeof mixedRef !== "object") {
          {
            if (returnFiber.mode & StrictMode || warnAboutStringRefs) {
              var componentName = getComponentName(returnFiber.type) || "Component";

              if (!didWarnAboutStringRefs[componentName]) {
                if (warnAboutStringRefs) {
                  warningWithoutStack$1(false, 'Component "%s" contains the string ref "%s". Support for string refs ' + "will be removed in a future major release. We recommend using " + "useRef() or createRef() instead." + "\n%s" + "\n\nLearn more about using refs safely here:" + "\nhttps://fb.me/react-strict-mode-string-ref", componentName, mixedRef, getStackByFiberInDevAndProd(returnFiber));
                } else {
                  warningWithoutStack$1(false, 'A string ref, "%s", has been found within a strict mode tree. ' + "String refs are a source of potential bugs and should be avoided. " + "We recommend using useRef() or createRef() instead." + "\n%s" + "\n\nLearn more about using refs safely here:" + "\nhttps://fb.me/react-strict-mode-string-ref", mixedRef, getStackByFiberInDevAndProd(returnFiber));
                }

                didWarnAboutStringRefs[componentName] = true;
              }
            }
          }

          if (element._owner) {
            var owner = element._owner;
            var inst = void 0;

            if (owner) {
              var ownerFiber = owner;

              (function () {
                if (!(ownerFiber.tag === ClassComponent)) {
                  throw ReactError(Error("Function components cannot have refs. Did you mean to use React.forwardRef()?"));
                }
              })();

              inst = ownerFiber.stateNode;
            }

            (function () {
              if (!inst) {
                throw ReactError(Error("Missing owner for string ref " + mixedRef + ". This error is likely caused by a bug in React. Please file an issue."));
              }
            })();

            var stringRef = "" + mixedRef;

            if (current$$1 !== null && current$$1.ref !== null && typeof current$$1.ref === "function" && current$$1.ref._stringRef === stringRef) {
              return current$$1.ref;
            }

            var ref = function ref(value) {
              var refs = inst.refs;

              if (refs === emptyRefsObject) {
                refs = inst.refs = {};
              }

              if (value === null) {
                delete refs[stringRef];
              } else {
                refs[stringRef] = value;
              }
            };

            ref._stringRef = stringRef;
            return ref;
          } else {
            (function () {
              if (!(typeof mixedRef === "string")) {
                throw ReactError(Error("Expected ref to be a function, a string, an object returned by React.createRef(), or null."));
              }
            })();

            (function () {
              if (!element._owner) {
                throw ReactError(Error("Element ref was specified as a string (" + mixedRef + ") but no owner was set. This could happen for one of the following reasons:\n1. You may be adding a ref to a function component\n2. You may be adding a ref to a component that was not created inside a component's render method\n3. You have multiple copies of React loaded\nSee https://fb.me/react-refs-must-have-owner for more information."));
              }
            })();
          }
        }

        return mixedRef;
      }

      function throwOnInvalidObjectType(returnFiber, newChild) {
        if (returnFiber.type !== "textarea") {
          var addendum = "";
          {
            addendum = " If you meant to render a collection of children, use an array " + "instead." + getCurrentFiberStackInDev();
          }

          (function () {
            {
              throw ReactError(Error("Objects are not valid as a React child (found: " + (Object.prototype.toString.call(newChild) === "[object Object]" ? "object with keys {" + Object.keys(newChild).join(", ") + "}" : newChild) + ")." + addendum));
            }
          })();
        }
      }

      function warnOnFunctionType() {
        var currentComponentErrorInfo = "Functions are not valid as a React child. This may happen if " + "you return a Component instead of <Component /> from render. " + "Or maybe you meant to call this function rather than return it." + getCurrentFiberStackInDev();

        if (ownerHasFunctionTypeWarning[currentComponentErrorInfo]) {
          return;
        }

        ownerHasFunctionTypeWarning[currentComponentErrorInfo] = true;
        warning$1(false, "Functions are not valid as a React child. This may happen if " + "you return a Component instead of <Component /> from render. " + "Or maybe you meant to call this function rather than return it.");
      }

      function ChildReconciler(shouldTrackSideEffects) {
        function deleteChild(returnFiber, childToDelete) {
          if (!shouldTrackSideEffects) {
            return;
          }

          var last = returnFiber.lastEffect;

          if (last !== null) {
            last.nextEffect = childToDelete;
            returnFiber.lastEffect = childToDelete;
          } else {
            returnFiber.firstEffect = returnFiber.lastEffect = childToDelete;
          }

          childToDelete.nextEffect = null;
          childToDelete.effectTag = Deletion;
        }

        function deleteRemainingChildren(returnFiber, currentFirstChild) {
          if (!shouldTrackSideEffects) {
            return null;
          }

          var childToDelete = currentFirstChild;

          while (childToDelete !== null) {
            deleteChild(returnFiber, childToDelete);
            childToDelete = childToDelete.sibling;
          }

          return null;
        }

        function mapRemainingChildren(returnFiber, currentFirstChild) {
          var existingChildren = new Map();
          var existingChild = currentFirstChild;

          while (existingChild !== null) {
            if (existingChild.key !== null) {
              existingChildren.set(existingChild.key, existingChild);
            } else {
              existingChildren.set(existingChild.index, existingChild);
            }

            existingChild = existingChild.sibling;
          }

          return existingChildren;
        }

        function useFiber(fiber, pendingProps, expirationTime) {
          var clone = createWorkInProgress(fiber, pendingProps, expirationTime);
          clone.index = 0;
          clone.sibling = null;
          return clone;
        }

        function placeChild(newFiber, lastPlacedIndex, newIndex) {
          newFiber.index = newIndex;

          if (!shouldTrackSideEffects) {
            return lastPlacedIndex;
          }

          var current$$1 = newFiber.alternate;

          if (current$$1 !== null) {
            var oldIndex = current$$1.index;

            if (oldIndex < lastPlacedIndex) {
              newFiber.effectTag = Placement;
              return lastPlacedIndex;
            } else {
              return oldIndex;
            }
          } else {
            newFiber.effectTag = Placement;
            return lastPlacedIndex;
          }
        }

        function placeSingleChild(newFiber) {
          if (shouldTrackSideEffects && newFiber.alternate === null) {
            newFiber.effectTag = Placement;
          }

          return newFiber;
        }

        function updateTextNode(returnFiber, current$$1, textContent, expirationTime) {
          if (current$$1 === null || current$$1.tag !== HostText) {
            var created = createFiberFromText(textContent, returnFiber.mode, expirationTime);
            created.return = returnFiber;
            return created;
          } else {
            var existing = useFiber(current$$1, textContent, expirationTime);
            existing.return = returnFiber;
            return existing;
          }
        }

        function updateElement(returnFiber, current$$1, element, expirationTime) {
          if (current$$1 !== null && (current$$1.elementType === element.type || isCompatibleFamilyForHotReloading(current$$1, element))) {
            var existing = useFiber(current$$1, element.props, expirationTime);
            existing.ref = coerceRef(returnFiber, current$$1, element);
            existing.return = returnFiber;
            {
              existing._debugSource = element._source;
              existing._debugOwner = element._owner;
            }
            return existing;
          } else {
            var created = createFiberFromElement(element, returnFiber.mode, expirationTime);
            created.ref = coerceRef(returnFiber, current$$1, element);
            created.return = returnFiber;
            return created;
          }
        }

        function updatePortal(returnFiber, current$$1, portal, expirationTime) {
          if (current$$1 === null || current$$1.tag !== HostPortal || current$$1.stateNode.containerInfo !== portal.containerInfo || current$$1.stateNode.implementation !== portal.implementation) {
            var created = createFiberFromPortal(portal, returnFiber.mode, expirationTime);
            created.return = returnFiber;
            return created;
          } else {
            var existing = useFiber(current$$1, portal.children || [], expirationTime);
            existing.return = returnFiber;
            return existing;
          }
        }

        function updateFragment(returnFiber, current$$1, fragment, expirationTime, key) {
          if (current$$1 === null || current$$1.tag !== Fragment) {
            var created = createFiberFromFragment(fragment, returnFiber.mode, expirationTime, key);
            created.return = returnFiber;
            return created;
          } else {
            var existing = useFiber(current$$1, fragment, expirationTime);
            existing.return = returnFiber;
            return existing;
          }
        }

        function createChild(returnFiber, newChild, expirationTime) {
          if (typeof newChild === "string" || typeof newChild === "number") {
            var created = createFiberFromText("" + newChild, returnFiber.mode, expirationTime);
            created.return = returnFiber;
            return created;
          }

          if (typeof newChild === "object" && newChild !== null) {
            switch (newChild.$$typeof) {
              case REACT_ELEMENT_TYPE:
                {
                  var _created = createFiberFromElement(newChild, returnFiber.mode, expirationTime);

                  _created.ref = coerceRef(returnFiber, null, newChild);
                  _created.return = returnFiber;
                  return _created;
                }

              case REACT_PORTAL_TYPE:
                {
                  var _created2 = createFiberFromPortal(newChild, returnFiber.mode, expirationTime);

                  _created2.return = returnFiber;
                  return _created2;
                }
            }

            if (isArray(newChild) || getIteratorFn(newChild)) {
              var _created3 = createFiberFromFragment(newChild, returnFiber.mode, expirationTime, null);

              _created3.return = returnFiber;
              return _created3;
            }

            throwOnInvalidObjectType(returnFiber, newChild);
          }

          {
            if (typeof newChild === "function") {
              warnOnFunctionType();
            }
          }
          return null;
        }

        function updateSlot(returnFiber, oldFiber, newChild, expirationTime) {
          var key = oldFiber !== null ? oldFiber.key : null;

          if (typeof newChild === "string" || typeof newChild === "number") {
            if (key !== null) {
              return null;
            }

            return updateTextNode(returnFiber, oldFiber, "" + newChild, expirationTime);
          }

          if (typeof newChild === "object" && newChild !== null) {
            switch (newChild.$$typeof) {
              case REACT_ELEMENT_TYPE:
                {
                  if (newChild.key === key) {
                    if (newChild.type === REACT_FRAGMENT_TYPE) {
                      return updateFragment(returnFiber, oldFiber, newChild.props.children, expirationTime, key);
                    }

                    return updateElement(returnFiber, oldFiber, newChild, expirationTime);
                  } else {
                    return null;
                  }
                }

              case REACT_PORTAL_TYPE:
                {
                  if (newChild.key === key) {
                    return updatePortal(returnFiber, oldFiber, newChild, expirationTime);
                  } else {
                    return null;
                  }
                }
            }

            if (isArray(newChild) || getIteratorFn(newChild)) {
              if (key !== null) {
                return null;
              }

              return updateFragment(returnFiber, oldFiber, newChild, expirationTime, null);
            }

            throwOnInvalidObjectType(returnFiber, newChild);
          }

          {
            if (typeof newChild === "function") {
              warnOnFunctionType();
            }
          }
          return null;
        }

        function updateFromMap(existingChildren, returnFiber, newIdx, newChild, expirationTime) {
          if (typeof newChild === "string" || typeof newChild === "number") {
            var matchedFiber = existingChildren.get(newIdx) || null;
            return updateTextNode(returnFiber, matchedFiber, "" + newChild, expirationTime);
          }

          if (typeof newChild === "object" && newChild !== null) {
            switch (newChild.$$typeof) {
              case REACT_ELEMENT_TYPE:
                {
                  var _matchedFiber = existingChildren.get(newChild.key === null ? newIdx : newChild.key) || null;

                  if (newChild.type === REACT_FRAGMENT_TYPE) {
                    return updateFragment(returnFiber, _matchedFiber, newChild.props.children, expirationTime, newChild.key);
                  }

                  return updateElement(returnFiber, _matchedFiber, newChild, expirationTime);
                }

              case REACT_PORTAL_TYPE:
                {
                  var _matchedFiber2 = existingChildren.get(newChild.key === null ? newIdx : newChild.key) || null;

                  return updatePortal(returnFiber, _matchedFiber2, newChild, expirationTime);
                }
            }

            if (isArray(newChild) || getIteratorFn(newChild)) {
              var _matchedFiber3 = existingChildren.get(newIdx) || null;

              return updateFragment(returnFiber, _matchedFiber3, newChild, expirationTime, null);
            }

            throwOnInvalidObjectType(returnFiber, newChild);
          }

          {
            if (typeof newChild === "function") {
              warnOnFunctionType();
            }
          }
          return null;
        }

        function warnOnInvalidKey(child, knownKeys) {
          {
            if (typeof child !== "object" || child === null) {
              return knownKeys;
            }

            switch (child.$$typeof) {
              case REACT_ELEMENT_TYPE:
              case REACT_PORTAL_TYPE:
                warnForMissingKey(child);
                var key = child.key;

                if (typeof key !== "string") {
                  break;
                }

                if (knownKeys === null) {
                  knownKeys = new Set();
                  knownKeys.add(key);
                  break;
                }

                if (!knownKeys.has(key)) {
                  knownKeys.add(key);
                  break;
                }

                warning$1(false, "Encountered two children with the same key, `%s`. " + "Keys should be unique so that components maintain their identity " + "across updates. Non-unique keys may cause children to be " + "duplicated and/or omitted — the behavior is unsupported and " + "could change in a future version.", key);
                break;

              default:
                break;
            }
          }
          return knownKeys;
        }

        function reconcileChildrenArray(returnFiber, currentFirstChild, newChildren, expirationTime) {
          {
            var knownKeys = null;

            for (var i = 0; i < newChildren.length; i++) {
              var child = newChildren[i];
              knownKeys = warnOnInvalidKey(child, knownKeys);
            }
          }
          var resultingFirstChild = null;
          var previousNewFiber = null;
          var oldFiber = currentFirstChild;
          var lastPlacedIndex = 0;
          var newIdx = 0;
          var nextOldFiber = null;

          for (; oldFiber !== null && newIdx < newChildren.length; newIdx++) {
            if (oldFiber.index > newIdx) {
              nextOldFiber = oldFiber;
              oldFiber = null;
            } else {
              nextOldFiber = oldFiber.sibling;
            }

            var newFiber = updateSlot(returnFiber, oldFiber, newChildren[newIdx], expirationTime);

            if (newFiber === null) {
              if (oldFiber === null) {
                oldFiber = nextOldFiber;
              }

              break;
            }

            if (shouldTrackSideEffects) {
              if (oldFiber && newFiber.alternate === null) {
                deleteChild(returnFiber, oldFiber);
              }
            }

            lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx);

            if (previousNewFiber === null) {
              resultingFirstChild = newFiber;
            } else {
              previousNewFiber.sibling = newFiber;
            }

            previousNewFiber = newFiber;
            oldFiber = nextOldFiber;
          }

          if (newIdx === newChildren.length) {
            deleteRemainingChildren(returnFiber, oldFiber);
            return resultingFirstChild;
          }

          if (oldFiber === null) {
            for (; newIdx < newChildren.length; newIdx++) {
              var _newFiber = createChild(returnFiber, newChildren[newIdx], expirationTime);

              if (_newFiber === null) {
                continue;
              }

              lastPlacedIndex = placeChild(_newFiber, lastPlacedIndex, newIdx);

              if (previousNewFiber === null) {
                resultingFirstChild = _newFiber;
              } else {
                previousNewFiber.sibling = _newFiber;
              }

              previousNewFiber = _newFiber;
            }

            return resultingFirstChild;
          }

          var existingChildren = mapRemainingChildren(returnFiber, oldFiber);

          for (; newIdx < newChildren.length; newIdx++) {
            var _newFiber2 = updateFromMap(existingChildren, returnFiber, newIdx, newChildren[newIdx], expirationTime);

            if (_newFiber2 !== null) {
              if (shouldTrackSideEffects) {
                if (_newFiber2.alternate !== null) {
                  existingChildren.delete(_newFiber2.key === null ? newIdx : _newFiber2.key);
                }
              }

              lastPlacedIndex = placeChild(_newFiber2, lastPlacedIndex, newIdx);

              if (previousNewFiber === null) {
                resultingFirstChild = _newFiber2;
              } else {
                previousNewFiber.sibling = _newFiber2;
              }

              previousNewFiber = _newFiber2;
            }
          }

          if (shouldTrackSideEffects) {
            existingChildren.forEach(function (child) {
              return deleteChild(returnFiber, child);
            });
          }

          return resultingFirstChild;
        }

        function reconcileChildrenIterator(returnFiber, currentFirstChild, newChildrenIterable, expirationTime) {
          var iteratorFn = getIteratorFn(newChildrenIterable);

          (function () {
            if (!(typeof iteratorFn === "function")) {
              throw ReactError(Error("An object is not an iterable. This error is likely caused by a bug in React. Please file an issue."));
            }
          })();

          {
            if (typeof Symbol === "function" && newChildrenIterable[typeof Symbol === "function" ? Symbol.toStringTag : "@@toStringTag"] === "Generator") {
              !didWarnAboutGenerators ? warning$1(false, "Using Generators as children is unsupported and will likely yield " + "unexpected results because enumerating a generator mutates it. " + "You may convert it to an array with `Array.from()` or the " + "`[...spread]` operator before rendering. Keep in mind " + "you might need to polyfill these features for older browsers.") : void 0;
              didWarnAboutGenerators = true;
            }

            if (newChildrenIterable.entries === iteratorFn) {
              !didWarnAboutMaps ? warning$1(false, "Using Maps as children is unsupported and will likely yield " + "unexpected results. Convert it to a sequence/iterable of keyed " + "ReactElements instead.") : void 0;
              didWarnAboutMaps = true;
            }

            var _newChildren = iteratorFn.call(newChildrenIterable);

            if (_newChildren) {
              var knownKeys = null;

              var _step = _newChildren.next();

              for (; !_step.done; _step = _newChildren.next()) {
                var child = _step.value;
                knownKeys = warnOnInvalidKey(child, knownKeys);
              }
            }
          }
          var newChildren = iteratorFn.call(newChildrenIterable);

          (function () {
            if (!(newChildren != null)) {
              throw ReactError(Error("An iterable object provided no iterator."));
            }
          })();

          var resultingFirstChild = null;
          var previousNewFiber = null;
          var oldFiber = currentFirstChild;
          var lastPlacedIndex = 0;
          var newIdx = 0;
          var nextOldFiber = null;
          var step = newChildren.next();

          for (; oldFiber !== null && !step.done; newIdx++, step = newChildren.next()) {
            if (oldFiber.index > newIdx) {
              nextOldFiber = oldFiber;
              oldFiber = null;
            } else {
              nextOldFiber = oldFiber.sibling;
            }

            var newFiber = updateSlot(returnFiber, oldFiber, step.value, expirationTime);

            if (newFiber === null) {
              if (oldFiber === null) {
                oldFiber = nextOldFiber;
              }

              break;
            }

            if (shouldTrackSideEffects) {
              if (oldFiber && newFiber.alternate === null) {
                deleteChild(returnFiber, oldFiber);
              }
            }

            lastPlacedIndex = placeChild(newFiber, lastPlacedIndex, newIdx);

            if (previousNewFiber === null) {
              resultingFirstChild = newFiber;
            } else {
              previousNewFiber.sibling = newFiber;
            }

            previousNewFiber = newFiber;
            oldFiber = nextOldFiber;
          }

          if (step.done) {
            deleteRemainingChildren(returnFiber, oldFiber);
            return resultingFirstChild;
          }

          if (oldFiber === null) {
            for (; !step.done; newIdx++, step = newChildren.next()) {
              var _newFiber3 = createChild(returnFiber, step.value, expirationTime);

              if (_newFiber3 === null) {
                continue;
              }

              lastPlacedIndex = placeChild(_newFiber3, lastPlacedIndex, newIdx);

              if (previousNewFiber === null) {
                resultingFirstChild = _newFiber3;
              } else {
                previousNewFiber.sibling = _newFiber3;
              }

              previousNewFiber = _newFiber3;
            }

            return resultingFirstChild;
          }

          var existingChildren = mapRemainingChildren(returnFiber, oldFiber);

          for (; !step.done; newIdx++, step = newChildren.next()) {
            var _newFiber4 = updateFromMap(existingChildren, returnFiber, newIdx, step.value, expirationTime);

            if (_newFiber4 !== null) {
              if (shouldTrackSideEffects) {
                if (_newFiber4.alternate !== null) {
                  existingChildren.delete(_newFiber4.key === null ? newIdx : _newFiber4.key);
                }
              }

              lastPlacedIndex = placeChild(_newFiber4, lastPlacedIndex, newIdx);

              if (previousNewFiber === null) {
                resultingFirstChild = _newFiber4;
              } else {
                previousNewFiber.sibling = _newFiber4;
              }

              previousNewFiber = _newFiber4;
            }
          }

          if (shouldTrackSideEffects) {
            existingChildren.forEach(function (child) {
              return deleteChild(returnFiber, child);
            });
          }

          return resultingFirstChild;
        }

        function reconcileSingleTextNode(returnFiber, currentFirstChild, textContent, expirationTime) {
          if (currentFirstChild !== null && currentFirstChild.tag === HostText) {
            deleteRemainingChildren(returnFiber, currentFirstChild.sibling);
            var existing = useFiber(currentFirstChild, textContent, expirationTime);
            existing.return = returnFiber;
            return existing;
          }

          deleteRemainingChildren(returnFiber, currentFirstChild);
          var created = createFiberFromText(textContent, returnFiber.mode, expirationTime);
          created.return = returnFiber;
          return created;
        }

        function reconcileSingleElement(returnFiber, currentFirstChild, element, expirationTime) {
          var key = element.key;
          var child = currentFirstChild;

          while (child !== null) {
            if (child.key === key) {
              if (child.tag === Fragment ? element.type === REACT_FRAGMENT_TYPE : child.elementType === element.type || isCompatibleFamilyForHotReloading(child, element)) {
                deleteRemainingChildren(returnFiber, child.sibling);
                var existing = useFiber(child, element.type === REACT_FRAGMENT_TYPE ? element.props.children : element.props, expirationTime);
                existing.ref = coerceRef(returnFiber, child, element);
                existing.return = returnFiber;
                {
                  existing._debugSource = element._source;
                  existing._debugOwner = element._owner;
                }
                return existing;
              } else {
                deleteRemainingChildren(returnFiber, child);
                break;
              }
            } else {
              deleteChild(returnFiber, child);
            }

            child = child.sibling;
          }

          if (element.type === REACT_FRAGMENT_TYPE) {
            var created = createFiberFromFragment(element.props.children, returnFiber.mode, expirationTime, element.key);
            created.return = returnFiber;
            return created;
          } else {
            var _created4 = createFiberFromElement(element, returnFiber.mode, expirationTime);

            _created4.ref = coerceRef(returnFiber, currentFirstChild, element);
            _created4.return = returnFiber;
            return _created4;
          }
        }

        function reconcileSinglePortal(returnFiber, currentFirstChild, portal, expirationTime) {
          var key = portal.key;
          var child = currentFirstChild;

          while (child !== null) {
            if (child.key === key) {
              if (child.tag === HostPortal && child.stateNode.containerInfo === portal.containerInfo && child.stateNode.implementation === portal.implementation) {
                deleteRemainingChildren(returnFiber, child.sibling);
                var existing = useFiber(child, portal.children || [], expirationTime);
                existing.return = returnFiber;
                return existing;
              } else {
                deleteRemainingChildren(returnFiber, child);
                break;
              }
            } else {
              deleteChild(returnFiber, child);
            }

            child = child.sibling;
          }

          var created = createFiberFromPortal(portal, returnFiber.mode, expirationTime);
          created.return = returnFiber;
          return created;
        }

        function reconcileChildFibers(returnFiber, currentFirstChild, newChild, expirationTime) {
          var isUnkeyedTopLevelFragment = typeof newChild === "object" && newChild !== null && newChild.type === REACT_FRAGMENT_TYPE && newChild.key === null;

          if (isUnkeyedTopLevelFragment) {
            newChild = newChild.props.children;
          }

          var isObject = typeof newChild === "object" && newChild !== null;

          if (isObject) {
            switch (newChild.$$typeof) {
              case REACT_ELEMENT_TYPE:
                return placeSingleChild(reconcileSingleElement(returnFiber, currentFirstChild, newChild, expirationTime));

              case REACT_PORTAL_TYPE:
                return placeSingleChild(reconcileSinglePortal(returnFiber, currentFirstChild, newChild, expirationTime));
            }
          }

          if (typeof newChild === "string" || typeof newChild === "number") {
            return placeSingleChild(reconcileSingleTextNode(returnFiber, currentFirstChild, "" + newChild, expirationTime));
          }

          if (isArray(newChild)) {
            return reconcileChildrenArray(returnFiber, currentFirstChild, newChild, expirationTime);
          }

          if (getIteratorFn(newChild)) {
            return reconcileChildrenIterator(returnFiber, currentFirstChild, newChild, expirationTime);
          }

          if (isObject) {
            throwOnInvalidObjectType(returnFiber, newChild);
          }

          {
            if (typeof newChild === "function") {
              warnOnFunctionType();
            }
          }

          if (typeof newChild === "undefined" && !isUnkeyedTopLevelFragment) {
            switch (returnFiber.tag) {
              case ClassComponent:
                {
                  {
                    var instance = returnFiber.stateNode;

                    if (instance.render._isMockFunction) {
                      break;
                    }
                  }
                }

              case FunctionComponent:
                {
                  var Component = returnFiber.type;

                  (function () {
                    {
                      throw ReactError(Error((Component.displayName || Component.name || "Component") + "(...): Nothing was returned from render. This usually means a return statement is missing. Or, to render nothing, return null."));
                    }
                  })();
                }
            }
          }

          return deleteRemainingChildren(returnFiber, currentFirstChild);
        }

        return reconcileChildFibers;
      }

      var reconcileChildFibers = ChildReconciler(true);
      var mountChildFibers = ChildReconciler(false);

      function cloneChildFibers(current$$1, workInProgress) {
        (function () {
          if (!(current$$1 === null || workInProgress.child === current$$1.child)) {
            throw ReactError(Error("Resuming work not yet implemented."));
          }
        })();

        if (workInProgress.child === null) {
          return;
        }

        var currentChild = workInProgress.child;
        var newChild = createWorkInProgress(currentChild, currentChild.pendingProps, currentChild.expirationTime);
        workInProgress.child = newChild;
        newChild.return = workInProgress;

        while (currentChild.sibling !== null) {
          currentChild = currentChild.sibling;
          newChild = newChild.sibling = createWorkInProgress(currentChild, currentChild.pendingProps, currentChild.expirationTime);
          newChild.return = workInProgress;
        }

        newChild.sibling = null;
      }

      function resetChildFibers(workInProgress, renderExpirationTime) {
        var child = workInProgress.child;

        while (child !== null) {
          resetWorkInProgress(child, renderExpirationTime);
          child = child.sibling;
        }
      }

      var NO_CONTEXT = {};
      var contextStackCursor$1 = createCursor(NO_CONTEXT);
      var contextFiberStackCursor = createCursor(NO_CONTEXT);
      var rootInstanceStackCursor = createCursor(NO_CONTEXT);

      function requiredContext(c) {
        (function () {
          if (!(c !== NO_CONTEXT)) {
            throw ReactError(Error("Expected host context to exist. This error is likely caused by a bug in React. Please file an issue."));
          }
        })();

        return c;
      }

      function getRootHostContainer() {
        var rootInstance = requiredContext(rootInstanceStackCursor.current);
        return rootInstance;
      }

      function pushHostContainer(fiber, nextRootInstance) {
        push(rootInstanceStackCursor, nextRootInstance, fiber);
        push(contextFiberStackCursor, fiber, fiber);
        push(contextStackCursor$1, NO_CONTEXT, fiber);
        var nextRootContext = getRootHostContext(nextRootInstance);
        pop(contextStackCursor$1, fiber);
        push(contextStackCursor$1, nextRootContext, fiber);
      }

      function popHostContainer(fiber) {
        pop(contextStackCursor$1, fiber);
        pop(contextFiberStackCursor, fiber);
        pop(rootInstanceStackCursor, fiber);
      }

      function getHostContext() {
        var context = requiredContext(contextStackCursor$1.current);
        return context;
      }

      function pushHostContext(fiber) {
        var rootInstance = requiredContext(rootInstanceStackCursor.current);
        var context = requiredContext(contextStackCursor$1.current);
        var nextContext = getChildHostContext(context, fiber.type, rootInstance);

        if (context === nextContext) {
          return;
        }

        push(contextFiberStackCursor, fiber, fiber);
        push(contextStackCursor$1, nextContext, fiber);
      }

      function popHostContext(fiber) {
        if (contextFiberStackCursor.current !== fiber) {
          return;
        }

        pop(contextStackCursor$1, fiber);
        pop(contextFiberStackCursor, fiber);
      }

      var DefaultSuspenseContext = 0;
      var SubtreeSuspenseContextMask = 1;
      var InvisibleParentSuspenseContext = 1;
      var ForceSuspenseFallback = 2;
      var suspenseStackCursor = createCursor(DefaultSuspenseContext);

      function hasSuspenseContext(parentContext, flag) {
        return (parentContext & flag) !== 0;
      }

      function setDefaultShallowSuspenseContext(parentContext) {
        return parentContext & SubtreeSuspenseContextMask;
      }

      function setShallowSuspenseContext(parentContext, shallowContext) {
        return parentContext & SubtreeSuspenseContextMask | shallowContext;
      }

      function addSubtreeSuspenseContext(parentContext, subtreeContext) {
        return parentContext | subtreeContext;
      }

      function pushSuspenseContext(fiber, newContext) {
        push(suspenseStackCursor, newContext, fiber);
      }

      function popSuspenseContext(fiber) {
        pop(suspenseStackCursor, fiber);
      }

      function shouldCaptureSuspense(workInProgress, hasInvisibleParent) {
        var nextState = workInProgress.memoizedState;

        if (nextState !== null) {
          return false;
        }

        var props = workInProgress.memoizedProps;

        if (props.fallback === undefined) {
          return false;
        }

        if (props.unstable_avoidThisFallback !== true) {
          return true;
        }

        if (hasInvisibleParent) {
          return false;
        }

        return true;
      }

      function findFirstSuspended(row) {
        var node = row;

        while (node !== null) {
          if (node.tag === SuspenseComponent) {
            var state = node.memoizedState;

            if (state !== null) {
              return node;
            }
          } else if (node.tag === SuspenseListComponent && node.memoizedProps.revealOrder !== undefined) {
            var didSuspend = (node.effectTag & DidCapture) !== NoEffect;

            if (didSuspend) {
              return node;
            }
          } else if (node.child !== null) {
            node.child.return = node;
            node = node.child;
            continue;
          }

          if (node === row) {
            return null;
          }

          while (node.sibling === null) {
            if (node.return === null || node.return === row) {
              return null;
            }

            node = node.return;
          }

          node.sibling.return = node.return;
          node = node.sibling;
        }

        return null;
      }

      function createResponderListener(responder, props) {
        var eventResponderListener = {
          responder: responder,
          props: props
        };
        {
          Object.freeze(eventResponderListener);
        }
        return eventResponderListener;
      }

      function createResponderInstance(responder, responderProps, responderState, target, fiber) {
        return {
          fiber: fiber,
          props: responderProps,
          responder: responder,
          rootEventTypes: null,
          state: responderState,
          target: target
        };
      }

      var NoEffect$1 = 0;
      var UnmountSnapshot = 2;
      var UnmountMutation = 4;
      var MountMutation = 8;
      var UnmountLayout = 16;
      var MountLayout = 32;
      var MountPassive = 64;
      var UnmountPassive = 128;
      var ReactCurrentDispatcher$1 = ReactSharedInternals.ReactCurrentDispatcher;
      var didWarnAboutMismatchedHooksForComponent = void 0;
      {
        didWarnAboutMismatchedHooksForComponent = new Set();
      }
      var renderExpirationTime$1 = NoWork;
      var currentlyRenderingFiber$1 = null;
      var currentHook = null;
      var nextCurrentHook = null;
      var firstWorkInProgressHook = null;
      var workInProgressHook = null;
      var nextWorkInProgressHook = null;
      var remainingExpirationTime = NoWork;
      var componentUpdateQueue = null;
      var sideEffectTag = 0;
      var didScheduleRenderPhaseUpdate = false;
      var renderPhaseUpdates = null;
      var numberOfReRenders = 0;
      var RE_RENDER_LIMIT = 25;
      var currentHookNameInDev = null;
      var hookTypesDev = null;
      var hookTypesUpdateIndexDev = -1;
      var ignorePreviousDependencies = false;

      function mountHookTypesDev() {
        {
          var hookName = currentHookNameInDev;

          if (hookTypesDev === null) {
            hookTypesDev = [hookName];
          } else {
            hookTypesDev.push(hookName);
          }
        }
      }

      function updateHookTypesDev() {
        {
          var hookName = currentHookNameInDev;

          if (hookTypesDev !== null) {
            hookTypesUpdateIndexDev++;

            if (hookTypesDev[hookTypesUpdateIndexDev] !== hookName) {
              warnOnHookMismatchInDev(hookName);
            }
          }
        }
      }

      function checkDepsAreArrayDev(deps) {
        {
          if (deps !== undefined && deps !== null && !Array.isArray(deps)) {
            warning$1(false, "%s received a final argument that is not an array (instead, received `%s`). When " + "specified, the final argument must be an array.", currentHookNameInDev, typeof deps);
          }
        }
      }

      function warnOnHookMismatchInDev(currentHookName) {
        {
          var componentName = getComponentName(currentlyRenderingFiber$1.type);

          if (!didWarnAboutMismatchedHooksForComponent.has(componentName)) {
            didWarnAboutMismatchedHooksForComponent.add(componentName);

            if (hookTypesDev !== null) {
              var table = "";
              var secondColumnStart = 30;

              for (var i = 0; i <= hookTypesUpdateIndexDev; i++) {
                var oldHookName = hookTypesDev[i];
                var newHookName = i === hookTypesUpdateIndexDev ? currentHookName : oldHookName;
                var row = i + 1 + ". " + oldHookName;

                while (row.length < secondColumnStart) {
                  row += " ";
                }

                row += newHookName + "\n";
                table += row;
              }

              warning$1(false, "React has detected a change in the order of Hooks called by %s. " + "This will lead to bugs and errors if not fixed. " + "For more information, read the Rules of Hooks: https://fb.me/rules-of-hooks\n\n" + "   Previous render            Next render\n" + "   ------------------------------------------------------\n" + "%s" + "   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", componentName, table);
            }
          }
        }
      }

      function throwInvalidHookError() {
        (function () {
          {
            throw ReactError(Error("Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of the following reasons:\n1. You might have mismatching versions of React and the renderer (such as React DOM)\n2. You might be breaking the Rules of Hooks\n3. You might have more than one copy of React in the same app\nSee https://fb.me/react-invalid-hook-call for tips about how to debug and fix this problem."));
          }
        })();
      }

      function areHookInputsEqual(nextDeps, prevDeps) {
        {
          if (ignorePreviousDependencies) {
            return false;
          }
        }

        if (prevDeps === null) {
          {
            warning$1(false, "%s received a final argument during this render, but not during " + "the previous render. Even though the final argument is optional, " + "its type cannot change between renders.", currentHookNameInDev);
          }
          return false;
        }

        {
          if (nextDeps.length !== prevDeps.length) {
            warning$1(false, "The final argument passed to %s changed size between renders. The " + "order and size of this array must remain constant.\n\n" + "Previous: %s\n" + "Incoming: %s", currentHookNameInDev, "[" + prevDeps.join(", ") + "]", "[" + nextDeps.join(", ") + "]");
          }
        }

        for (var i = 0; i < prevDeps.length && i < nextDeps.length; i++) {
          if (is(nextDeps[i], prevDeps[i])) {
            continue;
          }

          return false;
        }

        return true;
      }

      function renderWithHooks(current, workInProgress, Component, props, refOrContext, nextRenderExpirationTime) {
        renderExpirationTime$1 = nextRenderExpirationTime;
        currentlyRenderingFiber$1 = workInProgress;
        nextCurrentHook = current !== null ? current.memoizedState : null;
        {
          hookTypesDev = current !== null ? current._debugHookTypes : null;
          hookTypesUpdateIndexDev = -1;
          ignorePreviousDependencies = current !== null && current.type !== workInProgress.type;
        }
        {
          if (nextCurrentHook !== null) {
            ReactCurrentDispatcher$1.current = HooksDispatcherOnUpdateInDEV;
          } else if (hookTypesDev !== null) {
            ReactCurrentDispatcher$1.current = HooksDispatcherOnMountWithHookTypesInDEV;
          } else {
            ReactCurrentDispatcher$1.current = HooksDispatcherOnMountInDEV;
          }
        }
        var children = Component(props, refOrContext);

        if (didScheduleRenderPhaseUpdate) {
          do {
            didScheduleRenderPhaseUpdate = false;
            numberOfReRenders += 1;
            {
              ignorePreviousDependencies = false;
            }
            nextCurrentHook = current !== null ? current.memoizedState : null;
            nextWorkInProgressHook = firstWorkInProgressHook;
            currentHook = null;
            workInProgressHook = null;
            componentUpdateQueue = null;
            {
              hookTypesUpdateIndexDev = -1;
            }
            ReactCurrentDispatcher$1.current = HooksDispatcherOnUpdateInDEV;
            children = Component(props, refOrContext);
          } while (didScheduleRenderPhaseUpdate);

          renderPhaseUpdates = null;
          numberOfReRenders = 0;
        }

        ReactCurrentDispatcher$1.current = ContextOnlyDispatcher;
        var renderedWork = currentlyRenderingFiber$1;
        renderedWork.memoizedState = firstWorkInProgressHook;
        renderedWork.expirationTime = remainingExpirationTime;
        renderedWork.updateQueue = componentUpdateQueue;
        renderedWork.effectTag |= sideEffectTag;
        {
          renderedWork._debugHookTypes = hookTypesDev;
        }
        var didRenderTooFewHooks = currentHook !== null && currentHook.next !== null;
        renderExpirationTime$1 = NoWork;
        currentlyRenderingFiber$1 = null;
        currentHook = null;
        nextCurrentHook = null;
        firstWorkInProgressHook = null;
        workInProgressHook = null;
        nextWorkInProgressHook = null;
        {
          currentHookNameInDev = null;
          hookTypesDev = null;
          hookTypesUpdateIndexDev = -1;
        }
        remainingExpirationTime = NoWork;
        componentUpdateQueue = null;
        sideEffectTag = 0;

        (function () {
          if (!!didRenderTooFewHooks) {
            throw ReactError(Error("Rendered fewer hooks than expected. This may be caused by an accidental early return statement."));
          }
        })();

        return children;
      }

      function bailoutHooks(current, workInProgress, expirationTime) {
        workInProgress.updateQueue = current.updateQueue;
        workInProgress.effectTag &= ~(Passive | Update);

        if (current.expirationTime <= expirationTime) {
          current.expirationTime = NoWork;
        }
      }

      function resetHooks() {
        ReactCurrentDispatcher$1.current = ContextOnlyDispatcher;
        renderExpirationTime$1 = NoWork;
        currentlyRenderingFiber$1 = null;
        currentHook = null;
        nextCurrentHook = null;
        firstWorkInProgressHook = null;
        workInProgressHook = null;
        nextWorkInProgressHook = null;
        {
          hookTypesDev = null;
          hookTypesUpdateIndexDev = -1;
          currentHookNameInDev = null;
        }
        remainingExpirationTime = NoWork;
        componentUpdateQueue = null;
        sideEffectTag = 0;
        didScheduleRenderPhaseUpdate = false;
        renderPhaseUpdates = null;
        numberOfReRenders = 0;
      }

      function mountWorkInProgressHook() {
        var hook = {
          memoizedState: null,
          baseState: null,
          queue: null,
          baseUpdate: null,
          next: null
        };

        if (workInProgressHook === null) {
          firstWorkInProgressHook = workInProgressHook = hook;
        } else {
          workInProgressHook = workInProgressHook.next = hook;
        }

        return workInProgressHook;
      }

      function updateWorkInProgressHook() {
        if (nextWorkInProgressHook !== null) {
          workInProgressHook = nextWorkInProgressHook;
          nextWorkInProgressHook = workInProgressHook.next;
          currentHook = nextCurrentHook;
          nextCurrentHook = currentHook !== null ? currentHook.next : null;
        } else {
          (function () {
            if (!(nextCurrentHook !== null)) {
              throw ReactError(Error("Rendered more hooks than during the previous render."));
            }
          })();

          currentHook = nextCurrentHook;
          var newHook = {
            memoizedState: currentHook.memoizedState,
            baseState: currentHook.baseState,
            queue: currentHook.queue,
            baseUpdate: currentHook.baseUpdate,
            next: null
          };

          if (workInProgressHook === null) {
            workInProgressHook = firstWorkInProgressHook = newHook;
          } else {
            workInProgressHook = workInProgressHook.next = newHook;
          }

          nextCurrentHook = currentHook.next;
        }

        return workInProgressHook;
      }

      function createFunctionComponentUpdateQueue() {
        return {
          lastEffect: null
        };
      }

      function basicStateReducer(state, action) {
        return typeof action === "function" ? action(state) : action;
      }

      function mountReducer(reducer, initialArg, init) {
        var hook = mountWorkInProgressHook();
        var initialState = void 0;

        if (init !== undefined) {
          initialState = init(initialArg);
        } else {
          initialState = initialArg;
        }

        hook.memoizedState = hook.baseState = initialState;
        var queue = hook.queue = {
          last: null,
          dispatch: null,
          lastRenderedReducer: reducer,
          lastRenderedState: initialState
        };
        var dispatch = queue.dispatch = dispatchAction.bind(null, currentlyRenderingFiber$1, queue);
        return [hook.memoizedState, dispatch];
      }

      function updateReducer(reducer, initialArg, init) {
        var hook = updateWorkInProgressHook();
        var queue = hook.queue;

        (function () {
          if (!(queue !== null)) {
            throw ReactError(Error("Should have a queue. This is likely a bug in React. Please file an issue."));
          }
        })();

        queue.lastRenderedReducer = reducer;

        if (numberOfReRenders > 0) {
          var _dispatch = queue.dispatch;

          if (renderPhaseUpdates !== null) {
            var firstRenderPhaseUpdate = renderPhaseUpdates.get(queue);

            if (firstRenderPhaseUpdate !== undefined) {
              renderPhaseUpdates.delete(queue);
              var newState = hook.memoizedState;
              var update = firstRenderPhaseUpdate;

              do {
                var _action = update.action;
                newState = reducer(newState, _action);
                update = update.next;
              } while (update !== null);

              if (!is(newState, hook.memoizedState)) {
                markWorkInProgressReceivedUpdate();
              }

              hook.memoizedState = newState;

              if (hook.baseUpdate === queue.last) {
                hook.baseState = newState;
              }

              queue.lastRenderedState = newState;
              return [newState, _dispatch];
            }
          }

          return [hook.memoizedState, _dispatch];
        }

        var last = queue.last;
        var baseUpdate = hook.baseUpdate;
        var baseState = hook.baseState;
        var first = void 0;

        if (baseUpdate !== null) {
          if (last !== null) {
            last.next = null;
          }

          first = baseUpdate.next;
        } else {
          first = last !== null ? last.next : null;
        }

        if (first !== null) {
          var _newState = baseState;
          var newBaseState = null;
          var newBaseUpdate = null;
          var prevUpdate = baseUpdate;
          var _update = first;
          var didSkip = false;

          do {
            var updateExpirationTime = _update.expirationTime;

            if (updateExpirationTime < renderExpirationTime$1) {
              if (!didSkip) {
                didSkip = true;
                newBaseUpdate = prevUpdate;
                newBaseState = _newState;
              }

              if (updateExpirationTime > remainingExpirationTime) {
                remainingExpirationTime = updateExpirationTime;
              }
            } else {
              markRenderEventTimeAndConfig(updateExpirationTime, _update.suspenseConfig);

              if (_update.eagerReducer === reducer) {
                _newState = _update.eagerState;
              } else {
                var _action2 = _update.action;
                _newState = reducer(_newState, _action2);
              }
            }

            prevUpdate = _update;
            _update = _update.next;
          } while (_update !== null && _update !== first);

          if (!didSkip) {
            newBaseUpdate = prevUpdate;
            newBaseState = _newState;
          }

          if (!is(_newState, hook.memoizedState)) {
            markWorkInProgressReceivedUpdate();
          }

          hook.memoizedState = _newState;
          hook.baseUpdate = newBaseUpdate;
          hook.baseState = newBaseState;
          queue.lastRenderedState = _newState;
        }

        var dispatch = queue.dispatch;
        return [hook.memoizedState, dispatch];
      }

      function mountState(initialState) {
        var hook = mountWorkInProgressHook();

        if (typeof initialState === "function") {
          initialState = initialState();
        }

        hook.memoizedState = hook.baseState = initialState;
        var queue = hook.queue = {
          last: null,
          dispatch: null,
          lastRenderedReducer: basicStateReducer,
          lastRenderedState: initialState
        };
        var dispatch = queue.dispatch = dispatchAction.bind(null, currentlyRenderingFiber$1, queue);
        return [hook.memoizedState, dispatch];
      }

      function updateState(initialState) {
        return updateReducer(basicStateReducer, initialState);
      }

      function pushEffect(tag, create, destroy, deps) {
        var effect = {
          tag: tag,
          create: create,
          destroy: destroy,
          deps: deps,
          next: null
        };

        if (componentUpdateQueue === null) {
          componentUpdateQueue = createFunctionComponentUpdateQueue();
          componentUpdateQueue.lastEffect = effect.next = effect;
        } else {
          var _lastEffect = componentUpdateQueue.lastEffect;

          if (_lastEffect === null) {
            componentUpdateQueue.lastEffect = effect.next = effect;
          } else {
            var firstEffect = _lastEffect.next;
            _lastEffect.next = effect;
            effect.next = firstEffect;
            componentUpdateQueue.lastEffect = effect;
          }
        }

        return effect;
      }

      function mountRef(initialValue) {
        var hook = mountWorkInProgressHook();
        var ref = {
          current: initialValue
        };
        {
          Object.seal(ref);
        }
        hook.memoizedState = ref;
        return ref;
      }

      function updateRef(initialValue) {
        var hook = updateWorkInProgressHook();
        return hook.memoizedState;
      }

      function mountEffectImpl(fiberEffectTag, hookEffectTag, create, deps) {
        var hook = mountWorkInProgressHook();
        var nextDeps = deps === undefined ? null : deps;
        sideEffectTag |= fiberEffectTag;
        hook.memoizedState = pushEffect(hookEffectTag, create, undefined, nextDeps);
      }

      function updateEffectImpl(fiberEffectTag, hookEffectTag, create, deps) {
        var hook = updateWorkInProgressHook();
        var nextDeps = deps === undefined ? null : deps;
        var destroy = undefined;

        if (currentHook !== null) {
          var prevEffect = currentHook.memoizedState;
          destroy = prevEffect.destroy;

          if (nextDeps !== null) {
            var prevDeps = prevEffect.deps;

            if (areHookInputsEqual(nextDeps, prevDeps)) {
              pushEffect(NoEffect$1, create, destroy, nextDeps);
              return;
            }
          }
        }

        sideEffectTag |= fiberEffectTag;
        hook.memoizedState = pushEffect(hookEffectTag, create, destroy, nextDeps);
      }

      function mountEffect(create, deps) {
        {
          if ("undefined" !== typeof jest) {
            warnIfNotCurrentlyActingEffectsInDEV(currentlyRenderingFiber$1);
          }
        }
        return mountEffectImpl(Update | Passive, UnmountPassive | MountPassive, create, deps);
      }

      function updateEffect(create, deps) {
        {
          if ("undefined" !== typeof jest) {
            warnIfNotCurrentlyActingEffectsInDEV(currentlyRenderingFiber$1);
          }
        }
        return updateEffectImpl(Update | Passive, UnmountPassive | MountPassive, create, deps);
      }

      function mountLayoutEffect(create, deps) {
        return mountEffectImpl(Update, UnmountMutation | MountLayout, create, deps);
      }

      function updateLayoutEffect(create, deps) {
        return updateEffectImpl(Update, UnmountMutation | MountLayout, create, deps);
      }

      function imperativeHandleEffect(create, ref) {
        if (typeof ref === "function") {
          var refCallback = ref;

          var _inst = create();

          refCallback(_inst);
          return function () {
            refCallback(null);
          };
        } else if (ref !== null && ref !== undefined) {
          var refObject = ref;
          {
            !refObject.hasOwnProperty("current") ? warning$1(false, "Expected useImperativeHandle() first argument to either be a " + "ref callback or React.createRef() object. Instead received: %s.", "an object with keys {" + Object.keys(refObject).join(", ") + "}") : void 0;
          }

          var _inst2 = create();

          refObject.current = _inst2;
          return function () {
            refObject.current = null;
          };
        }
      }

      function mountImperativeHandle(ref, create, deps) {
        {
          !(typeof create === "function") ? warning$1(false, "Expected useImperativeHandle() second argument to be a function " + "that creates a handle. Instead received: %s.", create !== null ? typeof create : "null") : void 0;
        }
        var effectDeps = deps !== null && deps !== undefined ? deps.concat([ref]) : null;
        return mountEffectImpl(Update, UnmountMutation | MountLayout, imperativeHandleEffect.bind(null, create, ref), effectDeps);
      }

      function updateImperativeHandle(ref, create, deps) {
        {
          !(typeof create === "function") ? warning$1(false, "Expected useImperativeHandle() second argument to be a function " + "that creates a handle. Instead received: %s.", create !== null ? typeof create : "null") : void 0;
        }
        var effectDeps = deps !== null && deps !== undefined ? deps.concat([ref]) : null;
        return updateEffectImpl(Update, UnmountMutation | MountLayout, imperativeHandleEffect.bind(null, create, ref), effectDeps);
      }

      function mountDebugValue(value, formatterFn) {}

      var updateDebugValue = mountDebugValue;

      function mountCallback(callback, deps) {
        var hook = mountWorkInProgressHook();
        var nextDeps = deps === undefined ? null : deps;
        hook.memoizedState = [callback, nextDeps];
        return callback;
      }

      function updateCallback(callback, deps) {
        var hook = updateWorkInProgressHook();
        var nextDeps = deps === undefined ? null : deps;
        var prevState = hook.memoizedState;

        if (prevState !== null) {
          if (nextDeps !== null) {
            var prevDeps = prevState[1];

            if (areHookInputsEqual(nextDeps, prevDeps)) {
              return prevState[0];
            }
          }
        }

        hook.memoizedState = [callback, nextDeps];
        return callback;
      }

      function mountMemo(nextCreate, deps) {
        var hook = mountWorkInProgressHook();
        var nextDeps = deps === undefined ? null : deps;
        var nextValue = nextCreate();
        hook.memoizedState = [nextValue, nextDeps];
        return nextValue;
      }

      function updateMemo(nextCreate, deps) {
        var hook = updateWorkInProgressHook();
        var nextDeps = deps === undefined ? null : deps;
        var prevState = hook.memoizedState;

        if (prevState !== null) {
          if (nextDeps !== null) {
            var prevDeps = prevState[1];

            if (areHookInputsEqual(nextDeps, prevDeps)) {
              return prevState[0];
            }
          }
        }

        var nextValue = nextCreate();
        hook.memoizedState = [nextValue, nextDeps];
        return nextValue;
      }

      function dispatchAction(fiber, queue, action) {
        (function () {
          if (!(numberOfReRenders < RE_RENDER_LIMIT)) {
            throw ReactError(Error("Too many re-renders. React limits the number of renders to prevent an infinite loop."));
          }
        })();

        {
          !(arguments.length <= 3) ? warning$1(false, "State updates from the useState() and useReducer() Hooks don't support the " + "second callback argument. To execute a side effect after " + "rendering, declare it in the component body with useEffect().") : void 0;
        }
        var alternate = fiber.alternate;

        if (fiber === currentlyRenderingFiber$1 || alternate !== null && alternate === currentlyRenderingFiber$1) {
          didScheduleRenderPhaseUpdate = true;
          var update = {
            expirationTime: renderExpirationTime$1,
            suspenseConfig: null,
            action: action,
            eagerReducer: null,
            eagerState: null,
            next: null
          };
          {
            update.priority = getCurrentPriorityLevel();
          }

          if (renderPhaseUpdates === null) {
            renderPhaseUpdates = new Map();
          }

          var firstRenderPhaseUpdate = renderPhaseUpdates.get(queue);

          if (firstRenderPhaseUpdate === undefined) {
            renderPhaseUpdates.set(queue, update);
          } else {
            var lastRenderPhaseUpdate = firstRenderPhaseUpdate;

            while (lastRenderPhaseUpdate.next !== null) {
              lastRenderPhaseUpdate = lastRenderPhaseUpdate.next;
            }

            lastRenderPhaseUpdate.next = update;
          }
        } else {
          if (revertPassiveEffectsChange) {
            flushPassiveEffects();
          }

          var currentTime = requestCurrentTime();

          var _suspenseConfig = requestCurrentSuspenseConfig();

          var _expirationTime = computeExpirationForFiber(currentTime, fiber, _suspenseConfig);

          var _update2 = {
            expirationTime: _expirationTime,
            suspenseConfig: _suspenseConfig,
            action: action,
            eagerReducer: null,
            eagerState: null,
            next: null
          };
          {
            _update2.priority = getCurrentPriorityLevel();
          }
          var _last = queue.last;

          if (_last === null) {
            _update2.next = _update2;
          } else {
            var first = _last.next;

            if (first !== null) {
              _update2.next = first;
            }

            _last.next = _update2;
          }

          queue.last = _update2;

          if (fiber.expirationTime === NoWork && (alternate === null || alternate.expirationTime === NoWork)) {
            var _lastRenderedReducer = queue.lastRenderedReducer;

            if (_lastRenderedReducer !== null) {
              var prevDispatcher = void 0;
              {
                prevDispatcher = ReactCurrentDispatcher$1.current;
                ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnUpdateInDEV;
              }

              try {
                var currentState = queue.lastRenderedState;

                var _eagerState = _lastRenderedReducer(currentState, action);

                _update2.eagerReducer = _lastRenderedReducer;
                _update2.eagerState = _eagerState;

                if (is(_eagerState, currentState)) {
                  return;
                }
              } catch (error) {} finally {
                {
                  ReactCurrentDispatcher$1.current = prevDispatcher;
                }
              }
            }
          }

          {
            if ("undefined" !== typeof jest) {
              warnIfNotScopedWithMatchingAct(fiber);
              warnIfNotCurrentlyActingUpdatesInDev(fiber);
            }
          }
          scheduleWork(fiber, _expirationTime);
        }
      }

      var ContextOnlyDispatcher = {
        readContext: _readContext,
        useCallback: throwInvalidHookError,
        useContext: throwInvalidHookError,
        useEffect: throwInvalidHookError,
        useImperativeHandle: throwInvalidHookError,
        useLayoutEffect: throwInvalidHookError,
        useMemo: throwInvalidHookError,
        useReducer: throwInvalidHookError,
        useRef: throwInvalidHookError,
        useState: throwInvalidHookError,
        useDebugValue: throwInvalidHookError,
        useResponder: throwInvalidHookError
      };
      var HooksDispatcherOnMountInDEV = null;
      var HooksDispatcherOnMountWithHookTypesInDEV = null;
      var HooksDispatcherOnUpdateInDEV = null;
      var InvalidNestedHooksDispatcherOnMountInDEV = null;
      var InvalidNestedHooksDispatcherOnUpdateInDEV = null;
      {
        var warnInvalidContextAccess = function warnInvalidContextAccess() {
          warning$1(false, "Context can only be read while React is rendering. " + "In classes, you can read it in the render method or getDerivedStateFromProps. " + "In function components, you can read it directly in the function body, but not " + "inside Hooks like useReducer() or useMemo().");
        };

        var warnInvalidHookAccess = function warnInvalidHookAccess() {
          warning$1(false, "Do not call Hooks inside useEffect(...), useMemo(...), or other built-in Hooks. " + "You can only call Hooks at the top level of your React function. " + "For more information, see " + "https://fb.me/rules-of-hooks");
        };

        HooksDispatcherOnMountInDEV = {
          readContext: function readContext(context, observedBits) {
            return _readContext(context, observedBits);
          },
          useCallback: function useCallback(callback, deps) {
            currentHookNameInDev = "useCallback";
            mountHookTypesDev();
            checkDepsAreArrayDev(deps);
            return mountCallback(callback, deps);
          },
          useContext: function useContext(context, observedBits) {
            currentHookNameInDev = "useContext";
            mountHookTypesDev();
            return _readContext(context, observedBits);
          },
          useEffect: function useEffect(create, deps) {
            currentHookNameInDev = "useEffect";
            mountHookTypesDev();
            checkDepsAreArrayDev(deps);
            return mountEffect(create, deps);
          },
          useImperativeHandle: function useImperativeHandle(ref, create, deps) {
            currentHookNameInDev = "useImperativeHandle";
            mountHookTypesDev();
            checkDepsAreArrayDev(deps);
            return mountImperativeHandle(ref, create, deps);
          },
          useLayoutEffect: function useLayoutEffect(create, deps) {
            currentHookNameInDev = "useLayoutEffect";
            mountHookTypesDev();
            checkDepsAreArrayDev(deps);
            return mountLayoutEffect(create, deps);
          },
          useMemo: function useMemo(create, deps) {
            currentHookNameInDev = "useMemo";
            mountHookTypesDev();
            checkDepsAreArrayDev(deps);
            var prevDispatcher = ReactCurrentDispatcher$1.current;
            ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnMountInDEV;

            try {
              return mountMemo(create, deps);
            } finally {
              ReactCurrentDispatcher$1.current = prevDispatcher;
            }
          },
          useReducer: function useReducer(reducer, initialArg, init) {
            currentHookNameInDev = "useReducer";
            mountHookTypesDev();
            var prevDispatcher = ReactCurrentDispatcher$1.current;
            ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnMountInDEV;

            try {
              return mountReducer(reducer, initialArg, init);
            } finally {
              ReactCurrentDispatcher$1.current = prevDispatcher;
            }
          },
          useRef: function useRef(initialValue) {
            currentHookNameInDev = "useRef";
            mountHookTypesDev();
            return mountRef(initialValue);
          },
          useState: function useState(initialState) {
            currentHookNameInDev = "useState";
            mountHookTypesDev();
            var prevDispatcher = ReactCurrentDispatcher$1.current;
            ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnMountInDEV;

            try {
              return mountState(initialState);
            } finally {
              ReactCurrentDispatcher$1.current = prevDispatcher;
            }
          },
          useDebugValue: function useDebugValue(value, formatterFn) {
            currentHookNameInDev = "useDebugValue";
            mountHookTypesDev();
            return mountDebugValue(value, formatterFn);
          },
          useResponder: function useResponder(responder, props) {
            currentHookNameInDev = "useResponder";
            mountHookTypesDev();
            return createResponderListener(responder, props);
          }
        };
        HooksDispatcherOnMountWithHookTypesInDEV = {
          readContext: function readContext(context, observedBits) {
            return _readContext(context, observedBits);
          },
          useCallback: function useCallback(callback, deps) {
            currentHookNameInDev = "useCallback";
            updateHookTypesDev();
            return mountCallback(callback, deps);
          },
          useContext: function useContext(context, observedBits) {
            currentHookNameInDev = "useContext";
            updateHookTypesDev();
            return _readContext(context, observedBits);
          },
          useEffect: function useEffect(create, deps) {
            currentHookNameInDev = "useEffect";
            updateHookTypesDev();
            return mountEffect(create, deps);
          },
          useImperativeHandle: function useImperativeHandle(ref, create, deps) {
            currentHookNameInDev = "useImperativeHandle";
            updateHookTypesDev();
            return mountImperativeHandle(ref, create, deps);
          },
          useLayoutEffect: function useLayoutEffect(create, deps) {
            currentHookNameInDev = "useLayoutEffect";
            updateHookTypesDev();
            return mountLayoutEffect(create, deps);
          },
          useMemo: function useMemo(create, deps) {
            currentHookNameInDev = "useMemo";
            updateHookTypesDev();
            var prevDispatcher = ReactCurrentDispatcher$1.current;
            ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnMountInDEV;

            try {
              return mountMemo(create, deps);
            } finally {
              ReactCurrentDispatcher$1.current = prevDispatcher;
            }
          },
          useReducer: function useReducer(reducer, initialArg, init) {
            currentHookNameInDev = "useReducer";
            updateHookTypesDev();
            var prevDispatcher = ReactCurrentDispatcher$1.current;
            ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnMountInDEV;

            try {
              return mountReducer(reducer, initialArg, init);
            } finally {
              ReactCurrentDispatcher$1.current = prevDispatcher;
            }
          },
          useRef: function useRef(initialValue) {
            currentHookNameInDev = "useRef";
            updateHookTypesDev();
            return mountRef(initialValue);
          },
          useState: function useState(initialState) {
            currentHookNameInDev = "useState";
            updateHookTypesDev();
            var prevDispatcher = ReactCurrentDispatcher$1.current;
            ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnMountInDEV;

            try {
              return mountState(initialState);
            } finally {
              ReactCurrentDispatcher$1.current = prevDispatcher;
            }
          },
          useDebugValue: function useDebugValue(value, formatterFn) {
            currentHookNameInDev = "useDebugValue";
            updateHookTypesDev();
            return mountDebugValue(value, formatterFn);
          },
          useResponder: function useResponder(responder, props) {
            currentHookNameInDev = "useResponder";
            updateHookTypesDev();
            return createResponderListener(responder, props);
          }
        };
        HooksDispatcherOnUpdateInDEV = {
          readContext: function readContext(context, observedBits) {
            return _readContext(context, observedBits);
          },
          useCallback: function useCallback(callback, deps) {
            currentHookNameInDev = "useCallback";
            updateHookTypesDev();
            return updateCallback(callback, deps);
          },
          useContext: function useContext(context, observedBits) {
            currentHookNameInDev = "useContext";
            updateHookTypesDev();
            return _readContext(context, observedBits);
          },
          useEffect: function useEffect(create, deps) {
            currentHookNameInDev = "useEffect";
            updateHookTypesDev();
            return updateEffect(create, deps);
          },
          useImperativeHandle: function useImperativeHandle(ref, create, deps) {
            currentHookNameInDev = "useImperativeHandle";
            updateHookTypesDev();
            return updateImperativeHandle(ref, create, deps);
          },
          useLayoutEffect: function useLayoutEffect(create, deps) {
            currentHookNameInDev = "useLayoutEffect";
            updateHookTypesDev();
            return updateLayoutEffect(create, deps);
          },
          useMemo: function useMemo(create, deps) {
            currentHookNameInDev = "useMemo";
            updateHookTypesDev();
            var prevDispatcher = ReactCurrentDispatcher$1.current;
            ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnUpdateInDEV;

            try {
              return updateMemo(create, deps);
            } finally {
              ReactCurrentDispatcher$1.current = prevDispatcher;
            }
          },
          useReducer: function useReducer(reducer, initialArg, init) {
            currentHookNameInDev = "useReducer";
            updateHookTypesDev();
            var prevDispatcher = ReactCurrentDispatcher$1.current;
            ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnUpdateInDEV;

            try {
              return updateReducer(reducer, initialArg, init);
            } finally {
              ReactCurrentDispatcher$1.current = prevDispatcher;
            }
          },
          useRef: function useRef(initialValue) {
            currentHookNameInDev = "useRef";
            updateHookTypesDev();
            return updateRef(initialValue);
          },
          useState: function useState(initialState) {
            currentHookNameInDev = "useState";
            updateHookTypesDev();
            var prevDispatcher = ReactCurrentDispatcher$1.current;
            ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnUpdateInDEV;

            try {
              return updateState(initialState);
            } finally {
              ReactCurrentDispatcher$1.current = prevDispatcher;
            }
          },
          useDebugValue: function useDebugValue(value, formatterFn) {
            currentHookNameInDev = "useDebugValue";
            updateHookTypesDev();
            return updateDebugValue(value, formatterFn);
          },
          useResponder: function useResponder(responder, props) {
            currentHookNameInDev = "useResponder";
            updateHookTypesDev();
            return createResponderListener(responder, props);
          }
        };
        InvalidNestedHooksDispatcherOnMountInDEV = {
          readContext: function readContext(context, observedBits) {
            warnInvalidContextAccess();
            return _readContext(context, observedBits);
          },
          useCallback: function useCallback(callback, deps) {
            currentHookNameInDev = "useCallback";
            warnInvalidHookAccess();
            mountHookTypesDev();
            return mountCallback(callback, deps);
          },
          useContext: function useContext(context, observedBits) {
            currentHookNameInDev = "useContext";
            warnInvalidHookAccess();
            mountHookTypesDev();
            return _readContext(context, observedBits);
          },
          useEffect: function useEffect(create, deps) {
            currentHookNameInDev = "useEffect";
            warnInvalidHookAccess();
            mountHookTypesDev();
            return mountEffect(create, deps);
          },
          useImperativeHandle: function useImperativeHandle(ref, create, deps) {
            currentHookNameInDev = "useImperativeHandle";
            warnInvalidHookAccess();
            mountHookTypesDev();
            return mountImperativeHandle(ref, create, deps);
          },
          useLayoutEffect: function useLayoutEffect(create, deps) {
            currentHookNameInDev = "useLayoutEffect";
            warnInvalidHookAccess();
            mountHookTypesDev();
            return mountLayoutEffect(create, deps);
          },
          useMemo: function useMemo(create, deps) {
            currentHookNameInDev = "useMemo";
            warnInvalidHookAccess();
            mountHookTypesDev();
            var prevDispatcher = ReactCurrentDispatcher$1.current;
            ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnMountInDEV;

            try {
              return mountMemo(create, deps);
            } finally {
              ReactCurrentDispatcher$1.current = prevDispatcher;
            }
          },
          useReducer: function useReducer(reducer, initialArg, init) {
            currentHookNameInDev = "useReducer";
            warnInvalidHookAccess();
            mountHookTypesDev();
            var prevDispatcher = ReactCurrentDispatcher$1.current;
            ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnMountInDEV;

            try {
              return mountReducer(reducer, initialArg, init);
            } finally {
              ReactCurrentDispatcher$1.current = prevDispatcher;
            }
          },
          useRef: function useRef(initialValue) {
            currentHookNameInDev = "useRef";
            warnInvalidHookAccess();
            mountHookTypesDev();
            return mountRef(initialValue);
          },
          useState: function useState(initialState) {
            currentHookNameInDev = "useState";
            warnInvalidHookAccess();
            mountHookTypesDev();
            var prevDispatcher = ReactCurrentDispatcher$1.current;
            ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnMountInDEV;

            try {
              return mountState(initialState);
            } finally {
              ReactCurrentDispatcher$1.current = prevDispatcher;
            }
          },
          useDebugValue: function useDebugValue(value, formatterFn) {
            currentHookNameInDev = "useDebugValue";
            warnInvalidHookAccess();
            mountHookTypesDev();
            return mountDebugValue(value, formatterFn);
          },
          useResponder: function useResponder(responder, props) {
            currentHookNameInDev = "useResponder";
            warnInvalidHookAccess();
            mountHookTypesDev();
            return createResponderListener(responder, props);
          }
        };
        InvalidNestedHooksDispatcherOnUpdateInDEV = {
          readContext: function readContext(context, observedBits) {
            warnInvalidContextAccess();
            return _readContext(context, observedBits);
          },
          useCallback: function useCallback(callback, deps) {
            currentHookNameInDev = "useCallback";
            warnInvalidHookAccess();
            updateHookTypesDev();
            return updateCallback(callback, deps);
          },
          useContext: function useContext(context, observedBits) {
            currentHookNameInDev = "useContext";
            warnInvalidHookAccess();
            updateHookTypesDev();
            return _readContext(context, observedBits);
          },
          useEffect: function useEffect(create, deps) {
            currentHookNameInDev = "useEffect";
            warnInvalidHookAccess();
            updateHookTypesDev();
            return updateEffect(create, deps);
          },
          useImperativeHandle: function useImperativeHandle(ref, create, deps) {
            currentHookNameInDev = "useImperativeHandle";
            warnInvalidHookAccess();
            updateHookTypesDev();
            return updateImperativeHandle(ref, create, deps);
          },
          useLayoutEffect: function useLayoutEffect(create, deps) {
            currentHookNameInDev = "useLayoutEffect";
            warnInvalidHookAccess();
            updateHookTypesDev();
            return updateLayoutEffect(create, deps);
          },
          useMemo: function useMemo(create, deps) {
            currentHookNameInDev = "useMemo";
            warnInvalidHookAccess();
            updateHookTypesDev();
            var prevDispatcher = ReactCurrentDispatcher$1.current;
            ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnUpdateInDEV;

            try {
              return updateMemo(create, deps);
            } finally {
              ReactCurrentDispatcher$1.current = prevDispatcher;
            }
          },
          useReducer: function useReducer(reducer, initialArg, init) {
            currentHookNameInDev = "useReducer";
            warnInvalidHookAccess();
            updateHookTypesDev();
            var prevDispatcher = ReactCurrentDispatcher$1.current;
            ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnUpdateInDEV;

            try {
              return updateReducer(reducer, initialArg, init);
            } finally {
              ReactCurrentDispatcher$1.current = prevDispatcher;
            }
          },
          useRef: function useRef(initialValue) {
            currentHookNameInDev = "useRef";
            warnInvalidHookAccess();
            updateHookTypesDev();
            return updateRef(initialValue);
          },
          useState: function useState(initialState) {
            currentHookNameInDev = "useState";
            warnInvalidHookAccess();
            updateHookTypesDev();
            var prevDispatcher = ReactCurrentDispatcher$1.current;
            ReactCurrentDispatcher$1.current = InvalidNestedHooksDispatcherOnUpdateInDEV;

            try {
              return updateState(initialState);
            } finally {
              ReactCurrentDispatcher$1.current = prevDispatcher;
            }
          },
          useDebugValue: function useDebugValue(value, formatterFn) {
            currentHookNameInDev = "useDebugValue";
            warnInvalidHookAccess();
            updateHookTypesDev();
            return updateDebugValue(value, formatterFn);
          },
          useResponder: function useResponder(responder, props) {
            currentHookNameInDev = "useResponder";
            warnInvalidHookAccess();
            updateHookTypesDev();
            return createResponderListener(responder, props);
          }
        };
      }
      var now$1 = Scheduler.unstable_now;
      var commitTime = 0;
      var profilerStartTime = -1;

      function getCommitTime() {
        return commitTime;
      }

      function recordCommitTime() {
        if (!enableProfilerTimer) {
          return;
        }

        commitTime = now$1();
      }

      function startProfilerTimer(fiber) {
        if (!enableProfilerTimer) {
          return;
        }

        profilerStartTime = now$1();

        if (fiber.actualStartTime < 0) {
          fiber.actualStartTime = now$1();
        }
      }

      function stopProfilerTimerIfRunning(fiber) {
        if (!enableProfilerTimer) {
          return;
        }

        profilerStartTime = -1;
      }

      function stopProfilerTimerIfRunningAndRecordDelta(fiber, overrideBaseTime) {
        if (!enableProfilerTimer) {
          return;
        }

        if (profilerStartTime >= 0) {
          var elapsedTime = now$1() - profilerStartTime;
          fiber.actualDuration += elapsedTime;

          if (overrideBaseTime) {
            fiber.selfBaseDuration = elapsedTime;
          }

          profilerStartTime = -1;
        }
      }

      var hydrationParentFiber = null;
      var nextHydratableInstance = null;
      var isHydrating = false;

      function warnIfHydrating() {
        {
          !!isHydrating ? warning$1(false, "We should not be hydrating here. This is a bug in React. Please file a bug.") : void 0;
        }
      }

      function enterHydrationState(fiber) {
        if (!supportsHydration) {
          return false;
        }

        var parentInstance = fiber.stateNode.containerInfo;
        nextHydratableInstance = getFirstHydratableChild(parentInstance);
        hydrationParentFiber = fiber;
        isHydrating = true;
        return true;
      }

      function reenterHydrationStateFromDehydratedSuspenseInstance(fiber) {
        if (!supportsHydration) {
          return false;
        }

        var suspenseInstance = fiber.stateNode;
        nextHydratableInstance = getNextHydratableSibling(suspenseInstance);
        popToNextHostParent(fiber);
        isHydrating = true;
        return true;
      }

      function deleteHydratableInstance(returnFiber, instance) {
        {
          switch (returnFiber.tag) {
            case HostRoot:
              didNotHydrateContainerInstance(returnFiber.stateNode.containerInfo, instance);
              break;

            case HostComponent:
              didNotHydrateInstance(returnFiber.type, returnFiber.memoizedProps, returnFiber.stateNode, instance);
              break;
          }
        }
        var childToDelete = createFiberFromHostInstanceForDeletion();
        childToDelete.stateNode = instance;
        childToDelete.return = returnFiber;
        childToDelete.effectTag = Deletion;

        if (returnFiber.lastEffect !== null) {
          returnFiber.lastEffect.nextEffect = childToDelete;
          returnFiber.lastEffect = childToDelete;
        } else {
          returnFiber.firstEffect = returnFiber.lastEffect = childToDelete;
        }
      }

      function insertNonHydratedInstance(returnFiber, fiber) {
        fiber.effectTag |= Placement;
        {
          switch (returnFiber.tag) {
            case HostRoot:
              {
                var parentContainer = returnFiber.stateNode.containerInfo;

                switch (fiber.tag) {
                  case HostComponent:
                    var type = fiber.type;
                    var props = fiber.pendingProps;
                    didNotFindHydratableContainerInstance(parentContainer, type, props);
                    break;

                  case HostText:
                    var text = fiber.pendingProps;
                    didNotFindHydratableContainerTextInstance(parentContainer, text);
                    break;

                  case SuspenseComponent:
                    didNotFindHydratableContainerSuspenseInstance(parentContainer);
                    break;
                }

                break;
              }

            case HostComponent:
              {
                var parentType = returnFiber.type;
                var parentProps = returnFiber.memoizedProps;
                var parentInstance = returnFiber.stateNode;

                switch (fiber.tag) {
                  case HostComponent:
                    var _type = fiber.type;
                    var _props = fiber.pendingProps;
                    didNotFindHydratableInstance(parentType, parentProps, parentInstance, _type, _props);
                    break;

                  case HostText:
                    var _text = fiber.pendingProps;
                    didNotFindHydratableTextInstance(parentType, parentProps, parentInstance, _text);
                    break;

                  case SuspenseComponent:
                    didNotFindHydratableSuspenseInstance(parentType, parentProps, parentInstance);
                    break;
                }

                break;
              }

            default:
              return;
          }
        }
      }

      function tryHydrate(fiber, nextInstance) {
        switch (fiber.tag) {
          case HostComponent:
            {
              var type = fiber.type;
              var props = fiber.pendingProps;
              var instance = canHydrateInstance(nextInstance, type, props);

              if (instance !== null) {
                fiber.stateNode = instance;
                return true;
              }

              return false;
            }

          case HostText:
            {
              var text = fiber.pendingProps;
              var textInstance = canHydrateTextInstance(nextInstance, text);

              if (textInstance !== null) {
                fiber.stateNode = textInstance;
                return true;
              }

              return false;
            }

          case SuspenseComponent:
            {
              if (enableSuspenseServerRenderer) {
                var suspenseInstance = canHydrateSuspenseInstance(nextInstance);

                if (suspenseInstance !== null) {
                  fiber.tag = DehydratedSuspenseComponent;
                  fiber.stateNode = suspenseInstance;
                  return true;
                }
              }

              return false;
            }

          default:
            return false;
        }
      }

      function tryToClaimNextHydratableInstance(fiber) {
        if (!isHydrating) {
          return;
        }

        var nextInstance = nextHydratableInstance;

        if (!nextInstance) {
          insertNonHydratedInstance(hydrationParentFiber, fiber);
          isHydrating = false;
          hydrationParentFiber = fiber;
          return;
        }

        var firstAttemptedInstance = nextInstance;

        if (!tryHydrate(fiber, nextInstance)) {
          nextInstance = getNextHydratableSibling(firstAttemptedInstance);

          if (!nextInstance || !tryHydrate(fiber, nextInstance)) {
            insertNonHydratedInstance(hydrationParentFiber, fiber);
            isHydrating = false;
            hydrationParentFiber = fiber;
            return;
          }

          deleteHydratableInstance(hydrationParentFiber, firstAttemptedInstance);
        }

        hydrationParentFiber = fiber;
        nextHydratableInstance = getFirstHydratableChild(nextInstance);
      }

      function prepareToHydrateHostInstance(fiber, rootContainerInstance, hostContext) {
        if (!supportsHydration) {
          (function () {
            {
              throw ReactError(Error("Expected prepareToHydrateHostInstance() to never be called. This error is likely caused by a bug in React. Please file an issue."));
            }
          })();
        }

        var instance = fiber.stateNode;
        var updatePayload = hydrateInstance(instance, fiber.type, fiber.memoizedProps, rootContainerInstance, hostContext, fiber);
        fiber.updateQueue = updatePayload;

        if (updatePayload !== null) {
          return true;
        }

        return false;
      }

      function prepareToHydrateHostTextInstance(fiber) {
        if (!supportsHydration) {
          (function () {
            {
              throw ReactError(Error("Expected prepareToHydrateHostTextInstance() to never be called. This error is likely caused by a bug in React. Please file an issue."));
            }
          })();
        }

        var textInstance = fiber.stateNode;
        var textContent = fiber.memoizedProps;
        var shouldUpdate = hydrateTextInstance(textInstance, textContent, fiber);
        {
          if (shouldUpdate) {
            var returnFiber = hydrationParentFiber;

            if (returnFiber !== null) {
              switch (returnFiber.tag) {
                case HostRoot:
                  {
                    var parentContainer = returnFiber.stateNode.containerInfo;
                    didNotMatchHydratedContainerTextInstance(parentContainer, textInstance, textContent);
                    break;
                  }

                case HostComponent:
                  {
                    var parentType = returnFiber.type;
                    var parentProps = returnFiber.memoizedProps;
                    var parentInstance = returnFiber.stateNode;
                    didNotMatchHydratedTextInstance(parentType, parentProps, parentInstance, textInstance, textContent);
                    break;
                  }
              }
            }
          }
        }
        return shouldUpdate;
      }

      function skipPastDehydratedSuspenseInstance(fiber) {
        if (!supportsHydration) {
          (function () {
            {
              throw ReactError(Error("Expected skipPastDehydratedSuspenseInstance() to never be called. This error is likely caused by a bug in React. Please file an issue."));
            }
          })();
        }

        var suspenseInstance = fiber.stateNode;

        (function () {
          if (!suspenseInstance) {
            throw ReactError(Error("Expected to have a hydrated suspense instance. This error is likely caused by a bug in React. Please file an issue."));
          }
        })();

        nextHydratableInstance = getNextHydratableInstanceAfterSuspenseInstance(suspenseInstance);
      }

      function popToNextHostParent(fiber) {
        var parent = fiber.return;

        while (parent !== null && parent.tag !== HostComponent && parent.tag !== HostRoot && parent.tag !== DehydratedSuspenseComponent) {
          parent = parent.return;
        }

        hydrationParentFiber = parent;
      }

      function popHydrationState(fiber) {
        if (!supportsHydration) {
          return false;
        }

        if (fiber !== hydrationParentFiber) {
          return false;
        }

        if (!isHydrating) {
          popToNextHostParent(fiber);
          isHydrating = true;
          return false;
        }

        var type = fiber.type;

        if (fiber.tag !== HostComponent || type !== "head" && type !== "body" && !shouldSetTextContent(type, fiber.memoizedProps)) {
          var nextInstance = nextHydratableInstance;

          while (nextInstance) {
            deleteHydratableInstance(fiber, nextInstance);
            nextInstance = getNextHydratableSibling(nextInstance);
          }
        }

        popToNextHostParent(fiber);
        nextHydratableInstance = hydrationParentFiber ? getNextHydratableSibling(fiber.stateNode) : null;
        return true;
      }

      function resetHydrationState() {
        if (!supportsHydration) {
          return;
        }

        hydrationParentFiber = null;
        nextHydratableInstance = null;
        isHydrating = false;
      }

      var ReactCurrentOwner$3 = ReactSharedInternals.ReactCurrentOwner;
      var didReceiveUpdate = false;
      var didWarnAboutBadClass = void 0;
      var didWarnAboutModulePatternComponent = void 0;
      var didWarnAboutContextTypeOnFunctionComponent = void 0;
      var didWarnAboutGetDerivedStateOnFunctionComponent = void 0;
      var didWarnAboutFunctionRefs = void 0;
      var didWarnAboutReassigningProps = void 0;
      var didWarnAboutMaxDuration = void 0;
      var didWarnAboutRevealOrder = void 0;
      var didWarnAboutTailOptions = void 0;
      var didWarnAboutDefaultPropsOnFunctionComponent = void 0;
      {
        didWarnAboutBadClass = {};
        didWarnAboutModulePatternComponent = {};
        didWarnAboutContextTypeOnFunctionComponent = {};
        didWarnAboutGetDerivedStateOnFunctionComponent = {};
        didWarnAboutFunctionRefs = {};
        didWarnAboutReassigningProps = false;
        didWarnAboutMaxDuration = false;
        didWarnAboutRevealOrder = {};
        didWarnAboutTailOptions = {};
        didWarnAboutDefaultPropsOnFunctionComponent = {};
      }

      function reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime) {
        if (current$$1 === null) {
          workInProgress.child = mountChildFibers(workInProgress, null, nextChildren, renderExpirationTime);
        } else {
          workInProgress.child = reconcileChildFibers(workInProgress, current$$1.child, nextChildren, renderExpirationTime);
        }
      }

      function forceUnmountCurrentAndReconcile(current$$1, workInProgress, nextChildren, renderExpirationTime) {
        workInProgress.child = reconcileChildFibers(workInProgress, current$$1.child, null, renderExpirationTime);
        workInProgress.child = reconcileChildFibers(workInProgress, null, nextChildren, renderExpirationTime);
      }

      function updateForwardRef(current$$1, workInProgress, Component, nextProps, renderExpirationTime) {
        {
          if (workInProgress.type !== workInProgress.elementType) {
            var innerPropTypes = Component.propTypes;

            if (innerPropTypes) {
              checkPropTypes(innerPropTypes, nextProps, "prop", getComponentName(Component), getCurrentFiberStackInDev);
            }
          }
        }
        var render = Component.render;
        var ref = workInProgress.ref;
        var nextChildren = void 0;
        prepareToReadContext(workInProgress, renderExpirationTime);
        {
          ReactCurrentOwner$3.current = workInProgress;
          setCurrentPhase("render");
          nextChildren = renderWithHooks(current$$1, workInProgress, render, nextProps, ref, renderExpirationTime);

          if (debugRenderPhaseSideEffects || debugRenderPhaseSideEffectsForStrictMode && workInProgress.mode & StrictMode) {
            if (workInProgress.memoizedState !== null) {
              nextChildren = renderWithHooks(current$$1, workInProgress, render, nextProps, ref, renderExpirationTime);
            }
          }

          setCurrentPhase(null);
        }

        if (current$$1 !== null && !didReceiveUpdate) {
          bailoutHooks(current$$1, workInProgress, renderExpirationTime);
          return bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
        }

        workInProgress.effectTag |= PerformedWork;
        reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime);
        return workInProgress.child;
      }

      function updateMemoComponent(current$$1, workInProgress, Component, nextProps, updateExpirationTime, renderExpirationTime) {
        if (current$$1 === null) {
          var type = Component.type;

          if (isSimpleFunctionComponent(type) && Component.compare === null && Component.defaultProps === undefined) {
            var resolvedType = type;
            {
              resolvedType = resolveFunctionForHotReloading(type);
            }
            workInProgress.tag = SimpleMemoComponent;
            workInProgress.type = resolvedType;
            {
              validateFunctionComponentInDev(workInProgress, type);
            }
            return updateSimpleMemoComponent(current$$1, workInProgress, resolvedType, nextProps, updateExpirationTime, renderExpirationTime);
          }

          {
            var innerPropTypes = type.propTypes;

            if (innerPropTypes) {
              checkPropTypes(innerPropTypes, nextProps, "prop", getComponentName(type), getCurrentFiberStackInDev);
            }
          }
          var child = createFiberFromTypeAndProps(Component.type, null, nextProps, null, workInProgress.mode, renderExpirationTime);
          child.ref = workInProgress.ref;
          child.return = workInProgress;
          workInProgress.child = child;
          return child;
        }

        {
          var _type = Component.type;
          var _innerPropTypes = _type.propTypes;

          if (_innerPropTypes) {
            checkPropTypes(_innerPropTypes, nextProps, "prop", getComponentName(_type), getCurrentFiberStackInDev);
          }
        }
        var currentChild = current$$1.child;

        if (updateExpirationTime < renderExpirationTime) {
          var prevProps = currentChild.memoizedProps;
          var compare = Component.compare;
          compare = compare !== null ? compare : shallowEqual;

          if (compare(prevProps, nextProps) && current$$1.ref === workInProgress.ref) {
            return bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
          }
        }

        workInProgress.effectTag |= PerformedWork;
        var newChild = createWorkInProgress(currentChild, nextProps, renderExpirationTime);
        newChild.ref = workInProgress.ref;
        newChild.return = workInProgress;
        workInProgress.child = newChild;
        return newChild;
      }

      function updateSimpleMemoComponent(current$$1, workInProgress, Component, nextProps, updateExpirationTime, renderExpirationTime) {
        {
          if (workInProgress.type !== workInProgress.elementType) {
            var outerMemoType = workInProgress.elementType;

            if (outerMemoType.$$typeof === REACT_LAZY_TYPE) {
              outerMemoType = refineResolvedLazyComponent(outerMemoType);
            }

            var outerPropTypes = outerMemoType && outerMemoType.propTypes;

            if (outerPropTypes) {
              checkPropTypes(outerPropTypes, nextProps, "prop", getComponentName(outerMemoType), getCurrentFiberStackInDev);
            }
          }
        }

        if (current$$1 !== null) {
          var prevProps = current$$1.memoizedProps;

          if (shallowEqual(prevProps, nextProps) && current$$1.ref === workInProgress.ref && workInProgress.type === current$$1.type) {
            didReceiveUpdate = false;

            if (updateExpirationTime < renderExpirationTime) {
              return bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
            }
          }
        }

        return updateFunctionComponent(current$$1, workInProgress, Component, nextProps, renderExpirationTime);
      }

      function updateFragment(current$$1, workInProgress, renderExpirationTime) {
        var nextChildren = workInProgress.pendingProps;
        reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime);
        return workInProgress.child;
      }

      function updateMode(current$$1, workInProgress, renderExpirationTime) {
        var nextChildren = workInProgress.pendingProps.children;
        reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime);
        return workInProgress.child;
      }

      function updateProfiler(current$$1, workInProgress, renderExpirationTime) {
        if (enableProfilerTimer) {
          workInProgress.effectTag |= Update;
        }

        var nextProps = workInProgress.pendingProps;
        var nextChildren = nextProps.children;
        reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime);
        return workInProgress.child;
      }

      function markRef(current$$1, workInProgress) {
        var ref = workInProgress.ref;

        if (current$$1 === null && ref !== null || current$$1 !== null && current$$1.ref !== ref) {
          workInProgress.effectTag |= Ref;
        }
      }

      function updateFunctionComponent(current$$1, workInProgress, Component, nextProps, renderExpirationTime) {
        {
          if (workInProgress.type !== workInProgress.elementType) {
            var innerPropTypes = Component.propTypes;

            if (innerPropTypes) {
              checkPropTypes(innerPropTypes, nextProps, "prop", getComponentName(Component), getCurrentFiberStackInDev);
            }
          }
        }
        var context = void 0;

        if (!disableLegacyContext) {
          var unmaskedContext = getUnmaskedContext(workInProgress, Component, true);
          context = getMaskedContext(workInProgress, unmaskedContext);
        }

        var nextChildren = void 0;
        prepareToReadContext(workInProgress, renderExpirationTime);
        {
          ReactCurrentOwner$3.current = workInProgress;
          setCurrentPhase("render");
          nextChildren = renderWithHooks(current$$1, workInProgress, Component, nextProps, context, renderExpirationTime);

          if (debugRenderPhaseSideEffects || debugRenderPhaseSideEffectsForStrictMode && workInProgress.mode & StrictMode) {
            if (workInProgress.memoizedState !== null) {
              nextChildren = renderWithHooks(current$$1, workInProgress, Component, nextProps, context, renderExpirationTime);
            }
          }

          setCurrentPhase(null);
        }

        if (current$$1 !== null && !didReceiveUpdate) {
          bailoutHooks(current$$1, workInProgress, renderExpirationTime);
          return bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
        }

        workInProgress.effectTag |= PerformedWork;
        reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime);
        return workInProgress.child;
      }

      function updateClassComponent(current$$1, workInProgress, Component, nextProps, renderExpirationTime) {
        {
          if (workInProgress.type !== workInProgress.elementType) {
            var innerPropTypes = Component.propTypes;

            if (innerPropTypes) {
              checkPropTypes(innerPropTypes, nextProps, "prop", getComponentName(Component), getCurrentFiberStackInDev);
            }
          }
        }
        var hasContext = void 0;

        if (isContextProvider(Component)) {
          hasContext = true;
          pushContextProvider(workInProgress);
        } else {
          hasContext = false;
        }

        prepareToReadContext(workInProgress, renderExpirationTime);
        var instance = workInProgress.stateNode;
        var shouldUpdate = void 0;

        if (instance === null) {
          if (current$$1 !== null) {
            current$$1.alternate = null;
            workInProgress.alternate = null;
            workInProgress.effectTag |= Placement;
          }

          constructClassInstance(workInProgress, Component, nextProps, renderExpirationTime);
          mountClassInstance(workInProgress, Component, nextProps, renderExpirationTime);
          shouldUpdate = true;
        } else if (current$$1 === null) {
          shouldUpdate = resumeMountClassInstance(workInProgress, Component, nextProps, renderExpirationTime);
        } else {
          shouldUpdate = updateClassInstance(current$$1, workInProgress, Component, nextProps, renderExpirationTime);
        }

        var nextUnitOfWork = finishClassComponent(current$$1, workInProgress, Component, shouldUpdate, hasContext, renderExpirationTime);
        {
          var inst = workInProgress.stateNode;

          if (inst.props !== nextProps) {
            !didWarnAboutReassigningProps ? warning$1(false, "It looks like %s is reassigning its own `this.props` while rendering. " + "This is not supported and can lead to confusing bugs.", getComponentName(workInProgress.type) || "a component") : void 0;
            didWarnAboutReassigningProps = true;
          }
        }
        return nextUnitOfWork;
      }

      function finishClassComponent(current$$1, workInProgress, Component, shouldUpdate, hasContext, renderExpirationTime) {
        markRef(current$$1, workInProgress);
        var didCaptureError = (workInProgress.effectTag & DidCapture) !== NoEffect;

        if (!shouldUpdate && !didCaptureError) {
          if (hasContext) {
            invalidateContextProvider(workInProgress, Component, false);
          }

          return bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
        }

        var instance = workInProgress.stateNode;
        ReactCurrentOwner$3.current = workInProgress;
        var nextChildren = void 0;

        if (didCaptureError && typeof Component.getDerivedStateFromError !== "function") {
          nextChildren = null;

          if (enableProfilerTimer) {
            stopProfilerTimerIfRunning(workInProgress);
          }
        } else {
          {
            setCurrentPhase("render");
            nextChildren = instance.render();

            if (debugRenderPhaseSideEffects || debugRenderPhaseSideEffectsForStrictMode && workInProgress.mode & StrictMode) {
              instance.render();
            }

            setCurrentPhase(null);
          }
        }

        workInProgress.effectTag |= PerformedWork;

        if (current$$1 !== null && didCaptureError) {
          forceUnmountCurrentAndReconcile(current$$1, workInProgress, nextChildren, renderExpirationTime);
        } else {
          reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime);
        }

        workInProgress.memoizedState = instance.state;

        if (hasContext) {
          invalidateContextProvider(workInProgress, Component, true);
        }

        return workInProgress.child;
      }

      function pushHostRootContext(workInProgress) {
        var root = workInProgress.stateNode;

        if (root.pendingContext) {
          pushTopLevelContextObject(workInProgress, root.pendingContext, root.pendingContext !== root.context);
        } else if (root.context) {
          pushTopLevelContextObject(workInProgress, root.context, false);
        }

        pushHostContainer(workInProgress, root.containerInfo);
      }

      function updateHostRoot(current$$1, workInProgress, renderExpirationTime) {
        pushHostRootContext(workInProgress);
        var updateQueue = workInProgress.updateQueue;

        (function () {
          if (!(updateQueue !== null)) {
            throw ReactError(Error("If the root does not have an updateQueue, we should have already bailed out. This error is likely caused by a bug in React. Please file an issue."));
          }
        })();

        var nextProps = workInProgress.pendingProps;
        var prevState = workInProgress.memoizedState;
        var prevChildren = prevState !== null ? prevState.element : null;
        processUpdateQueue(workInProgress, updateQueue, nextProps, null, renderExpirationTime);
        var nextState = workInProgress.memoizedState;
        var nextChildren = nextState.element;

        if (nextChildren === prevChildren) {
          resetHydrationState();
          return bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
        }

        var root = workInProgress.stateNode;

        if ((current$$1 === null || current$$1.child === null) && root.hydrate && enterHydrationState(workInProgress)) {
          workInProgress.effectTag |= Placement;
          workInProgress.child = mountChildFibers(workInProgress, null, nextChildren, renderExpirationTime);
        } else {
          reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime);
          resetHydrationState();
        }

        return workInProgress.child;
      }

      function updateHostComponent(current$$1, workInProgress, renderExpirationTime) {
        pushHostContext(workInProgress);

        if (current$$1 === null) {
          tryToClaimNextHydratableInstance(workInProgress);
        }

        var type = workInProgress.type;
        var nextProps = workInProgress.pendingProps;
        var prevProps = current$$1 !== null ? current$$1.memoizedProps : null;
        var nextChildren = nextProps.children;
        var isDirectTextChild = shouldSetTextContent(type, nextProps);

        if (isDirectTextChild) {
          nextChildren = null;
        } else if (prevProps !== null && shouldSetTextContent(type, prevProps)) {
          workInProgress.effectTag |= ContentReset;
        }

        markRef(current$$1, workInProgress);

        if (workInProgress.mode & ConcurrentMode && renderExpirationTime !== Never && shouldDeprioritizeSubtree(type, nextProps)) {
          if (enableSchedulerTracing) {
            markSpawnedWork(Never);
          }

          workInProgress.expirationTime = workInProgress.childExpirationTime = Never;
          return null;
        }

        reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime);
        return workInProgress.child;
      }

      function updateHostText(current$$1, workInProgress) {
        if (current$$1 === null) {
          tryToClaimNextHydratableInstance(workInProgress);
        }

        return null;
      }

      function mountLazyComponent(_current, workInProgress, elementType, updateExpirationTime, renderExpirationTime) {
        if (_current !== null) {
          _current.alternate = null;
          workInProgress.alternate = null;
          workInProgress.effectTag |= Placement;
        }

        var props = workInProgress.pendingProps;
        cancelWorkTimer(workInProgress);
        var Component = readLazyComponentType(elementType);
        workInProgress.type = Component;
        var resolvedTag = workInProgress.tag = resolveLazyComponentTag(Component);
        startWorkTimer(workInProgress);
        var resolvedProps = resolveDefaultProps(Component, props);
        var child = void 0;

        switch (resolvedTag) {
          case FunctionComponent:
            {
              {
                validateFunctionComponentInDev(workInProgress, Component);
                workInProgress.type = Component = resolveFunctionForHotReloading(Component);
              }
              child = updateFunctionComponent(null, workInProgress, Component, resolvedProps, renderExpirationTime);
              break;
            }

          case ClassComponent:
            {
              {
                workInProgress.type = Component = resolveClassForHotReloading(Component);
              }
              child = updateClassComponent(null, workInProgress, Component, resolvedProps, renderExpirationTime);
              break;
            }

          case ForwardRef:
            {
              {
                workInProgress.type = Component = resolveForwardRefForHotReloading(Component);
              }
              child = updateForwardRef(null, workInProgress, Component, resolvedProps, renderExpirationTime);
              break;
            }

          case MemoComponent:
            {
              {
                if (workInProgress.type !== workInProgress.elementType) {
                  var outerPropTypes = Component.propTypes;

                  if (outerPropTypes) {
                    checkPropTypes(outerPropTypes, resolvedProps, "prop", getComponentName(Component), getCurrentFiberStackInDev);
                  }
                }
              }
              child = updateMemoComponent(null, workInProgress, Component, resolveDefaultProps(Component.type, resolvedProps), updateExpirationTime, renderExpirationTime);
              break;
            }

          default:
            {
              var hint = "";
              {
                if (Component !== null && typeof Component === "object" && Component.$$typeof === REACT_LAZY_TYPE) {
                  hint = " Did you wrap a component in React.lazy() more than once?";
                }
              }

              (function () {
                {
                  throw ReactError(Error("Element type is invalid. Received a promise that resolves to: " + Component + ". Lazy element type must resolve to a class or function." + hint));
                }
              })();
            }
        }

        return child;
      }

      function mountIncompleteClassComponent(_current, workInProgress, Component, nextProps, renderExpirationTime) {
        if (_current !== null) {
          _current.alternate = null;
          workInProgress.alternate = null;
          workInProgress.effectTag |= Placement;
        }

        workInProgress.tag = ClassComponent;
        var hasContext = void 0;

        if (isContextProvider(Component)) {
          hasContext = true;
          pushContextProvider(workInProgress);
        } else {
          hasContext = false;
        }

        prepareToReadContext(workInProgress, renderExpirationTime);
        constructClassInstance(workInProgress, Component, nextProps, renderExpirationTime);
        mountClassInstance(workInProgress, Component, nextProps, renderExpirationTime);
        return finishClassComponent(null, workInProgress, Component, true, hasContext, renderExpirationTime);
      }

      function mountIndeterminateComponent(_current, workInProgress, Component, renderExpirationTime) {
        if (_current !== null) {
          _current.alternate = null;
          workInProgress.alternate = null;
          workInProgress.effectTag |= Placement;
        }

        var props = workInProgress.pendingProps;
        var context = void 0;

        if (!disableLegacyContext) {
          var unmaskedContext = getUnmaskedContext(workInProgress, Component, false);
          context = getMaskedContext(workInProgress, unmaskedContext);
        }

        prepareToReadContext(workInProgress, renderExpirationTime);
        var value = void 0;
        {
          if (Component.prototype && typeof Component.prototype.render === "function") {
            var componentName = getComponentName(Component) || "Unknown";

            if (!didWarnAboutBadClass[componentName]) {
              warningWithoutStack$1(false, "The <%s /> component appears to have a render method, but doesn't extend React.Component. " + "This is likely to cause errors. Change %s to extend React.Component instead.", componentName, componentName);
              didWarnAboutBadClass[componentName] = true;
            }
          }

          if (workInProgress.mode & StrictMode) {
            ReactStrictModeWarnings.recordLegacyContextWarning(workInProgress, null);
          }

          ReactCurrentOwner$3.current = workInProgress;
          value = renderWithHooks(null, workInProgress, Component, props, context, renderExpirationTime);
        }
        workInProgress.effectTag |= PerformedWork;

        if (typeof value === "object" && value !== null && typeof value.render === "function" && value.$$typeof === undefined) {
          {
            var _componentName = getComponentName(Component) || "Unknown";

            if (!didWarnAboutModulePatternComponent[_componentName]) {
              warningWithoutStack$1(false, "The <%s /> component appears to be a function component that returns a class instance. " + "Change %s to a class that extends React.Component instead. " + "If you can't use a class try assigning the prototype on the function as a workaround. " + "`%s.prototype = React.Component.prototype`. Don't use an arrow function since it " + "cannot be called with `new` by React.", _componentName, _componentName, _componentName);
              didWarnAboutModulePatternComponent[_componentName] = true;
            }
          }
          workInProgress.tag = ClassComponent;
          resetHooks();
          var hasContext = false;

          if (isContextProvider(Component)) {
            hasContext = true;
            pushContextProvider(workInProgress);
          } else {
            hasContext = false;
          }

          workInProgress.memoizedState = value.state !== null && value.state !== undefined ? value.state : null;
          var getDerivedStateFromProps = Component.getDerivedStateFromProps;

          if (typeof getDerivedStateFromProps === "function") {
            applyDerivedStateFromProps(workInProgress, Component, getDerivedStateFromProps, props);
          }

          adoptClassInstance(workInProgress, value);
          mountClassInstance(workInProgress, Component, props, renderExpirationTime);
          return finishClassComponent(null, workInProgress, Component, true, hasContext, renderExpirationTime);
        } else {
          workInProgress.tag = FunctionComponent;
          {
            if (disableLegacyContext && Component.contextTypes) {
              warningWithoutStack$1(false, "%s uses the legacy contextTypes API which is no longer supported. " + "Use React.createContext() with React.useContext() instead.", getComponentName(Component) || "Unknown");
            }

            if (debugRenderPhaseSideEffects || debugRenderPhaseSideEffectsForStrictMode && workInProgress.mode & StrictMode) {
              if (workInProgress.memoizedState !== null) {
                value = renderWithHooks(null, workInProgress, Component, props, context, renderExpirationTime);
              }
            }
          }
          reconcileChildren(null, workInProgress, value, renderExpirationTime);
          {
            validateFunctionComponentInDev(workInProgress, Component);
          }
          return workInProgress.child;
        }
      }

      function validateFunctionComponentInDev(workInProgress, Component) {
        if (Component) {
          !!Component.childContextTypes ? warningWithoutStack$1(false, "%s(...): childContextTypes cannot be defined on a function component.", Component.displayName || Component.name || "Component") : void 0;
        }

        if (workInProgress.ref !== null) {
          var info = "";
          var ownerName = getCurrentFiberOwnerNameInDevOrNull();

          if (ownerName) {
            info += "\n\nCheck the render method of `" + ownerName + "`.";
          }

          var warningKey = ownerName || workInProgress._debugID || "";
          var debugSource = workInProgress._debugSource;

          if (debugSource) {
            warningKey = debugSource.fileName + ":" + debugSource.lineNumber;
          }

          if (!didWarnAboutFunctionRefs[warningKey]) {
            didWarnAboutFunctionRefs[warningKey] = true;
            warning$1(false, "Function components cannot be given refs. " + "Attempts to access this ref will fail. " + "Did you mean to use React.forwardRef()?%s", info);
          }
        }

        if (warnAboutDefaultPropsOnFunctionComponents && Component.defaultProps !== undefined) {
          var componentName = getComponentName(Component) || "Unknown";

          if (!didWarnAboutDefaultPropsOnFunctionComponent[componentName]) {
            warningWithoutStack$1(false, "%s: Support for defaultProps will be removed from function components " + "in a future major release. Use JavaScript default parameters instead.", componentName);
            didWarnAboutDefaultPropsOnFunctionComponent[componentName] = true;
          }
        }

        if (typeof Component.getDerivedStateFromProps === "function") {
          var _componentName2 = getComponentName(Component) || "Unknown";

          if (!didWarnAboutGetDerivedStateOnFunctionComponent[_componentName2]) {
            warningWithoutStack$1(false, "%s: Function components do not support getDerivedStateFromProps.", _componentName2);
            didWarnAboutGetDerivedStateOnFunctionComponent[_componentName2] = true;
          }
        }

        if (typeof Component.contextType === "object" && Component.contextType !== null) {
          var _componentName3 = getComponentName(Component) || "Unknown";

          if (!didWarnAboutContextTypeOnFunctionComponent[_componentName3]) {
            warningWithoutStack$1(false, "%s: Function components do not support contextType.", _componentName3);
            didWarnAboutContextTypeOnFunctionComponent[_componentName3] = true;
          }
        }
      }

      var SUSPENDED_MARKER = {};

      function shouldRemainOnFallback(suspenseContext, current$$1, workInProgress) {
        return hasSuspenseContext(suspenseContext, ForceSuspenseFallback) && (current$$1 === null || current$$1.memoizedState !== null);
      }

      function updateSuspenseComponent(current$$1, workInProgress, renderExpirationTime) {
        var mode = workInProgress.mode;
        var nextProps = workInProgress.pendingProps;
        {
          if (shouldSuspend(workInProgress)) {
            workInProgress.effectTag |= DidCapture;
          }
        }
        var suspenseContext = suspenseStackCursor.current;
        var nextState = null;
        var nextDidTimeout = false;

        if ((workInProgress.effectTag & DidCapture) !== NoEffect || shouldRemainOnFallback(suspenseContext, current$$1, workInProgress)) {
          nextState = SUSPENDED_MARKER;
          nextDidTimeout = true;
          workInProgress.effectTag &= ~DidCapture;
        } else {
          if (current$$1 === null || current$$1.memoizedState !== null) {
            if (nextProps.fallback !== undefined && nextProps.unstable_avoidThisFallback !== true) {
              suspenseContext = addSubtreeSuspenseContext(suspenseContext, InvisibleParentSuspenseContext);
            }
          }
        }

        suspenseContext = setDefaultShallowSuspenseContext(suspenseContext);
        pushSuspenseContext(workInProgress, suspenseContext);
        {
          if ("maxDuration" in nextProps) {
            if (!didWarnAboutMaxDuration) {
              didWarnAboutMaxDuration = true;
              warning$1(false, "maxDuration has been removed from React. " + "Remove the maxDuration prop.");
            }
          }
        }
        var child = void 0;
        var next = void 0;

        if (current$$1 === null) {
          if (enableSuspenseServerRenderer) {
            if (nextProps.fallback !== undefined) {
              tryToClaimNextHydratableInstance(workInProgress);

              if (workInProgress.tag === DehydratedSuspenseComponent) {
                popSuspenseContext(workInProgress);
                return updateDehydratedSuspenseComponent(null, workInProgress, renderExpirationTime);
              }
            }
          }

          if (nextDidTimeout) {
            var nextFallbackChildren = nextProps.fallback;
            var primaryChildFragment = createFiberFromFragment(null, mode, NoWork, null);
            primaryChildFragment.return = workInProgress;

            if ((workInProgress.mode & BatchedMode) === NoMode) {
              var progressedState = workInProgress.memoizedState;
              var progressedPrimaryChild = progressedState !== null ? workInProgress.child.child : workInProgress.child;
              primaryChildFragment.child = progressedPrimaryChild;
              var progressedChild = progressedPrimaryChild;

              while (progressedChild !== null) {
                progressedChild.return = primaryChildFragment;
                progressedChild = progressedChild.sibling;
              }
            }

            var fallbackChildFragment = createFiberFromFragment(nextFallbackChildren, mode, renderExpirationTime, null);
            fallbackChildFragment.return = workInProgress;
            primaryChildFragment.sibling = fallbackChildFragment;
            child = primaryChildFragment;
            next = fallbackChildFragment;
          } else {
            var nextPrimaryChildren = nextProps.children;
            child = next = mountChildFibers(workInProgress, null, nextPrimaryChildren, renderExpirationTime);
          }
        } else {
          var prevState = current$$1.memoizedState;
          var prevDidTimeout = prevState !== null;

          if (prevDidTimeout) {
            var currentPrimaryChildFragment = current$$1.child;
            var currentFallbackChildFragment = currentPrimaryChildFragment.sibling;

            if (nextDidTimeout) {
              var _nextFallbackChildren = nextProps.fallback;

              var _primaryChildFragment = createWorkInProgress(currentPrimaryChildFragment, currentPrimaryChildFragment.pendingProps, NoWork);

              _primaryChildFragment.return = workInProgress;

              if ((workInProgress.mode & BatchedMode) === NoMode) {
                var _progressedState = workInProgress.memoizedState;

                var _progressedPrimaryChild = _progressedState !== null ? workInProgress.child.child : workInProgress.child;

                if (_progressedPrimaryChild !== currentPrimaryChildFragment.child) {
                  _primaryChildFragment.child = _progressedPrimaryChild;
                  var _progressedChild = _progressedPrimaryChild;

                  while (_progressedChild !== null) {
                    _progressedChild.return = _primaryChildFragment;
                    _progressedChild = _progressedChild.sibling;
                  }
                }
              }

              if (enableProfilerTimer && workInProgress.mode & ProfileMode) {
                var treeBaseDuration = 0;
                var hiddenChild = _primaryChildFragment.child;

                while (hiddenChild !== null) {
                  treeBaseDuration += hiddenChild.treeBaseDuration;
                  hiddenChild = hiddenChild.sibling;
                }

                _primaryChildFragment.treeBaseDuration = treeBaseDuration;
              }

              var _fallbackChildFragment = createWorkInProgress(currentFallbackChildFragment, _nextFallbackChildren, currentFallbackChildFragment.expirationTime);

              _fallbackChildFragment.return = workInProgress;
              _primaryChildFragment.sibling = _fallbackChildFragment;
              child = _primaryChildFragment;
              _primaryChildFragment.childExpirationTime = NoWork;
              next = _fallbackChildFragment;
            } else {
              var _nextPrimaryChildren = nextProps.children;
              var currentPrimaryChild = currentPrimaryChildFragment.child;
              var primaryChild = reconcileChildFibers(workInProgress, currentPrimaryChild, _nextPrimaryChildren, renderExpirationTime);
              child = next = primaryChild;
            }
          } else {
            var _currentPrimaryChild = current$$1.child;

            if (nextDidTimeout) {
              var _nextFallbackChildren2 = nextProps.fallback;

              var _primaryChildFragment2 = createFiberFromFragment(null, mode, NoWork, null);

              _primaryChildFragment2.return = workInProgress;
              _primaryChildFragment2.child = _currentPrimaryChild;

              if (_currentPrimaryChild !== null) {
                _currentPrimaryChild.return = _primaryChildFragment2;
              }

              if ((workInProgress.mode & BatchedMode) === NoMode) {
                var _progressedState2 = workInProgress.memoizedState;

                var _progressedPrimaryChild2 = _progressedState2 !== null ? workInProgress.child.child : workInProgress.child;

                _primaryChildFragment2.child = _progressedPrimaryChild2;
                var _progressedChild2 = _progressedPrimaryChild2;

                while (_progressedChild2 !== null) {
                  _progressedChild2.return = _primaryChildFragment2;
                  _progressedChild2 = _progressedChild2.sibling;
                }
              }

              if (enableProfilerTimer && workInProgress.mode & ProfileMode) {
                var _treeBaseDuration = 0;
                var _hiddenChild = _primaryChildFragment2.child;

                while (_hiddenChild !== null) {
                  _treeBaseDuration += _hiddenChild.treeBaseDuration;
                  _hiddenChild = _hiddenChild.sibling;
                }

                _primaryChildFragment2.treeBaseDuration = _treeBaseDuration;
              }

              var _fallbackChildFragment2 = createFiberFromFragment(_nextFallbackChildren2, mode, renderExpirationTime, null);

              _fallbackChildFragment2.return = workInProgress;
              _primaryChildFragment2.sibling = _fallbackChildFragment2;
              _fallbackChildFragment2.effectTag |= Placement;
              child = _primaryChildFragment2;
              _primaryChildFragment2.childExpirationTime = NoWork;
              next = _fallbackChildFragment2;
            } else {
              var _nextPrimaryChildren2 = nextProps.children;
              next = child = reconcileChildFibers(workInProgress, _currentPrimaryChild, _nextPrimaryChildren2, renderExpirationTime);
            }
          }

          workInProgress.stateNode = current$$1.stateNode;
        }

        workInProgress.memoizedState = nextState;
        workInProgress.child = child;
        return next;
      }

      function retrySuspenseComponentWithoutHydrating(current$$1, workInProgress, renderExpirationTime) {
        current$$1.alternate = null;
        workInProgress.alternate = null;
        var returnFiber = workInProgress.return;

        (function () {
          if (!(returnFiber !== null)) {
            throw ReactError(Error("Suspense boundaries are never on the root. This is probably a bug in React."));
          }
        })();

        var last = returnFiber.lastEffect;

        if (last !== null) {
          last.nextEffect = current$$1;
          returnFiber.lastEffect = current$$1;
        } else {
          returnFiber.firstEffect = returnFiber.lastEffect = current$$1;
        }

        current$$1.nextEffect = null;
        current$$1.effectTag = Deletion;
        popSuspenseContext(workInProgress);
        workInProgress.tag = SuspenseComponent;
        workInProgress.stateNode = null;
        workInProgress.memoizedState = null;
        workInProgress.effectTag |= Placement;
        return updateSuspenseComponent(null, workInProgress, renderExpirationTime);
      }

      function updateDehydratedSuspenseComponent(current$$1, workInProgress, renderExpirationTime) {
        pushSuspenseContext(workInProgress, setDefaultShallowSuspenseContext(suspenseStackCursor.current));
        var suspenseInstance = workInProgress.stateNode;

        if (current$$1 === null) {
          if (isSuspenseInstanceFallback(suspenseInstance)) {
            var serverDisplayTime = requestCurrentTime();
            workInProgress.expirationTime = computeAsyncExpiration(serverDisplayTime);
          } else {
            workInProgress.expirationTime = Never;
          }

          return null;
        }

        if ((workInProgress.effectTag & DidCapture) !== NoEffect) {
          workInProgress.child = null;
          return null;
        }

        warnIfHydrating();

        if (isSuspenseInstanceFallback(suspenseInstance)) {
          return retrySuspenseComponentWithoutHydrating(current$$1, workInProgress, renderExpirationTime);
        }

        var hasContextChanged$$1 = current$$1.childExpirationTime >= renderExpirationTime;

        if (didReceiveUpdate || hasContextChanged$$1) {
          return retrySuspenseComponentWithoutHydrating(current$$1, workInProgress, renderExpirationTime);
        } else if (isSuspenseInstancePending(suspenseInstance)) {
          workInProgress.effectTag |= DidCapture;
          workInProgress.child = null;
          registerSuspenseInstanceRetry(suspenseInstance, retryTimedOutBoundary.bind(null, current$$1));
          return null;
        } else {
          reenterHydrationStateFromDehydratedSuspenseInstance(workInProgress);
          var nextProps = workInProgress.pendingProps;
          var nextChildren = nextProps.children;
          workInProgress.child = mountChildFibers(workInProgress, null, nextChildren, renderExpirationTime);
          return workInProgress.child;
        }
      }

      function propagateSuspenseContextChange(workInProgress, firstChild, renderExpirationTime) {
        var node = firstChild;

        while (node !== null) {
          if (node.tag === SuspenseComponent) {
            var state = node.memoizedState;

            if (state !== null) {
              if (node.expirationTime < renderExpirationTime) {
                node.expirationTime = renderExpirationTime;
              }

              var alternate = node.alternate;

              if (alternate !== null && alternate.expirationTime < renderExpirationTime) {
                alternate.expirationTime = renderExpirationTime;
              }

              scheduleWorkOnParentPath(node.return, renderExpirationTime);
            }
          } else if (node.child !== null) {
            node.child.return = node;
            node = node.child;
            continue;
          }

          if (node === workInProgress) {
            return;
          }

          while (node.sibling === null) {
            if (node.return === null || node.return === workInProgress) {
              return;
            }

            node = node.return;
          }

          node.sibling.return = node.return;
          node = node.sibling;
        }
      }

      function findLastContentRow(firstChild) {
        var row = firstChild;
        var lastContentRow = null;

        while (row !== null) {
          var currentRow = row.alternate;

          if (currentRow !== null && findFirstSuspended(currentRow) === null) {
            lastContentRow = row;
          }

          row = row.sibling;
        }

        return lastContentRow;
      }

      function validateRevealOrder(revealOrder) {
        {
          if (revealOrder !== undefined && revealOrder !== "forwards" && revealOrder !== "backwards" && revealOrder !== "together" && !didWarnAboutRevealOrder[revealOrder]) {
            didWarnAboutRevealOrder[revealOrder] = true;

            if (typeof revealOrder === "string") {
              switch (revealOrder.toLowerCase()) {
                case "together":
                case "forwards":
                case "backwards":
                  {
                    warning$1(false, '"%s" is not a valid value for revealOrder on <SuspenseList />. ' + 'Use lowercase "%s" instead.', revealOrder, revealOrder.toLowerCase());
                    break;
                  }

                case "forward":
                case "backward":
                  {
                    warning$1(false, '"%s" is not a valid value for revealOrder on <SuspenseList />. ' + 'React uses the -s suffix in the spelling. Use "%ss" instead.', revealOrder, revealOrder.toLowerCase());
                    break;
                  }

                default:
                  warning$1(false, '"%s" is not a supported revealOrder on <SuspenseList />. ' + 'Did you mean "together", "forwards" or "backwards"?', revealOrder);
                  break;
              }
            } else {
              warning$1(false, "%s is not a supported value for revealOrder on <SuspenseList />. " + 'Did you mean "together", "forwards" or "backwards"?', revealOrder);
            }
          }
        }
      }

      function validateTailOptions(tailMode, revealOrder) {
        {
          if (tailMode !== undefined && !didWarnAboutTailOptions[tailMode]) {
            if (tailMode !== "collapsed" && tailMode !== "hidden") {
              didWarnAboutTailOptions[tailMode] = true;
              warning$1(false, '"%s" is not a supported value for tail on <SuspenseList />. ' + 'Did you mean "collapsed" or "hidden"?', tailMode);
            } else if (revealOrder !== "forwards" && revealOrder !== "backwards") {
              didWarnAboutTailOptions[tailMode] = true;
              warning$1(false, '<SuspenseList tail="%s" /> is only valid if revealOrder is ' + '"forwards" or "backwards". ' + 'Did you mean to specify revealOrder="forwards"?', tailMode);
            }
          }
        }
      }

      function validateSuspenseListNestedChild(childSlot, index) {
        {
          var isArray = Array.isArray(childSlot);
          var isIterable = !isArray && typeof getIteratorFn(childSlot) === "function";

          if (isArray || isIterable) {
            var type = isArray ? "array" : "iterable";
            warning$1(false, "A nested %s was passed to row #%s in <SuspenseList />. Wrap it in " + "an additional SuspenseList to configure its revealOrder: " + "<SuspenseList revealOrder=...> ... " + "<SuspenseList revealOrder=...>{%s}</SuspenseList> ... " + "</SuspenseList>", type, index, type);
            return false;
          }
        }
        return true;
      }

      function validateSuspenseListChildren(children, revealOrder) {
        {
          if ((revealOrder === "forwards" || revealOrder === "backwards") && children !== undefined && children !== null && children !== false) {
            if (Array.isArray(children)) {
              for (var i = 0; i < children.length; i++) {
                if (!validateSuspenseListNestedChild(children[i], i)) {
                  return;
                }
              }
            } else {
              var iteratorFn = getIteratorFn(children);

              if (typeof iteratorFn === "function") {
                var childrenIterator = iteratorFn.call(children);

                if (childrenIterator) {
                  var step = childrenIterator.next();
                  var _i = 0;

                  for (; !step.done; step = childrenIterator.next()) {
                    if (!validateSuspenseListNestedChild(step.value, _i)) {
                      return;
                    }

                    _i++;
                  }
                }
              } else {
                warning$1(false, 'A single row was passed to a <SuspenseList revealOrder="%s" />. ' + "This is not useful since it needs multiple rows. " + "Did you mean to pass multiple children or an array?", revealOrder);
              }
            }
          }
        }
      }

      function initSuspenseListRenderState(workInProgress, isBackwards, tail, lastContentRow, tailMode) {
        var renderState = workInProgress.memoizedState;

        if (renderState === null) {
          workInProgress.memoizedState = {
            isBackwards: isBackwards,
            rendering: null,
            last: lastContentRow,
            tail: tail,
            tailExpiration: 0,
            tailMode: tailMode
          };
        } else {
          renderState.isBackwards = isBackwards;
          renderState.rendering = null;
          renderState.last = lastContentRow;
          renderState.tail = tail;
          renderState.tailExpiration = 0;
          renderState.tailMode = tailMode;
        }
      }

      function updateSuspenseListComponent(current$$1, workInProgress, renderExpirationTime) {
        var nextProps = workInProgress.pendingProps;
        var revealOrder = nextProps.revealOrder;
        var tailMode = nextProps.tail;
        var newChildren = nextProps.children;
        validateRevealOrder(revealOrder);
        validateTailOptions(tailMode, revealOrder);
        validateSuspenseListChildren(newChildren, revealOrder);
        reconcileChildren(current$$1, workInProgress, newChildren, renderExpirationTime);
        var suspenseContext = suspenseStackCursor.current;
        var shouldForceFallback = hasSuspenseContext(suspenseContext, ForceSuspenseFallback);

        if (shouldForceFallback) {
          suspenseContext = setShallowSuspenseContext(suspenseContext, ForceSuspenseFallback);
          workInProgress.effectTag |= DidCapture;
        } else {
          var didSuspendBefore = current$$1 !== null && (current$$1.effectTag & DidCapture) !== NoEffect;

          if (didSuspendBefore) {
            propagateSuspenseContextChange(workInProgress, workInProgress.child, renderExpirationTime);
          }

          suspenseContext = setDefaultShallowSuspenseContext(suspenseContext);
        }

        pushSuspenseContext(workInProgress, suspenseContext);

        if ((workInProgress.mode & BatchedMode) === NoMode) {
          workInProgress.memoizedState = null;
        } else {
          switch (revealOrder) {
            case "forwards":
              {
                var lastContentRow = findLastContentRow(workInProgress.child);
                var tail = void 0;

                if (lastContentRow === null) {
                  tail = workInProgress.child;
                  workInProgress.child = null;
                } else {
                  tail = lastContentRow.sibling;
                  lastContentRow.sibling = null;
                }

                initSuspenseListRenderState(workInProgress, false, tail, lastContentRow, tailMode);
                break;
              }

            case "backwards":
              {
                var _tail = null;
                var row = workInProgress.child;
                workInProgress.child = null;

                while (row !== null) {
                  var currentRow = row.alternate;

                  if (currentRow !== null && findFirstSuspended(currentRow) === null) {
                    workInProgress.child = row;
                    break;
                  }

                  var nextRow = row.sibling;
                  row.sibling = _tail;
                  _tail = row;
                  row = nextRow;
                }

                initSuspenseListRenderState(workInProgress, true, _tail, null, tailMode);
                break;
              }

            case "together":
              {
                initSuspenseListRenderState(workInProgress, false, null, null, undefined);
                break;
              }

            default:
              {
                workInProgress.memoizedState = null;
              }
          }
        }

        return workInProgress.child;
      }

      function updatePortalComponent(current$$1, workInProgress, renderExpirationTime) {
        pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
        var nextChildren = workInProgress.pendingProps;

        if (current$$1 === null) {
          workInProgress.child = reconcileChildFibers(workInProgress, null, nextChildren, renderExpirationTime);
        } else {
          reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime);
        }

        return workInProgress.child;
      }

      function updateContextProvider(current$$1, workInProgress, renderExpirationTime) {
        var providerType = workInProgress.type;
        var context = providerType._context;
        var newProps = workInProgress.pendingProps;
        var oldProps = workInProgress.memoizedProps;
        var newValue = newProps.value;
        {
          var providerPropTypes = workInProgress.type.propTypes;

          if (providerPropTypes) {
            checkPropTypes(providerPropTypes, newProps, "prop", "Context.Provider", getCurrentFiberStackInDev);
          }
        }
        pushProvider(workInProgress, newValue);

        if (oldProps !== null) {
          var oldValue = oldProps.value;
          var changedBits = calculateChangedBits(context, newValue, oldValue);

          if (changedBits === 0) {
            if (oldProps.children === newProps.children && !hasContextChanged()) {
              return bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
            }
          } else {
            propagateContextChange(workInProgress, context, changedBits, renderExpirationTime);
          }
        }

        var newChildren = newProps.children;
        reconcileChildren(current$$1, workInProgress, newChildren, renderExpirationTime);
        return workInProgress.child;
      }

      var hasWarnedAboutUsingContextAsConsumer = false;

      function updateContextConsumer(current$$1, workInProgress, renderExpirationTime) {
        var context = workInProgress.type;
        {
          if (context._context === undefined) {
            if (context !== context.Consumer) {
              if (!hasWarnedAboutUsingContextAsConsumer) {
                hasWarnedAboutUsingContextAsConsumer = true;
                warning$1(false, "Rendering <Context> directly is not supported and will be removed in " + "a future major release. Did you mean to render <Context.Consumer> instead?");
              }
            }
          } else {
            context = context._context;
          }
        }
        var newProps = workInProgress.pendingProps;
        var render = newProps.children;
        {
          !(typeof render === "function") ? warningWithoutStack$1(false, "A context consumer was rendered with multiple children, or a child " + "that isn't a function. A context consumer expects a single child " + "that is a function. If you did pass a function, make sure there " + "is no trailing or leading whitespace around it.") : void 0;
        }
        prepareToReadContext(workInProgress, renderExpirationTime);

        var newValue = _readContext(context, newProps.unstable_observedBits);

        var newChildren = void 0;
        {
          ReactCurrentOwner$3.current = workInProgress;
          setCurrentPhase("render");
          newChildren = render(newValue);
          setCurrentPhase(null);
        }
        workInProgress.effectTag |= PerformedWork;
        reconcileChildren(current$$1, workInProgress, newChildren, renderExpirationTime);
        return workInProgress.child;
      }

      function updateFundamentalComponent$1(current$$1, workInProgress, renderExpirationTime) {
        var fundamentalImpl = workInProgress.type.impl;

        if (fundamentalImpl.reconcileChildren === false) {
          return null;
        }

        var nextProps = workInProgress.pendingProps;
        var nextChildren = nextProps.children;
        reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime);
        return workInProgress.child;
      }

      function markWorkInProgressReceivedUpdate() {
        didReceiveUpdate = true;
      }

      function bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime) {
        cancelWorkTimer(workInProgress);

        if (current$$1 !== null) {
          workInProgress.dependencies = current$$1.dependencies;
        }

        if (enableProfilerTimer) {
          stopProfilerTimerIfRunning(workInProgress);
        }

        var childExpirationTime = workInProgress.childExpirationTime;

        if (childExpirationTime < renderExpirationTime) {
          return null;
        } else {
          cloneChildFibers(current$$1, workInProgress);
          return workInProgress.child;
        }
      }

      function remountFiber(current$$1, oldWorkInProgress, newWorkInProgress) {
        {
          var returnFiber = oldWorkInProgress.return;

          if (returnFiber === null) {
            throw new Error("Cannot swap the root fiber.");
          }

          current$$1.alternate = null;
          oldWorkInProgress.alternate = null;
          newWorkInProgress.index = oldWorkInProgress.index;
          newWorkInProgress.sibling = oldWorkInProgress.sibling;
          newWorkInProgress.return = oldWorkInProgress.return;
          newWorkInProgress.ref = oldWorkInProgress.ref;

          if (oldWorkInProgress === returnFiber.child) {
            returnFiber.child = newWorkInProgress;
          } else {
            var prevSibling = returnFiber.child;

            if (prevSibling === null) {
              throw new Error("Expected parent to have a child.");
            }

            while (prevSibling.sibling !== oldWorkInProgress) {
              prevSibling = prevSibling.sibling;

              if (prevSibling === null) {
                throw new Error("Expected to find the previous sibling.");
              }
            }

            prevSibling.sibling = newWorkInProgress;
          }

          var last = returnFiber.lastEffect;

          if (last !== null) {
            last.nextEffect = current$$1;
            returnFiber.lastEffect = current$$1;
          } else {
            returnFiber.firstEffect = returnFiber.lastEffect = current$$1;
          }

          current$$1.nextEffect = null;
          current$$1.effectTag = Deletion;
          newWorkInProgress.effectTag |= Placement;
          return newWorkInProgress;
        }
      }

      function beginWork$1(current$$1, workInProgress, renderExpirationTime) {
        var updateExpirationTime = workInProgress.expirationTime;
        {
          if (workInProgress._debugNeedsRemount && current$$1 !== null) {
            return remountFiber(current$$1, workInProgress, createFiberFromTypeAndProps(workInProgress.type, workInProgress.key, workInProgress.pendingProps, workInProgress._debugOwner || null, workInProgress.mode, workInProgress.expirationTime));
          }
        }

        if (current$$1 !== null) {
          var oldProps = current$$1.memoizedProps;
          var newProps = workInProgress.pendingProps;

          if (oldProps !== newProps || hasContextChanged() || workInProgress.type !== current$$1.type) {
            didReceiveUpdate = true;
          } else if (updateExpirationTime < renderExpirationTime) {
            didReceiveUpdate = false;

            switch (workInProgress.tag) {
              case HostRoot:
                pushHostRootContext(workInProgress);
                resetHydrationState();
                break;

              case HostComponent:
                pushHostContext(workInProgress);

                if (workInProgress.mode & ConcurrentMode && renderExpirationTime !== Never && shouldDeprioritizeSubtree(workInProgress.type, newProps)) {
                  if (enableSchedulerTracing) {
                    markSpawnedWork(Never);
                  }

                  workInProgress.expirationTime = workInProgress.childExpirationTime = Never;
                  return null;
                }

                break;

              case ClassComponent:
                {
                  var Component = workInProgress.type;

                  if (isContextProvider(Component)) {
                    pushContextProvider(workInProgress);
                  }

                  break;
                }

              case HostPortal:
                pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
                break;

              case ContextProvider:
                {
                  var newValue = workInProgress.memoizedProps.value;
                  pushProvider(workInProgress, newValue);
                  break;
                }

              case Profiler:
                if (enableProfilerTimer) {
                  workInProgress.effectTag |= Update;
                }

                break;

              case SuspenseComponent:
                {
                  var state = workInProgress.memoizedState;
                  var didTimeout = state !== null;

                  if (didTimeout) {
                    var primaryChildFragment = workInProgress.child;
                    var primaryChildExpirationTime = primaryChildFragment.childExpirationTime;

                    if (primaryChildExpirationTime !== NoWork && primaryChildExpirationTime >= renderExpirationTime) {
                      return updateSuspenseComponent(current$$1, workInProgress, renderExpirationTime);
                    } else {
                      pushSuspenseContext(workInProgress, setDefaultShallowSuspenseContext(suspenseStackCursor.current));
                      var child = bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);

                      if (child !== null) {
                        return child.sibling;
                      } else {
                        return null;
                      }
                    }
                  } else {
                    pushSuspenseContext(workInProgress, setDefaultShallowSuspenseContext(suspenseStackCursor.current));
                  }

                  break;
                }

              case DehydratedSuspenseComponent:
                {
                  if (enableSuspenseServerRenderer) {
                    pushSuspenseContext(workInProgress, setDefaultShallowSuspenseContext(suspenseStackCursor.current));
                    workInProgress.effectTag |= DidCapture;
                  }

                  break;
                }

              case SuspenseListComponent:
                {
                  var didSuspendBefore = (current$$1.effectTag & DidCapture) !== NoEffect;
                  var hasChildWork = workInProgress.childExpirationTime >= renderExpirationTime;

                  if (didSuspendBefore) {
                    if (hasChildWork) {
                      return updateSuspenseListComponent(current$$1, workInProgress, renderExpirationTime);
                    }

                    workInProgress.effectTag |= DidCapture;
                  }

                  var renderState = workInProgress.memoizedState;

                  if (renderState !== null) {
                    renderState.rendering = null;
                    renderState.tail = null;
                  }

                  pushSuspenseContext(workInProgress, suspenseStackCursor.current);

                  if (hasChildWork) {
                    break;
                  } else {
                    return null;
                  }
                }
            }

            return bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
          }
        } else {
          didReceiveUpdate = false;
        }

        workInProgress.expirationTime = NoWork;

        switch (workInProgress.tag) {
          case IndeterminateComponent:
            {
              return mountIndeterminateComponent(current$$1, workInProgress, workInProgress.type, renderExpirationTime);
            }

          case LazyComponent:
            {
              var elementType = workInProgress.elementType;
              return mountLazyComponent(current$$1, workInProgress, elementType, updateExpirationTime, renderExpirationTime);
            }

          case FunctionComponent:
            {
              var _Component = workInProgress.type;
              var unresolvedProps = workInProgress.pendingProps;
              var resolvedProps = workInProgress.elementType === _Component ? unresolvedProps : resolveDefaultProps(_Component, unresolvedProps);
              return updateFunctionComponent(current$$1, workInProgress, _Component, resolvedProps, renderExpirationTime);
            }

          case ClassComponent:
            {
              var _Component2 = workInProgress.type;
              var _unresolvedProps = workInProgress.pendingProps;

              var _resolvedProps = workInProgress.elementType === _Component2 ? _unresolvedProps : resolveDefaultProps(_Component2, _unresolvedProps);

              return updateClassComponent(current$$1, workInProgress, _Component2, _resolvedProps, renderExpirationTime);
            }

          case HostRoot:
            return updateHostRoot(current$$1, workInProgress, renderExpirationTime);

          case HostComponent:
            return updateHostComponent(current$$1, workInProgress, renderExpirationTime);

          case HostText:
            return updateHostText(current$$1, workInProgress);

          case SuspenseComponent:
            return updateSuspenseComponent(current$$1, workInProgress, renderExpirationTime);

          case HostPortal:
            return updatePortalComponent(current$$1, workInProgress, renderExpirationTime);

          case ForwardRef:
            {
              var type = workInProgress.type;
              var _unresolvedProps2 = workInProgress.pendingProps;

              var _resolvedProps2 = workInProgress.elementType === type ? _unresolvedProps2 : resolveDefaultProps(type, _unresolvedProps2);

              return updateForwardRef(current$$1, workInProgress, type, _resolvedProps2, renderExpirationTime);
            }

          case Fragment:
            return updateFragment(current$$1, workInProgress, renderExpirationTime);

          case Mode:
            return updateMode(current$$1, workInProgress, renderExpirationTime);

          case Profiler:
            return updateProfiler(current$$1, workInProgress, renderExpirationTime);

          case ContextProvider:
            return updateContextProvider(current$$1, workInProgress, renderExpirationTime);

          case ContextConsumer:
            return updateContextConsumer(current$$1, workInProgress, renderExpirationTime);

          case MemoComponent:
            {
              var _type2 = workInProgress.type;
              var _unresolvedProps3 = workInProgress.pendingProps;

              var _resolvedProps3 = resolveDefaultProps(_type2, _unresolvedProps3);

              {
                if (workInProgress.type !== workInProgress.elementType) {
                  var outerPropTypes = _type2.propTypes;

                  if (outerPropTypes) {
                    checkPropTypes(outerPropTypes, _resolvedProps3, "prop", getComponentName(_type2), getCurrentFiberStackInDev);
                  }
                }
              }
              _resolvedProps3 = resolveDefaultProps(_type2.type, _resolvedProps3);
              return updateMemoComponent(current$$1, workInProgress, _type2, _resolvedProps3, updateExpirationTime, renderExpirationTime);
            }

          case SimpleMemoComponent:
            {
              return updateSimpleMemoComponent(current$$1, workInProgress, workInProgress.type, workInProgress.pendingProps, updateExpirationTime, renderExpirationTime);
            }

          case IncompleteClassComponent:
            {
              var _Component3 = workInProgress.type;
              var _unresolvedProps4 = workInProgress.pendingProps;

              var _resolvedProps4 = workInProgress.elementType === _Component3 ? _unresolvedProps4 : resolveDefaultProps(_Component3, _unresolvedProps4);

              return mountIncompleteClassComponent(current$$1, workInProgress, _Component3, _resolvedProps4, renderExpirationTime);
            }

          case DehydratedSuspenseComponent:
            {
              if (enableSuspenseServerRenderer) {
                return updateDehydratedSuspenseComponent(current$$1, workInProgress, renderExpirationTime);
              }

              break;
            }

          case SuspenseListComponent:
            {
              return updateSuspenseListComponent(current$$1, workInProgress, renderExpirationTime);
            }

          case FundamentalComponent:
            {
              if (enableFundamentalAPI) {
                return updateFundamentalComponent$1(current$$1, workInProgress, renderExpirationTime);
              }

              break;
            }
        }

        (function () {
          {
            throw ReactError(Error("Unknown unit of work tag. This error is likely caused by a bug in React. Please file an issue."));
          }
        })();
      }

      function createFundamentalStateInstance(currentFiber, props, impl, state) {
        return {
          currentFiber: currentFiber,
          impl: impl,
          instance: null,
          prevProps: null,
          props: props,
          state: state
        };
      }

      var emptyObject$1 = {};
      var isArray$2 = Array.isArray;

      function markUpdate(workInProgress) {
        workInProgress.effectTag |= Update;
      }

      function markRef$1(workInProgress) {
        workInProgress.effectTag |= Ref;
      }

      var _appendAllChildren = void 0;

      var updateHostContainer = void 0;
      var updateHostComponent$1 = void 0;
      var updateHostText$1 = void 0;

      if (supportsMutation) {
        _appendAllChildren = function appendAllChildren(parent, workInProgress, needsVisibilityToggle, isHidden) {
          var node = workInProgress.child;

          while (node !== null) {
            if (node.tag === HostComponent || node.tag === HostText) {
              appendInitialChild(parent, node.stateNode);
            } else if (enableFundamentalAPI && node.tag === FundamentalComponent) {
              appendInitialChild(parent, node.stateNode.instance);
            } else if (node.tag === HostPortal) {} else if (node.child !== null) {
              node.child.return = node;
              node = node.child;
              continue;
            }

            if (node === workInProgress) {
              return;
            }

            while (node.sibling === null) {
              if (node.return === null || node.return === workInProgress) {
                return;
              }

              node = node.return;
            }

            node.sibling.return = node.return;
            node = node.sibling;
          }
        };

        updateHostContainer = function updateHostContainer(workInProgress) {};

        updateHostComponent$1 = function updateHostComponent$1(current, workInProgress, type, newProps, rootContainerInstance) {
          var oldProps = current.memoizedProps;

          if (oldProps === newProps) {
            return;
          }

          var instance = workInProgress.stateNode;
          var currentHostContext = getHostContext();
          var updatePayload = prepareUpdate(instance, type, oldProps, newProps, rootContainerInstance, currentHostContext);
          workInProgress.updateQueue = updatePayload;

          if (updatePayload) {
            markUpdate(workInProgress);
          }
        };

        updateHostText$1 = function updateHostText$1(current, workInProgress, oldText, newText) {
          if (oldText !== newText) {
            markUpdate(workInProgress);
          }
        };
      } else if (supportsPersistence) {
        _appendAllChildren = function appendAllChildren(parent, workInProgress, needsVisibilityToggle, isHidden) {
          var node = workInProgress.child;

          while (node !== null) {
            branches: if (node.tag === HostComponent) {
              var instance = node.stateNode;

              if (needsVisibilityToggle && isHidden) {
                var props = node.memoizedProps;
                var type = node.type;
                instance = cloneHiddenInstance(instance, type, props, node);
              }

              appendInitialChild(parent, instance);
            } else if (node.tag === HostText) {
              var _instance = node.stateNode;

              if (needsVisibilityToggle && isHidden) {
                var text = node.memoizedProps;
                _instance = cloneHiddenTextInstance(_instance, text, node);
              }

              appendInitialChild(parent, _instance);
            } else if (enableFundamentalAPI && node.tag === FundamentalComponent) {
              var _instance2 = node.stateNode.instance;

              if (needsVisibilityToggle && isHidden) {
                var _props = node.memoizedProps;
                var _type = node.type;
                _instance2 = cloneHiddenInstance(_instance2, _type, _props, node);
              }

              appendInitialChild(parent, _instance2);
            } else if (node.tag === HostPortal) {} else if (node.tag === SuspenseComponent) {
              if ((node.effectTag & Update) !== NoEffect) {
                var newIsHidden = node.memoizedState !== null;

                if (newIsHidden) {
                  var primaryChildParent = node.child;

                  if (primaryChildParent !== null) {
                    if (primaryChildParent.child !== null) {
                      primaryChildParent.child.return = primaryChildParent;

                      _appendAllChildren(parent, primaryChildParent, true, newIsHidden);
                    }

                    var fallbackChildParent = primaryChildParent.sibling;

                    if (fallbackChildParent !== null) {
                      fallbackChildParent.return = node;
                      node = fallbackChildParent;
                      continue;
                    }
                  }
                }
              }

              if (node.child !== null) {
                node.child.return = node;
                node = node.child;
                continue;
              }
            } else if (node.child !== null) {
              node.child.return = node;
              node = node.child;
              continue;
            }

            node = node;

            if (node === workInProgress) {
              return;
            }

            while (node.sibling === null) {
              if (node.return === null || node.return === workInProgress) {
                return;
              }

              node = node.return;
            }

            node.sibling.return = node.return;
            node = node.sibling;
          }
        };

        var appendAllChildrenToContainer = function appendAllChildrenToContainer(containerChildSet, workInProgress, needsVisibilityToggle, isHidden) {
          var node = workInProgress.child;

          while (node !== null) {
            branches: if (node.tag === HostComponent) {
              var instance = node.stateNode;

              if (needsVisibilityToggle && isHidden) {
                var props = node.memoizedProps;
                var type = node.type;
                instance = cloneHiddenInstance(instance, type, props, node);
              }

              appendChildToContainerChildSet(containerChildSet, instance);
            } else if (node.tag === HostText) {
              var _instance3 = node.stateNode;

              if (needsVisibilityToggle && isHidden) {
                var text = node.memoizedProps;
                _instance3 = cloneHiddenTextInstance(_instance3, text, node);
              }

              appendChildToContainerChildSet(containerChildSet, _instance3);
            } else if (enableFundamentalAPI && node.tag === FundamentalComponent) {
              var _instance4 = node.stateNode.instance;

              if (needsVisibilityToggle && isHidden) {
                var _props2 = node.memoizedProps;
                var _type2 = node.type;
                _instance4 = cloneHiddenInstance(_instance4, _type2, _props2, node);
              }

              appendChildToContainerChildSet(containerChildSet, _instance4);
            } else if (node.tag === HostPortal) {} else if (node.tag === SuspenseComponent) {
              if ((node.effectTag & Update) !== NoEffect) {
                var newIsHidden = node.memoizedState !== null;

                if (newIsHidden) {
                  var primaryChildParent = node.child;

                  if (primaryChildParent !== null) {
                    if (primaryChildParent.child !== null) {
                      primaryChildParent.child.return = primaryChildParent;
                      appendAllChildrenToContainer(containerChildSet, primaryChildParent, true, newIsHidden);
                    }

                    var fallbackChildParent = primaryChildParent.sibling;

                    if (fallbackChildParent !== null) {
                      fallbackChildParent.return = node;
                      node = fallbackChildParent;
                      continue;
                    }
                  }
                }
              }

              if (node.child !== null) {
                node.child.return = node;
                node = node.child;
                continue;
              }
            } else if (node.child !== null) {
              node.child.return = node;
              node = node.child;
              continue;
            }

            node = node;

            if (node === workInProgress) {
              return;
            }

            while (node.sibling === null) {
              if (node.return === null || node.return === workInProgress) {
                return;
              }

              node = node.return;
            }

            node.sibling.return = node.return;
            node = node.sibling;
          }
        };

        updateHostContainer = function updateHostContainer(workInProgress) {
          var portalOrRoot = workInProgress.stateNode;
          var childrenUnchanged = workInProgress.firstEffect === null;

          if (childrenUnchanged) {} else {
            var container = portalOrRoot.containerInfo;
            var newChildSet = createContainerChildSet(container);
            appendAllChildrenToContainer(newChildSet, workInProgress, false, false);
            portalOrRoot.pendingChildren = newChildSet;
            markUpdate(workInProgress);
            finalizeContainerChildren(container, newChildSet);
          }
        };

        updateHostComponent$1 = function updateHostComponent$1(current, workInProgress, type, newProps, rootContainerInstance) {
          var currentInstance = current.stateNode;
          var oldProps = current.memoizedProps;
          var childrenUnchanged = workInProgress.firstEffect === null;

          if (childrenUnchanged && oldProps === newProps) {
            workInProgress.stateNode = currentInstance;
            return;
          }

          var recyclableInstance = workInProgress.stateNode;
          var currentHostContext = getHostContext();
          var updatePayload = null;

          if (oldProps !== newProps) {
            updatePayload = prepareUpdate(recyclableInstance, type, oldProps, newProps, rootContainerInstance, currentHostContext);
          }

          if (childrenUnchanged && updatePayload === null) {
            workInProgress.stateNode = currentInstance;
            return;
          }

          var newInstance = cloneInstance(currentInstance, updatePayload, type, oldProps, newProps, workInProgress, childrenUnchanged, recyclableInstance);

          if (finalizeInitialChildren(newInstance, type, newProps, rootContainerInstance, currentHostContext)) {
            markUpdate(workInProgress);
          }

          workInProgress.stateNode = newInstance;

          if (childrenUnchanged) {
            markUpdate(workInProgress);
          } else {
            _appendAllChildren(newInstance, workInProgress, false, false);
          }
        };

        updateHostText$1 = function updateHostText$1(current, workInProgress, oldText, newText) {
          if (oldText !== newText) {
            var rootContainerInstance = getRootHostContainer();
            var currentHostContext = getHostContext();
            workInProgress.stateNode = createTextInstance(newText, rootContainerInstance, currentHostContext, workInProgress);
            markUpdate(workInProgress);
          }
        };
      } else {
        updateHostContainer = function updateHostContainer(workInProgress) {};

        updateHostComponent$1 = function updateHostComponent$1(current, workInProgress, type, newProps, rootContainerInstance) {};

        updateHostText$1 = function updateHostText$1(current, workInProgress, oldText, newText) {};
      }

      function cutOffTailIfNeeded(renderState, hasRenderedATailFallback) {
        switch (renderState.tailMode) {
          case "hidden":
            {
              var tailNode = renderState.tail;
              var lastTailNode = null;

              while (tailNode !== null) {
                if (tailNode.alternate !== null) {
                  lastTailNode = tailNode;
                }

                tailNode = tailNode.sibling;
              }

              if (lastTailNode === null) {
                renderState.tail = null;
              } else {
                lastTailNode.sibling = null;
              }

              break;
            }

          case "collapsed":
            {
              var _tailNode = renderState.tail;
              var _lastTailNode = null;

              while (_tailNode !== null) {
                if (_tailNode.alternate !== null) {
                  _lastTailNode = _tailNode;
                }

                _tailNode = _tailNode.sibling;
              }

              if (_lastTailNode === null) {
                if (!hasRenderedATailFallback && renderState.tail !== null) {
                  renderState.tail.sibling = null;
                } else {
                  renderState.tail = null;
                }
              } else {
                _lastTailNode.sibling = null;
              }

              break;
            }
        }
      }

      function completeWork(current, workInProgress, renderExpirationTime) {
        var newProps = workInProgress.pendingProps;

        switch (workInProgress.tag) {
          case IndeterminateComponent:
            break;

          case LazyComponent:
            break;

          case SimpleMemoComponent:
          case FunctionComponent:
            break;

          case ClassComponent:
            {
              var Component = workInProgress.type;

              if (isContextProvider(Component)) {
                popContext(workInProgress);
              }

              break;
            }

          case HostRoot:
            {
              popHostContainer(workInProgress);
              popTopLevelContextObject(workInProgress);
              var fiberRoot = workInProgress.stateNode;

              if (fiberRoot.pendingContext) {
                fiberRoot.context = fiberRoot.pendingContext;
                fiberRoot.pendingContext = null;
              }

              if (current === null || current.child === null) {
                popHydrationState(workInProgress);
                workInProgress.effectTag &= ~Placement;
              }

              updateHostContainer(workInProgress);
              break;
            }

          case HostComponent:
            {
              popHostContext(workInProgress);
              var rootContainerInstance = getRootHostContainer();
              var type = workInProgress.type;

              if (current !== null && workInProgress.stateNode != null) {
                updateHostComponent$1(current, workInProgress, type, newProps, rootContainerInstance);

                if (enableFlareAPI) {
                  var prevListeners = current.memoizedProps.listeners;
                  var nextListeners = newProps.listeners;
                  var instance = workInProgress.stateNode;

                  if (prevListeners !== nextListeners) {
                    updateEventListeners(nextListeners, instance, rootContainerInstance, workInProgress);
                  }
                }

                if (current.ref !== workInProgress.ref) {
                  markRef$1(workInProgress);
                }
              } else {
                if (!newProps) {
                  (function () {
                    if (!(workInProgress.stateNode !== null)) {
                      throw ReactError(Error("We must have new props for new mounts. This error is likely caused by a bug in React. Please file an issue."));
                    }
                  })();

                  break;
                }

                var currentHostContext = getHostContext();
                var wasHydrated = popHydrationState(workInProgress);

                if (wasHydrated) {
                  if (prepareToHydrateHostInstance(workInProgress, rootContainerInstance, currentHostContext)) {
                    markUpdate(workInProgress);
                  }

                  if (enableFlareAPI) {
                    var _instance5 = workInProgress.stateNode;
                    var listeners = newProps.listeners;

                    if (listeners != null) {
                      updateEventListeners(listeners, _instance5, rootContainerInstance, workInProgress);
                    }
                  }
                } else {
                  var _instance6 = createInstance(type, newProps, rootContainerInstance, currentHostContext, workInProgress);

                  _appendAllChildren(_instance6, workInProgress, false, false);

                  if (enableFlareAPI) {
                    var _listeners = newProps.listeners;

                    if (_listeners != null) {
                      updateEventListeners(_listeners, _instance6, rootContainerInstance, workInProgress);
                    }
                  }

                  if (finalizeInitialChildren(_instance6, type, newProps, rootContainerInstance, currentHostContext)) {
                    markUpdate(workInProgress);
                  }

                  workInProgress.stateNode = _instance6;
                }

                if (workInProgress.ref !== null) {
                  markRef$1(workInProgress);
                }
              }

              break;
            }

          case HostText:
            {
              var newText = newProps;

              if (current && workInProgress.stateNode != null) {
                var oldText = current.memoizedProps;
                updateHostText$1(current, workInProgress, oldText, newText);
              } else {
                if (typeof newText !== "string") {
                  (function () {
                    if (!(workInProgress.stateNode !== null)) {
                      throw ReactError(Error("We must have new props for new mounts. This error is likely caused by a bug in React. Please file an issue."));
                    }
                  })();
                }

                var _rootContainerInstance = getRootHostContainer();

                var _currentHostContext = getHostContext();

                var _wasHydrated = popHydrationState(workInProgress);

                if (_wasHydrated) {
                  if (prepareToHydrateHostTextInstance(workInProgress)) {
                    markUpdate(workInProgress);
                  }
                } else {
                  workInProgress.stateNode = createTextInstance(newText, _rootContainerInstance, _currentHostContext, workInProgress);
                }
              }

              break;
            }

          case ForwardRef:
            break;

          case SuspenseComponent:
            {
              popSuspenseContext(workInProgress);
              var nextState = workInProgress.memoizedState;

              if ((workInProgress.effectTag & DidCapture) !== NoEffect) {
                workInProgress.expirationTime = renderExpirationTime;
                return workInProgress;
              }

              var nextDidTimeout = nextState !== null;
              var prevDidTimeout = false;

              if (current === null) {
                popHydrationState(workInProgress);
              } else {
                var prevState = current.memoizedState;
                prevDidTimeout = prevState !== null;

                if (!nextDidTimeout && prevState !== null) {
                  var currentFallbackChild = current.child.sibling;

                  if (currentFallbackChild !== null) {
                    var first = workInProgress.firstEffect;

                    if (first !== null) {
                      workInProgress.firstEffect = currentFallbackChild;
                      currentFallbackChild.nextEffect = first;
                    } else {
                      workInProgress.firstEffect = workInProgress.lastEffect = currentFallbackChild;
                      currentFallbackChild.nextEffect = null;
                    }

                    currentFallbackChild.effectTag = Deletion;
                  }
                }
              }

              if (nextDidTimeout && !prevDidTimeout) {
                if ((workInProgress.mode & BatchedMode) !== NoMode) {
                  var hasInvisibleChildContext = current === null && workInProgress.memoizedProps.unstable_avoidThisFallback !== true;

                  if (hasInvisibleChildContext || hasSuspenseContext(suspenseStackCursor.current, InvisibleParentSuspenseContext)) {
                    renderDidSuspend();
                  } else {
                    renderDidSuspendDelayIfPossible();
                  }
                }
              }

              if (supportsPersistence) {
                if (nextDidTimeout) {
                  workInProgress.effectTag |= Update;
                }
              }

              if (supportsMutation) {
                if (nextDidTimeout || prevDidTimeout) {
                  workInProgress.effectTag |= Update;
                }
              }

              if (enableSuspenseCallback && workInProgress.updateQueue !== null && workInProgress.memoizedProps.suspenseCallback != null) {
                workInProgress.effectTag |= Update;
              }

              break;
            }

          case Fragment:
            break;

          case Mode:
            break;

          case Profiler:
            break;

          case HostPortal:
            popHostContainer(workInProgress);
            updateHostContainer(workInProgress);
            break;

          case ContextProvider:
            popProvider(workInProgress);
            break;

          case ContextConsumer:
            break;

          case MemoComponent:
            break;

          case IncompleteClassComponent:
            {
              var _Component = workInProgress.type;

              if (isContextProvider(_Component)) {
                popContext(workInProgress);
              }

              break;
            }

          case DehydratedSuspenseComponent:
            {
              if (enableSuspenseServerRenderer) {
                popSuspenseContext(workInProgress);

                if (current === null) {
                  var _wasHydrated2 = popHydrationState(workInProgress);

                  (function () {
                    if (!_wasHydrated2) {
                      throw ReactError(Error("A dehydrated suspense component was completed without a hydrated node. This is probably a bug in React."));
                    }
                  })();

                  if (enableSchedulerTracing) {
                    markSpawnedWork(Never);
                  }

                  skipPastDehydratedSuspenseInstance(workInProgress);
                } else {
                  resetHydrationState();

                  if ((workInProgress.effectTag & DidCapture) === NoEffect) {
                    current.alternate = null;
                    workInProgress.alternate = null;
                    workInProgress.tag = SuspenseComponent;
                    workInProgress.memoizedState = null;
                    workInProgress.stateNode = null;
                  }
                }
              }

              break;
            }

          case SuspenseListComponent:
            {
              popSuspenseContext(workInProgress);
              var renderState = workInProgress.memoizedState;

              if (renderState === null) {
                break;
              }

              var didSuspendAlready = (workInProgress.effectTag & DidCapture) !== NoEffect;
              var renderedTail = renderState.rendering;

              if (renderedTail === null) {
                if (!didSuspendAlready) {
                  var cannotBeSuspended = renderHasNotSuspendedYet() && (current === null || (current.effectTag & DidCapture) === NoEffect);

                  if (!cannotBeSuspended) {
                    var row = workInProgress.child;

                    while (row !== null) {
                      var suspended = findFirstSuspended(row);

                      if (suspended !== null) {
                        didSuspendAlready = true;
                        workInProgress.effectTag |= DidCapture;
                        cutOffTailIfNeeded(renderState, false);
                        var newThennables = suspended.updateQueue;

                        if (newThennables !== null) {
                          workInProgress.updateQueue = newThennables;
                          workInProgress.effectTag |= Update;
                        }

                        workInProgress.firstEffect = workInProgress.lastEffect = null;
                        resetChildFibers(workInProgress, renderExpirationTime);
                        pushSuspenseContext(workInProgress, setShallowSuspenseContext(suspenseStackCursor.current, ForceSuspenseFallback));
                        return workInProgress.child;
                      }

                      row = row.sibling;
                    }
                  }
                } else {
                  cutOffTailIfNeeded(renderState, false);
                }
              } else {
                if (!didSuspendAlready) {
                  var _suspended = findFirstSuspended(renderedTail);

                  if (_suspended !== null) {
                    workInProgress.effectTag |= DidCapture;
                    didSuspendAlready = true;
                    cutOffTailIfNeeded(renderState, true);

                    if (renderState.tail === null && renderState.tailMode === "hidden") {
                      var _newThennables = _suspended.updateQueue;

                      if (_newThennables !== null) {
                        workInProgress.updateQueue = _newThennables;
                        workInProgress.effectTag |= Update;
                      }

                      var lastEffect = workInProgress.lastEffect = renderState.lastEffect;

                      if (lastEffect !== null) {
                        lastEffect.nextEffect = null;
                      }

                      return null;
                    }
                  } else if (now() > renderState.tailExpiration && renderExpirationTime > Never) {
                    workInProgress.effectTag |= DidCapture;
                    didSuspendAlready = true;
                    cutOffTailIfNeeded(renderState, false);
                    var nextPriority = renderExpirationTime - 1;
                    workInProgress.expirationTime = workInProgress.childExpirationTime = nextPriority;

                    if (enableSchedulerTracing) {
                      markSpawnedWork(nextPriority);
                    }
                  }
                }

                if (renderState.isBackwards) {
                  renderedTail.sibling = workInProgress.child;
                  workInProgress.child = renderedTail;
                } else {
                  var previousSibling = renderState.last;

                  if (previousSibling !== null) {
                    previousSibling.sibling = renderedTail;
                  } else {
                    workInProgress.child = renderedTail;
                  }

                  renderState.last = renderedTail;
                }
              }

              if (renderState.tail !== null) {
                if (renderState.tailExpiration === 0) {
                  var TAIL_EXPIRATION_TIMEOUT_MS = 500;
                  renderState.tailExpiration = now() + TAIL_EXPIRATION_TIMEOUT_MS;
                }

                var next = renderState.tail;
                renderState.rendering = next;
                renderState.tail = next.sibling;
                renderState.lastEffect = workInProgress.lastEffect;
                next.sibling = null;
                var suspenseContext = suspenseStackCursor.current;

                if (didSuspendAlready) {
                  suspenseContext = setShallowSuspenseContext(suspenseContext, ForceSuspenseFallback);
                } else {
                  suspenseContext = setDefaultShallowSuspenseContext(suspenseContext);
                }

                pushSuspenseContext(workInProgress, suspenseContext);
                return next;
              }

              break;
            }

          case FundamentalComponent:
            {
              if (enableFundamentalAPI) {
                var fundamentalImpl = workInProgress.type.impl;
                var fundamentalInstance = workInProgress.stateNode;

                if (fundamentalInstance === null) {
                  var getInitialState = fundamentalImpl.getInitialState;
                  var fundamentalState = void 0;

                  if (getInitialState !== undefined) {
                    fundamentalState = getInitialState(newProps);
                  }

                  fundamentalInstance = workInProgress.stateNode = createFundamentalStateInstance(workInProgress, newProps, fundamentalImpl, fundamentalState || {});

                  var _instance7 = getFundamentalComponentInstance(fundamentalInstance);

                  fundamentalInstance.instance = _instance7;

                  if (fundamentalImpl.reconcileChildren === false) {
                    return null;
                  }

                  _appendAllChildren(_instance7, workInProgress, false, false);

                  mountFundamentalComponent(fundamentalInstance);
                } else {
                  var prevProps = fundamentalInstance.props;
                  fundamentalInstance.prevProps = prevProps;
                  fundamentalInstance.props = newProps;
                  fundamentalInstance.currentFiber = workInProgress;

                  if (supportsPersistence) {
                    var _instance8 = cloneFundamentalInstance(fundamentalInstance);

                    fundamentalInstance.instance = _instance8;

                    _appendAllChildren(_instance8, workInProgress, false, false);
                  }

                  var shouldUpdate = shouldUpdateFundamentalComponent(fundamentalInstance);

                  if (shouldUpdate) {
                    markUpdate(workInProgress);
                  }
                }
              }

              break;
            }

          default:
            (function () {
              {
                throw ReactError(Error("Unknown unit of work tag. This error is likely caused by a bug in React. Please file an issue."));
              }
            })();

        }

        return null;
      }

      function mountEventResponder$1(responder, responderProps, instance, rootContainerInstance, fiber, respondersMap) {
        var responderState = emptyObject$1;
        var getInitialState = responder.getInitialState;

        if (getInitialState !== null) {
          responderState = getInitialState(responderProps);
        }

        var responderInstance = createResponderInstance(responder, responderProps, responderState, instance, fiber);
        mountResponderInstance(responder, responderInstance, responderProps, responderState, instance, rootContainerInstance);
        respondersMap.set(responder, responderInstance);
      }

      function updateEventListener(listener, fiber, visistedResponders, respondersMap, instance, rootContainerInstance) {
        var responder = void 0;
        var props = void 0;

        if (listener) {
          responder = listener.responder;
          props = listener.props;
        }

        (function () {
          if (!(responder && responder.$$typeof === REACT_RESPONDER_TYPE)) {
            throw ReactError(Error("An invalid value was used as an event listener. Expect one or many event listeners created via React.unstable_useResponer()."));
          }
        })();

        var listenerProps = props;

        if (visistedResponders.has(responder)) {
          {
            warning$1(false, 'Duplicate event responder "%s" found in event listeners. ' + "Event listeners passed to elements cannot use the same event responder more than once.", responder.displayName);
          }
          return;
        }

        visistedResponders.add(responder);
        var responderInstance = respondersMap.get(responder);

        if (responderInstance === undefined) {
          mountEventResponder$1(responder, listenerProps, instance, rootContainerInstance, fiber, respondersMap);
        } else {
          responderInstance.props = listenerProps;
          responderInstance.fiber = fiber;
        }
      }

      function updateEventListeners(listeners, instance, rootContainerInstance, fiber) {
        var visistedResponders = new Set();
        var dependencies = fiber.dependencies;

        if (listeners != null) {
          if (dependencies === null) {
            dependencies = fiber.dependencies = {
              expirationTime: NoWork,
              firstContext: null,
              responders: new Map()
            };
          }

          var respondersMap = dependencies.responders;

          if (respondersMap === null) {
            respondersMap = new Map();
          }

          if (isArray$2(listeners)) {
            for (var i = 0, length = listeners.length; i < length; i++) {
              var listener = listeners[i];
              updateEventListener(listener, fiber, visistedResponders, respondersMap, instance, rootContainerInstance);
            }
          } else {
            updateEventListener(listeners, fiber, visistedResponders, respondersMap, instance, rootContainerInstance);
          }
        }

        if (dependencies !== null) {
          var _respondersMap = dependencies.responders;

          if (_respondersMap !== null) {
            var mountedResponders = Array.from(_respondersMap.keys());

            for (var _i = 0, _length = mountedResponders.length; _i < _length; _i++) {
              var mountedResponder = mountedResponders[_i];

              if (!visistedResponders.has(mountedResponder)) {
                var responderInstance = _respondersMap.get(mountedResponder);

                unmountResponderInstance(responderInstance);

                _respondersMap.delete(mountedResponder);
              }
            }
          }
        }
      }

      function unwindWork(workInProgress, renderExpirationTime) {
        switch (workInProgress.tag) {
          case ClassComponent:
            {
              var Component = workInProgress.type;

              if (isContextProvider(Component)) {
                popContext(workInProgress);
              }

              var effectTag = workInProgress.effectTag;

              if (effectTag & ShouldCapture) {
                workInProgress.effectTag = effectTag & ~ShouldCapture | DidCapture;
                return workInProgress;
              }

              return null;
            }

          case HostRoot:
            {
              popHostContainer(workInProgress);
              popTopLevelContextObject(workInProgress);
              var _effectTag = workInProgress.effectTag;

              (function () {
                if (!((_effectTag & DidCapture) === NoEffect)) {
                  throw ReactError(Error("The root failed to unmount after an error. This is likely a bug in React. Please file an issue."));
                }
              })();

              workInProgress.effectTag = _effectTag & ~ShouldCapture | DidCapture;
              return workInProgress;
            }

          case HostComponent:
            {
              popHostContext(workInProgress);
              return null;
            }

          case SuspenseComponent:
            {
              popSuspenseContext(workInProgress);
              var _effectTag2 = workInProgress.effectTag;

              if (_effectTag2 & ShouldCapture) {
                workInProgress.effectTag = _effectTag2 & ~ShouldCapture | DidCapture;
                return workInProgress;
              }

              return null;
            }

          case DehydratedSuspenseComponent:
            {
              if (enableSuspenseServerRenderer) {
                popSuspenseContext(workInProgress);

                if (workInProgress.alternate === null) {} else {
                  resetHydrationState();
                }

                var _effectTag3 = workInProgress.effectTag;

                if (_effectTag3 & ShouldCapture) {
                  workInProgress.effectTag = _effectTag3 & ~ShouldCapture | DidCapture;
                  return workInProgress;
                }
              }

              return null;
            }

          case SuspenseListComponent:
            {
              popSuspenseContext(workInProgress);
              return null;
            }

          case HostPortal:
            popHostContainer(workInProgress);
            return null;

          case ContextProvider:
            popProvider(workInProgress);
            return null;

          default:
            return null;
        }
      }

      function unwindInterruptedWork(interruptedWork) {
        switch (interruptedWork.tag) {
          case ClassComponent:
            {
              var childContextTypes = interruptedWork.type.childContextTypes;

              if (childContextTypes !== null && childContextTypes !== undefined) {
                popContext(interruptedWork);
              }

              break;
            }

          case HostRoot:
            {
              popHostContainer(interruptedWork);
              popTopLevelContextObject(interruptedWork);
              break;
            }

          case HostComponent:
            {
              popHostContext(interruptedWork);
              break;
            }

          case HostPortal:
            popHostContainer(interruptedWork);
            break;

          case SuspenseComponent:
            popSuspenseContext(interruptedWork);
            break;

          case DehydratedSuspenseComponent:
            if (enableSuspenseServerRenderer) {
              popSuspenseContext(interruptedWork);
            }

            break;

          case SuspenseListComponent:
            popSuspenseContext(interruptedWork);
            break;

          case ContextProvider:
            popProvider(interruptedWork);
            break;

          default:
            break;
        }
      }

      function createCapturedValue(value, source) {
        return {
          value: value,
          source: source,
          stack: getStackByFiberInDevAndProd(source)
        };
      }

      (function () {
        if (!(typeof ReactNativePrivateInterface.ReactFiberErrorDialog.showErrorDialog === "function")) {
          throw ReactError(Error("Expected ReactFiberErrorDialog.showErrorDialog to be a function."));
        }
      })();

      function showErrorDialog(capturedError) {
        return ReactNativePrivateInterface.ReactFiberErrorDialog.showErrorDialog(capturedError);
      }

      function logCapturedError(capturedError) {
        var logError = showErrorDialog(capturedError);

        if (logError === false) {
          return;
        }

        var error = capturedError.error;
        {
          var componentName = capturedError.componentName,
              componentStack = capturedError.componentStack,
              errorBoundaryName = capturedError.errorBoundaryName,
              errorBoundaryFound = capturedError.errorBoundaryFound,
              willRetry = capturedError.willRetry;

          if (error != null && error._suppressLogging) {
            if (errorBoundaryFound && willRetry) {
              return;
            }

            console.error(error);
          }

          var componentNameMessage = componentName ? "The above error occurred in the <" + componentName + "> component:" : "The above error occurred in one of your React components:";
          var errorBoundaryMessage = void 0;

          if (errorBoundaryFound && errorBoundaryName) {
            if (willRetry) {
              errorBoundaryMessage = "React will try to recreate this component tree from scratch " + ("using the error boundary you provided, " + errorBoundaryName + ".");
            } else {
              errorBoundaryMessage = "This error was initially handled by the error boundary " + errorBoundaryName + ".\n" + "Recreating the tree from scratch failed so React will unmount the tree.";
            }
          } else {
            errorBoundaryMessage = "Consider adding an error boundary to your tree to customize error handling behavior.\n" + "Visit https://fb.me/react-error-boundaries to learn more about error boundaries.";
          }

          var combinedMessage = "" + componentNameMessage + componentStack + "\n\n" + ("" + errorBoundaryMessage);
          console.error(combinedMessage);
        }
      }

      var didWarnAboutUndefinedSnapshotBeforeUpdate = null;
      {
        didWarnAboutUndefinedSnapshotBeforeUpdate = new Set();
      }
      var PossiblyWeakSet$1 = typeof WeakSet === "function" ? WeakSet : Set;

      function logError(boundary, errorInfo) {
        var source = errorInfo.source;
        var stack = errorInfo.stack;

        if (stack === null && source !== null) {
          stack = getStackByFiberInDevAndProd(source);
        }

        var capturedError = {
          componentName: source !== null ? getComponentName(source.type) : null,
          componentStack: stack !== null ? stack : "",
          error: errorInfo.value,
          errorBoundary: null,
          errorBoundaryName: null,
          errorBoundaryFound: false,
          willRetry: false
        };

        if (boundary !== null && boundary.tag === ClassComponent) {
          capturedError.errorBoundary = boundary.stateNode;
          capturedError.errorBoundaryName = getComponentName(boundary.type);
          capturedError.errorBoundaryFound = true;
          capturedError.willRetry = true;
        }

        try {
          logCapturedError(capturedError);
        } catch (e) {
          setTimeout(function () {
            throw e;
          });
        }
      }

      var callComponentWillUnmountWithTimer = function callComponentWillUnmountWithTimer(current$$1, instance) {
        startPhaseTimer(current$$1, "componentWillUnmount");
        instance.props = current$$1.memoizedProps;
        instance.state = current$$1.memoizedState;
        instance.componentWillUnmount();
        stopPhaseTimer();
      };

      function safelyCallComponentWillUnmount(current$$1, instance) {
        {
          invokeGuardedCallback(null, callComponentWillUnmountWithTimer, null, current$$1, instance);

          if (hasCaughtError()) {
            var unmountError = clearCaughtError();
            captureCommitPhaseError(current$$1, unmountError);
          }
        }
      }

      function safelyDetachRef(current$$1) {
        var ref = current$$1.ref;

        if (ref !== null) {
          if (typeof ref === "function") {
            {
              invokeGuardedCallback(null, ref, null, null);

              if (hasCaughtError()) {
                var refError = clearCaughtError();
                captureCommitPhaseError(current$$1, refError);
              }
            }
          } else {
            ref.current = null;
          }
        }
      }

      function safelyCallDestroy(current$$1, destroy) {
        {
          invokeGuardedCallback(null, destroy, null);

          if (hasCaughtError()) {
            var error = clearCaughtError();
            captureCommitPhaseError(current$$1, error);
          }
        }
      }

      function commitBeforeMutationLifeCycles(current$$1, finishedWork) {
        switch (finishedWork.tag) {
          case FunctionComponent:
          case ForwardRef:
          case SimpleMemoComponent:
            {
              commitHookEffectList(UnmountSnapshot, NoEffect$1, finishedWork);
              return;
            }

          case ClassComponent:
            {
              if (finishedWork.effectTag & Snapshot) {
                if (current$$1 !== null) {
                  var prevProps = current$$1.memoizedProps;
                  var prevState = current$$1.memoizedState;
                  startPhaseTimer(finishedWork, "getSnapshotBeforeUpdate");
                  var instance = finishedWork.stateNode;
                  {
                    if (finishedWork.type === finishedWork.elementType && !didWarnAboutReassigningProps) {
                      !(instance.props === finishedWork.memoizedProps) ? warning$1(false, "Expected %s props to match memoized props before " + "getSnapshotBeforeUpdate. " + "This might either be because of a bug in React, or because " + "a component reassigns its own `this.props`. " + "Please file an issue.", getComponentName(finishedWork.type) || "instance") : void 0;
                      !(instance.state === finishedWork.memoizedState) ? warning$1(false, "Expected %s state to match memoized state before " + "getSnapshotBeforeUpdate. " + "This might either be because of a bug in React, or because " + "a component reassigns its own `this.props`. " + "Please file an issue.", getComponentName(finishedWork.type) || "instance") : void 0;
                    }
                  }
                  var snapshot = instance.getSnapshotBeforeUpdate(finishedWork.elementType === finishedWork.type ? prevProps : resolveDefaultProps(finishedWork.type, prevProps), prevState);
                  {
                    var didWarnSet = didWarnAboutUndefinedSnapshotBeforeUpdate;

                    if (snapshot === undefined && !didWarnSet.has(finishedWork.type)) {
                      didWarnSet.add(finishedWork.type);
                      warningWithoutStack$1(false, "%s.getSnapshotBeforeUpdate(): A snapshot value (or null) " + "must be returned. You have returned undefined.", getComponentName(finishedWork.type));
                    }
                  }
                  instance.__reactInternalSnapshotBeforeUpdate = snapshot;
                  stopPhaseTimer();
                }
              }

              return;
            }

          case HostRoot:
          case HostComponent:
          case HostText:
          case HostPortal:
          case IncompleteClassComponent:
            return;

          default:
            {
              (function () {
                {
                  throw ReactError(Error("This unit of work tag should not have side-effects. This error is likely caused by a bug in React. Please file an issue."));
                }
              })();
            }
        }
      }

      function commitHookEffectList(unmountTag, mountTag, finishedWork) {
        var updateQueue = finishedWork.updateQueue;
        var lastEffect = updateQueue !== null ? updateQueue.lastEffect : null;

        if (lastEffect !== null) {
          var firstEffect = lastEffect.next;
          var effect = firstEffect;

          do {
            if ((effect.tag & unmountTag) !== NoEffect$1) {
              var destroy = effect.destroy;
              effect.destroy = undefined;

              if (destroy !== undefined) {
                destroy();
              }
            }

            if ((effect.tag & mountTag) !== NoEffect$1) {
              var create = effect.create;
              effect.destroy = create();
              {
                var _destroy = effect.destroy;

                if (_destroy !== undefined && typeof _destroy !== "function") {
                  var addendum = void 0;

                  if (_destroy === null) {
                    addendum = " You returned null. If your effect does not require clean " + "up, return undefined (or nothing).";
                  } else if (typeof _destroy.then === "function") {
                    addendum = "\n\nIt looks like you wrote useEffect(async () => ...) or returned a Promise. " + "Instead, write the async function inside your effect " + "and call it immediately:\n\n" + "useEffect(() => {\n" + "  async function fetchData() {\n" + "    // You can await here\n" + "    const response = await MyAPI.getData(someId);\n" + "    // ...\n" + "  }\n" + "  fetchData();\n" + "}, [someId]); // Or [] if effect doesn't need props or state\n\n" + "Learn more about data fetching with Hooks: https://fb.me/react-hooks-data-fetching";
                  } else {
                    addendum = " You returned: " + _destroy;
                  }

                  warningWithoutStack$1(false, "An effect function must not return anything besides a function, " + "which is used for clean-up.%s%s", addendum, getStackByFiberInDevAndProd(finishedWork));
                }
              }
            }

            effect = effect.next;
          } while (effect !== firstEffect);
        }
      }

      function commitPassiveHookEffects(finishedWork) {
        if ((finishedWork.effectTag & Passive) !== NoEffect) {
          switch (finishedWork.tag) {
            case FunctionComponent:
            case ForwardRef:
            case SimpleMemoComponent:
              {
                commitHookEffectList(UnmountPassive, NoEffect$1, finishedWork);
                commitHookEffectList(NoEffect$1, MountPassive, finishedWork);
                break;
              }

            default:
              break;
          }
        }
      }

      function commitLifeCycles(finishedRoot, current$$1, finishedWork, committedExpirationTime) {
        switch (finishedWork.tag) {
          case FunctionComponent:
          case ForwardRef:
          case SimpleMemoComponent:
            {
              commitHookEffectList(UnmountLayout, MountLayout, finishedWork);
              break;
            }

          case ClassComponent:
            {
              var instance = finishedWork.stateNode;

              if (finishedWork.effectTag & Update) {
                if (current$$1 === null) {
                  startPhaseTimer(finishedWork, "componentDidMount");
                  {
                    if (finishedWork.type === finishedWork.elementType && !didWarnAboutReassigningProps) {
                      !(instance.props === finishedWork.memoizedProps) ? warning$1(false, "Expected %s props to match memoized props before " + "componentDidMount. " + "This might either be because of a bug in React, or because " + "a component reassigns its own `this.props`. " + "Please file an issue.", getComponentName(finishedWork.type) || "instance") : void 0;
                      !(instance.state === finishedWork.memoizedState) ? warning$1(false, "Expected %s state to match memoized state before " + "componentDidMount. " + "This might either be because of a bug in React, or because " + "a component reassigns its own `this.props`. " + "Please file an issue.", getComponentName(finishedWork.type) || "instance") : void 0;
                    }
                  }
                  instance.componentDidMount();
                  stopPhaseTimer();
                } else {
                  var prevProps = finishedWork.elementType === finishedWork.type ? current$$1.memoizedProps : resolveDefaultProps(finishedWork.type, current$$1.memoizedProps);
                  var prevState = current$$1.memoizedState;
                  startPhaseTimer(finishedWork, "componentDidUpdate");
                  {
                    if (finishedWork.type === finishedWork.elementType && !didWarnAboutReassigningProps) {
                      !(instance.props === finishedWork.memoizedProps) ? warning$1(false, "Expected %s props to match memoized props before " + "componentDidUpdate. " + "This might either be because of a bug in React, or because " + "a component reassigns its own `this.props`. " + "Please file an issue.", getComponentName(finishedWork.type) || "instance") : void 0;
                      !(instance.state === finishedWork.memoizedState) ? warning$1(false, "Expected %s state to match memoized state before " + "componentDidUpdate. " + "This might either be because of a bug in React, or because " + "a component reassigns its own `this.props`. " + "Please file an issue.", getComponentName(finishedWork.type) || "instance") : void 0;
                    }
                  }
                  instance.componentDidUpdate(prevProps, prevState, instance.__reactInternalSnapshotBeforeUpdate);
                  stopPhaseTimer();
                }
              }

              var updateQueue = finishedWork.updateQueue;

              if (updateQueue !== null) {
                {
                  if (finishedWork.type === finishedWork.elementType && !didWarnAboutReassigningProps) {
                    !(instance.props === finishedWork.memoizedProps) ? warning$1(false, "Expected %s props to match memoized props before " + "processing the update queue. " + "This might either be because of a bug in React, or because " + "a component reassigns its own `this.props`. " + "Please file an issue.", getComponentName(finishedWork.type) || "instance") : void 0;
                    !(instance.state === finishedWork.memoizedState) ? warning$1(false, "Expected %s state to match memoized state before " + "processing the update queue. " + "This might either be because of a bug in React, or because " + "a component reassigns its own `this.props`. " + "Please file an issue.", getComponentName(finishedWork.type) || "instance") : void 0;
                  }
                }
                commitUpdateQueue(finishedWork, updateQueue, instance, committedExpirationTime);
              }

              return;
            }

          case HostRoot:
            {
              var _updateQueue = finishedWork.updateQueue;

              if (_updateQueue !== null) {
                var _instance = null;

                if (finishedWork.child !== null) {
                  switch (finishedWork.child.tag) {
                    case HostComponent:
                      _instance = getPublicInstance(finishedWork.child.stateNode);
                      break;

                    case ClassComponent:
                      _instance = finishedWork.child.stateNode;
                      break;
                  }
                }

                commitUpdateQueue(finishedWork, _updateQueue, _instance, committedExpirationTime);
              }

              return;
            }

          case HostComponent:
            {
              var _instance2 = finishedWork.stateNode;

              if (current$$1 === null && finishedWork.effectTag & Update) {
                var type = finishedWork.type;
                var props = finishedWork.memoizedProps;
                commitMount(_instance2, type, props, finishedWork);
              }

              return;
            }

          case HostText:
            {
              return;
            }

          case HostPortal:
            {
              return;
            }

          case Profiler:
            {
              if (enableProfilerTimer) {
                var onRender = finishedWork.memoizedProps.onRender;

                if (typeof onRender === "function") {
                  if (enableSchedulerTracing) {
                    onRender(finishedWork.memoizedProps.id, current$$1 === null ? "mount" : "update", finishedWork.actualDuration, finishedWork.treeBaseDuration, finishedWork.actualStartTime, getCommitTime(), finishedRoot.memoizedInteractions);
                  } else {
                    onRender(finishedWork.memoizedProps.id, current$$1 === null ? "mount" : "update", finishedWork.actualDuration, finishedWork.treeBaseDuration, finishedWork.actualStartTime, getCommitTime());
                  }
                }
              }

              return;
            }

          case SuspenseComponent:
          case SuspenseListComponent:
          case IncompleteClassComponent:
          case FundamentalComponent:
            return;

          default:
            {
              (function () {
                {
                  throw ReactError(Error("This unit of work tag should not have side-effects. This error is likely caused by a bug in React. Please file an issue."));
                }
              })();
            }
        }
      }

      function hideOrUnhideAllChildren(finishedWork, isHidden) {
        if (supportsMutation) {
          var node = finishedWork;

          while (true) {
            if (node.tag === HostComponent) {
              var instance = node.stateNode;

              if (isHidden) {
                hideInstance(instance);
              } else {
                unhideInstance(node.stateNode, node.memoizedProps);
              }
            } else if (node.tag === HostText) {
              var _instance3 = node.stateNode;

              if (isHidden) {
                hideTextInstance(_instance3);
              } else {
                unhideTextInstance(_instance3, node.memoizedProps);
              }
            } else if (node.tag === SuspenseComponent && node.memoizedState !== null) {
              var fallbackChildFragment = node.child.sibling;
              fallbackChildFragment.return = node;
              node = fallbackChildFragment;
              continue;
            } else if (node.child !== null) {
              node.child.return = node;
              node = node.child;
              continue;
            }

            if (node === finishedWork) {
              return;
            }

            while (node.sibling === null) {
              if (node.return === null || node.return === finishedWork) {
                return;
              }

              node = node.return;
            }

            node.sibling.return = node.return;
            node = node.sibling;
          }
        }
      }

      function commitAttachRef(finishedWork) {
        var ref = finishedWork.ref;

        if (ref !== null) {
          var instance = finishedWork.stateNode;
          var instanceToUse = void 0;

          switch (finishedWork.tag) {
            case HostComponent:
              instanceToUse = getPublicInstance(instance);
              break;

            default:
              instanceToUse = instance;
          }

          if (typeof ref === "function") {
            ref(instanceToUse);
          } else {
            {
              if (!ref.hasOwnProperty("current")) {
                warningWithoutStack$1(false, "Unexpected ref object provided for %s. " + "Use either a ref-setter function or React.createRef().%s", getComponentName(finishedWork.type), getStackByFiberInDevAndProd(finishedWork));
              }
            }
            ref.current = instanceToUse;
          }
        }
      }

      function commitDetachRef(current$$1) {
        var currentRef = current$$1.ref;

        if (currentRef !== null) {
          if (typeof currentRef === "function") {
            currentRef(null);
          } else {
            currentRef.current = null;
          }
        }
      }

      function commitUnmount(current$$1, renderPriorityLevel) {
        onCommitUnmount(current$$1);

        switch (current$$1.tag) {
          case FunctionComponent:
          case ForwardRef:
          case MemoComponent:
          case SimpleMemoComponent:
            {
              var updateQueue = current$$1.updateQueue;

              if (updateQueue !== null) {
                var lastEffect = updateQueue.lastEffect;

                if (lastEffect !== null) {
                  var firstEffect = lastEffect.next;
                  var priorityLevel = renderPriorityLevel > NormalPriority ? NormalPriority : renderPriorityLevel;
                  runWithPriority$1(priorityLevel, function () {
                    var effect = firstEffect;

                    do {
                      var destroy = effect.destroy;

                      if (destroy !== undefined) {
                        safelyCallDestroy(current$$1, destroy);
                      }

                      effect = effect.next;
                    } while (effect !== firstEffect);
                  });
                }
              }

              break;
            }

          case ClassComponent:
            {
              safelyDetachRef(current$$1);
              var instance = current$$1.stateNode;

              if (typeof instance.componentWillUnmount === "function") {
                safelyCallComponentWillUnmount(current$$1, instance);
              }

              return;
            }

          case HostComponent:
            {
              if (enableFlareAPI) {
                var dependencies = current$$1.dependencies;

                if (dependencies !== null) {
                  var respondersMap = dependencies.responders;

                  if (respondersMap !== null) {
                    var responderInstances = Array.from(respondersMap.values());

                    for (var i = 0, length = responderInstances.length; i < length; i++) {
                      var responderInstance = responderInstances[i];
                      unmountResponderInstance(responderInstance);
                    }

                    dependencies.responders = null;
                  }
                }
              }

              safelyDetachRef(current$$1);
              return;
            }

          case HostPortal:
            {
              if (supportsMutation) {
                unmountHostComponents(current$$1, renderPriorityLevel);
              } else if (supportsPersistence) {
                emptyPortalContainer(current$$1);
              }

              return;
            }

          case FundamentalComponent:
            {
              if (enableFundamentalAPI) {
                var fundamentalInstance = current$$1.stateNode;

                if (fundamentalInstance !== null) {
                  unmountFundamentalComponent(fundamentalInstance);
                  current$$1.stateNode = null;
                }
              }
            }
        }
      }

      function commitNestedUnmounts(root, renderPriorityLevel) {
        var node = root;

        while (true) {
          commitUnmount(node, renderPriorityLevel);

          if (node.child !== null && (!supportsMutation || node.tag !== HostPortal)) {
            node.child.return = node;
            node = node.child;
            continue;
          }

          if (node === root) {
            return;
          }

          while (node.sibling === null) {
            if (node.return === null || node.return === root) {
              return;
            }

            node = node.return;
          }

          node.sibling.return = node.return;
          node = node.sibling;
        }
      }

      function detachFiber(current$$1) {
        var alternate = current$$1.alternate;
        current$$1.return = null;
        current$$1.child = null;
        current$$1.memoizedState = null;
        current$$1.updateQueue = null;
        current$$1.dependencies = null;
        current$$1.alternate = null;
        current$$1.firstEffect = null;
        current$$1.lastEffect = null;
        current$$1.pendingProps = null;
        current$$1.memoizedProps = null;

        if (alternate !== null) {
          detachFiber(alternate);
        }
      }

      function emptyPortalContainer(current$$1) {
        if (!supportsPersistence) {
          return;
        }

        var portal = current$$1.stateNode;
        var containerInfo = portal.containerInfo;
        var emptyChildSet = createContainerChildSet(containerInfo);
      }

      function commitContainer(finishedWork) {
        if (!supportsPersistence) {
          return;
        }

        switch (finishedWork.tag) {
          case ClassComponent:
          case HostComponent:
          case HostText:
          case FundamentalComponent:
            {
              return;
            }

          case HostRoot:
          case HostPortal:
            {
              var portalOrRoot = finishedWork.stateNode;
              var containerInfo = portalOrRoot.containerInfo,
                  _pendingChildren = portalOrRoot.pendingChildren;
              return;
            }

          default:
            {
              (function () {
                {
                  throw ReactError(Error("This unit of work tag should not have side-effects. This error is likely caused by a bug in React. Please file an issue."));
                }
              })();
            }
        }
      }

      function getHostParentFiber(fiber) {
        var parent = fiber.return;

        while (parent !== null) {
          if (isHostParent(parent)) {
            return parent;
          }

          parent = parent.return;
        }

        (function () {
          {
            throw ReactError(Error("Expected to find a host parent. This error is likely caused by a bug in React. Please file an issue."));
          }
        })();
      }

      function isHostParent(fiber) {
        return fiber.tag === HostComponent || fiber.tag === HostRoot || fiber.tag === HostPortal;
      }

      function getHostSibling(fiber) {
        var node = fiber;

        siblings: while (true) {
          while (node.sibling === null) {
            if (node.return === null || isHostParent(node.return)) {
              return null;
            }

            node = node.return;
          }

          node.sibling.return = node.return;
          node = node.sibling;

          while (node.tag !== HostComponent && node.tag !== HostText && node.tag !== DehydratedSuspenseComponent) {
            if (node.effectTag & Placement) {
              continue siblings;
            }

            if (node.child === null || node.tag === HostPortal) {
              continue siblings;
            } else {
              node.child.return = node;
              node = node.child;
            }
          }

          if (!(node.effectTag & Placement)) {
            return node.stateNode;
          }
        }
      }

      function commitPlacement(finishedWork) {
        if (!supportsMutation) {
          return;
        }

        var parentFiber = getHostParentFiber(finishedWork);
        var parent = void 0;
        var isContainer = void 0;
        var parentStateNode = parentFiber.stateNode;

        switch (parentFiber.tag) {
          case HostComponent:
            parent = parentStateNode;
            isContainer = false;
            break;

          case HostRoot:
            parent = parentStateNode.containerInfo;
            isContainer = true;
            break;

          case HostPortal:
            parent = parentStateNode.containerInfo;
            isContainer = true;
            break;

          case FundamentalComponent:
            if (enableFundamentalAPI) {
              parent = parentStateNode.instance;
              isContainer = false;
            }

          default:
            (function () {
              {
                throw ReactError(Error("Invalid host parent fiber. This error is likely caused by a bug in React. Please file an issue."));
              }
            })();

        }

        if (parentFiber.effectTag & ContentReset) {
          resetTextContent(parent);
          parentFiber.effectTag &= ~ContentReset;
        }

        var before = getHostSibling(finishedWork);
        var node = finishedWork;

        while (true) {
          var isHost = node.tag === HostComponent || node.tag === HostText;

          if (isHost || enableFundamentalAPI && node.tag === FundamentalComponent) {
            var stateNode = isHost ? node.stateNode : node.stateNode.instance;

            if (before) {
              if (isContainer) {
                insertInContainerBefore(parent, stateNode, before);
              } else {
                insertBefore(parent, stateNode, before);
              }
            } else {
              if (isContainer) {
                appendChildToContainer(parent, stateNode);
              } else {
                appendChild(parent, stateNode);
              }
            }
          } else if (node.tag === HostPortal) {} else if (node.child !== null) {
            node.child.return = node;
            node = node.child;
            continue;
          }

          if (node === finishedWork) {
            return;
          }

          while (node.sibling === null) {
            if (node.return === null || node.return === finishedWork) {
              return;
            }

            node = node.return;
          }

          node.sibling.return = node.return;
          node = node.sibling;
        }
      }

      function unmountHostComponents(current$$1, renderPriorityLevel) {
        var node = current$$1;
        var currentParentIsValid = false;
        var currentParent = void 0;
        var currentParentIsContainer = void 0;

        while (true) {
          if (!currentParentIsValid) {
            var parent = node.return;

            findParent: while (true) {
              (function () {
                if (!(parent !== null)) {
                  throw ReactError(Error("Expected to find a host parent. This error is likely caused by a bug in React. Please file an issue."));
                }
              })();

              var parentStateNode = parent.stateNode;

              switch (parent.tag) {
                case HostComponent:
                  currentParent = parentStateNode;
                  currentParentIsContainer = false;
                  break findParent;

                case HostRoot:
                  currentParent = parentStateNode.containerInfo;
                  currentParentIsContainer = true;
                  break findParent;

                case HostPortal:
                  currentParent = parentStateNode.containerInfo;
                  currentParentIsContainer = true;
                  break findParent;

                case FundamentalComponent:
                  if (enableFundamentalAPI) {
                    currentParent = parentStateNode.instance;
                    currentParentIsContainer = false;
                  }

              }

              parent = parent.return;
            }

            currentParentIsValid = true;
          }

          if (node.tag === HostComponent || node.tag === HostText) {
            commitNestedUnmounts(node, renderPriorityLevel);

            if (currentParentIsContainer) {
              removeChildFromContainer(currentParent, node.stateNode);
            } else {
              removeChild(currentParent, node.stateNode);
            }
          } else if (enableFundamentalAPI && node.tag === FundamentalComponent) {
            var fundamentalNode = node.stateNode.instance;
            commitNestedUnmounts(node, renderPriorityLevel);

            if (currentParentIsContainer) {
              removeChildFromContainer(currentParent, fundamentalNode);
            } else {
              removeChild(currentParent, fundamentalNode);
            }
          } else if (enableSuspenseServerRenderer && node.tag === DehydratedSuspenseComponent) {
            if (currentParentIsContainer) {
              clearSuspenseBoundaryFromContainer(currentParent, node.stateNode);
            } else {
              clearSuspenseBoundary(currentParent, node.stateNode);
            }
          } else if (node.tag === HostPortal) {
            if (node.child !== null) {
              currentParent = node.stateNode.containerInfo;
              currentParentIsContainer = true;
              node.child.return = node;
              node = node.child;
              continue;
            }
          } else {
            commitUnmount(node, renderPriorityLevel);

            if (node.child !== null) {
              node.child.return = node;
              node = node.child;
              continue;
            }
          }

          if (node === current$$1) {
            return;
          }

          while (node.sibling === null) {
            if (node.return === null || node.return === current$$1) {
              return;
            }

            node = node.return;

            if (node.tag === HostPortal) {
              currentParentIsValid = false;
            }
          }

          node.sibling.return = node.return;
          node = node.sibling;
        }
      }

      function commitDeletion(current$$1, renderPriorityLevel) {
        if (supportsMutation) {
          unmountHostComponents(current$$1, renderPriorityLevel);
        } else {
          commitNestedUnmounts(current$$1, renderPriorityLevel);
        }

        detachFiber(current$$1);
      }

      function commitWork(current$$1, finishedWork) {
        if (!supportsMutation) {
          switch (finishedWork.tag) {
            case FunctionComponent:
            case ForwardRef:
            case MemoComponent:
            case SimpleMemoComponent:
              {
                commitHookEffectList(UnmountMutation, MountMutation, finishedWork);
                return;
              }

            case Profiler:
              {
                return;
              }

            case SuspenseComponent:
              {
                commitSuspenseComponent(finishedWork);
                attachSuspenseRetryListeners(finishedWork);
                return;
              }

            case SuspenseListComponent:
              {
                attachSuspenseRetryListeners(finishedWork);
                return;
              }
          }

          commitContainer(finishedWork);
          return;
        }

        switch (finishedWork.tag) {
          case FunctionComponent:
          case ForwardRef:
          case MemoComponent:
          case SimpleMemoComponent:
            {
              commitHookEffectList(UnmountMutation, MountMutation, finishedWork);
              return;
            }

          case ClassComponent:
            {
              return;
            }

          case HostComponent:
            {
              var instance = finishedWork.stateNode;

              if (instance != null) {
                var newProps = finishedWork.memoizedProps;
                var oldProps = current$$1 !== null ? current$$1.memoizedProps : newProps;
                var type = finishedWork.type;
                var updatePayload = finishedWork.updateQueue;
                finishedWork.updateQueue = null;

                if (updatePayload !== null) {
                  commitUpdate(instance, updatePayload, type, oldProps, newProps, finishedWork);
                }
              }

              return;
            }

          case HostText:
            {
              (function () {
                if (!(finishedWork.stateNode !== null)) {
                  throw ReactError(Error("This should have a text node initialized. This error is likely caused by a bug in React. Please file an issue."));
                }
              })();

              var textInstance = finishedWork.stateNode;
              var newText = finishedWork.memoizedProps;
              var oldText = current$$1 !== null ? current$$1.memoizedProps : newText;
              commitTextUpdate(textInstance, oldText, newText);
              return;
            }

          case HostRoot:
            {
              return;
            }

          case Profiler:
            {
              return;
            }

          case SuspenseComponent:
            {
              commitSuspenseComponent(finishedWork);
              attachSuspenseRetryListeners(finishedWork);
              return;
            }

          case SuspenseListComponent:
            {
              attachSuspenseRetryListeners(finishedWork);
              return;
            }

          case IncompleteClassComponent:
            {
              return;
            }

          case FundamentalComponent:
            {
              if (enableFundamentalAPI) {
                var fundamentalInstance = finishedWork.stateNode;
                updateFundamentalComponent(fundamentalInstance);
              }

              return;
            }

          default:
            {
              (function () {
                {
                  throw ReactError(Error("This unit of work tag should not have side-effects. This error is likely caused by a bug in React. Please file an issue."));
                }
              })();
            }
        }
      }

      function commitSuspenseComponent(finishedWork) {
        var newState = finishedWork.memoizedState;
        var newDidTimeout = void 0;
        var primaryChildParent = finishedWork;

        if (newState === null) {
          newDidTimeout = false;
        } else {
          newDidTimeout = true;
          primaryChildParent = finishedWork.child;
          markCommitTimeOfFallback();
        }

        if (supportsMutation && primaryChildParent !== null) {
          hideOrUnhideAllChildren(primaryChildParent, newDidTimeout);
        }

        if (enableSuspenseCallback && newState !== null) {
          var suspenseCallback = finishedWork.memoizedProps.suspenseCallback;

          if (typeof suspenseCallback === "function") {
            var thenables = finishedWork.updateQueue;

            if (thenables !== null) {
              suspenseCallback(new Set(thenables));
            }
          } else {
            if (suspenseCallback !== undefined) {
              warning$1(false, "Unexpected type for suspenseCallback.");
            }
          }
        }
      }

      function attachSuspenseRetryListeners(finishedWork) {
        var thenables = finishedWork.updateQueue;

        if (thenables !== null) {
          finishedWork.updateQueue = null;
          var retryCache = finishedWork.stateNode;

          if (retryCache === null) {
            retryCache = finishedWork.stateNode = new PossiblyWeakSet$1();
          }

          thenables.forEach(function (thenable) {
            var retry = resolveRetryThenable.bind(null, finishedWork, thenable);

            if (!retryCache.has(thenable)) {
              if (enableSchedulerTracing) {
                retry = tracing.unstable_wrap(retry);
              }

              retryCache.add(thenable);
              thenable.then(retry, retry);
            }
          });
        }
      }

      function commitResetTextContent(current$$1) {
        if (!supportsMutation) {
          return;
        }

        resetTextContent(current$$1.stateNode);
      }

      var PossiblyWeakSet = typeof WeakSet === "function" ? WeakSet : Set;
      var PossiblyWeakMap = typeof WeakMap === "function" ? WeakMap : Map;

      function createRootErrorUpdate(fiber, errorInfo, expirationTime) {
        var update = createUpdate(expirationTime, null);
        update.tag = CaptureUpdate;
        update.payload = {
          element: null
        };
        var error = errorInfo.value;

        update.callback = function () {
          onUncaughtError(error);
          logError(fiber, errorInfo);
        };

        return update;
      }

      function createClassErrorUpdate(fiber, errorInfo, expirationTime) {
        var update = createUpdate(expirationTime, null);
        update.tag = CaptureUpdate;
        var getDerivedStateFromError = fiber.type.getDerivedStateFromError;

        if (typeof getDerivedStateFromError === "function") {
          var error = errorInfo.value;

          update.payload = function () {
            logError(fiber, errorInfo);
            return getDerivedStateFromError(error);
          };
        }

        var inst = fiber.stateNode;

        if (inst !== null && typeof inst.componentDidCatch === "function") {
          update.callback = function callback() {
            {
              markFailedErrorBoundaryForHotReloading(fiber);
            }

            if (typeof getDerivedStateFromError !== "function") {
              markLegacyErrorBoundaryAsFailed(this);
              logError(fiber, errorInfo);
            }

            var error = errorInfo.value;
            var stack = errorInfo.stack;
            this.componentDidCatch(error, {
              componentStack: stack !== null ? stack : ""
            });
            {
              if (typeof getDerivedStateFromError !== "function") {
                !(fiber.expirationTime === Sync) ? warningWithoutStack$1(false, "%s: Error boundaries should implement getDerivedStateFromError(). " + "In that method, return a state update to display an error message or fallback UI.", getComponentName(fiber.type) || "Unknown") : void 0;
              }
            }
          };
        } else {
          update.callback = function () {
            markFailedErrorBoundaryForHotReloading(fiber);
          };
        }

        return update;
      }

      function attachPingListener(root, renderExpirationTime, thenable) {
        var pingCache = root.pingCache;
        var threadIDs = void 0;

        if (pingCache === null) {
          pingCache = root.pingCache = new PossiblyWeakMap();
          threadIDs = new Set();
          pingCache.set(thenable, threadIDs);
        } else {
          threadIDs = pingCache.get(thenable);

          if (threadIDs === undefined) {
            threadIDs = new Set();
            pingCache.set(thenable, threadIDs);
          }
        }

        if (!threadIDs.has(renderExpirationTime)) {
          threadIDs.add(renderExpirationTime);
          var ping = pingSuspendedRoot.bind(null, root, thenable, renderExpirationTime);

          if (enableSchedulerTracing) {
            ping = tracing.unstable_wrap(ping);
          }

          thenable.then(ping, ping);
        }
      }

      function throwException(root, returnFiber, sourceFiber, value, renderExpirationTime) {
        sourceFiber.effectTag |= Incomplete;
        sourceFiber.firstEffect = sourceFiber.lastEffect = null;

        if (value !== null && typeof value === "object" && typeof value.then === "function") {
          var thenable = value;
          checkForWrongSuspensePriorityInDEV(sourceFiber);
          var hasInvisibleParentBoundary = hasSuspenseContext(suspenseStackCursor.current, InvisibleParentSuspenseContext);
          var _workInProgress = returnFiber;

          do {
            if (_workInProgress.tag === SuspenseComponent && shouldCaptureSuspense(_workInProgress, hasInvisibleParentBoundary)) {
              var thenables = _workInProgress.updateQueue;

              if (thenables === null) {
                var updateQueue = new Set();
                updateQueue.add(thenable);
                _workInProgress.updateQueue = updateQueue;
              } else {
                thenables.add(thenable);
              }

              if ((_workInProgress.mode & BatchedMode) === NoMode) {
                _workInProgress.effectTag |= DidCapture;
                sourceFiber.effectTag &= ~(LifecycleEffectMask | Incomplete);

                if (sourceFiber.tag === ClassComponent) {
                  var currentSourceFiber = sourceFiber.alternate;

                  if (currentSourceFiber === null) {
                    sourceFiber.tag = IncompleteClassComponent;
                  } else {
                    var update = createUpdate(Sync, null);
                    update.tag = ForceUpdate;
                    enqueueUpdate(sourceFiber, update);
                  }
                }

                sourceFiber.expirationTime = Sync;
                return;
              }

              attachPingListener(root, renderExpirationTime, thenable);
              _workInProgress.effectTag |= ShouldCapture;
              _workInProgress.expirationTime = renderExpirationTime;
              return;
            } else if (enableSuspenseServerRenderer && _workInProgress.tag === DehydratedSuspenseComponent) {
              attachPingListener(root, renderExpirationTime, thenable);
              var retryCache = _workInProgress.memoizedState;

              if (retryCache === null) {
                retryCache = _workInProgress.memoizedState = new PossiblyWeakSet();
                var current$$1 = _workInProgress.alternate;

                (function () {
                  if (!current$$1) {
                    throw ReactError(Error("A dehydrated suspense boundary must commit before trying to render. This is probably a bug in React."));
                  }
                })();

                current$$1.memoizedState = retryCache;
              }

              if (!retryCache.has(thenable)) {
                retryCache.add(thenable);
                var retry = resolveRetryThenable.bind(null, _workInProgress, thenable);

                if (enableSchedulerTracing) {
                  retry = tracing.unstable_wrap(retry);
                }

                thenable.then(retry, retry);
              }

              _workInProgress.effectTag |= ShouldCapture;
              _workInProgress.expirationTime = renderExpirationTime;
              return;
            }

            _workInProgress = _workInProgress.return;
          } while (_workInProgress !== null);

          value = new Error((getComponentName(sourceFiber.type) || "A React component") + " suspended while rendering, but no fallback UI was specified.\n" + "\n" + "Add a <Suspense fallback=...> component higher in the tree to " + "provide a loading indicator or placeholder to display." + getStackByFiberInDevAndProd(sourceFiber));
        }

        renderDidError();
        value = createCapturedValue(value, sourceFiber);
        var workInProgress = returnFiber;

        do {
          switch (workInProgress.tag) {
            case HostRoot:
              {
                var _errorInfo = value;
                workInProgress.effectTag |= ShouldCapture;
                workInProgress.expirationTime = renderExpirationTime;

                var _update = createRootErrorUpdate(workInProgress, _errorInfo, renderExpirationTime);

                enqueueCapturedUpdate(workInProgress, _update);
                return;
              }

            case ClassComponent:
              var errorInfo = value;
              var ctor = workInProgress.type;
              var instance = workInProgress.stateNode;

              if ((workInProgress.effectTag & DidCapture) === NoEffect && (typeof ctor.getDerivedStateFromError === "function" || instance !== null && typeof instance.componentDidCatch === "function" && !isAlreadyFailedLegacyErrorBoundary(instance))) {
                workInProgress.effectTag |= ShouldCapture;
                workInProgress.expirationTime = renderExpirationTime;

                var _update2 = createClassErrorUpdate(workInProgress, errorInfo, renderExpirationTime);

                enqueueCapturedUpdate(workInProgress, _update2);
                return;
              }

              break;

            default:
              break;
          }

          workInProgress = workInProgress.return;
        } while (workInProgress !== null);
      }

      var ceil = Math.ceil;
      var ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
      var ReactCurrentOwner$2 = ReactSharedInternals.ReactCurrentOwner;
      var IsSomeRendererActing = ReactSharedInternals.IsSomeRendererActing;
      var NoContext = 0;
      var BatchedContext = 1;
      var EventContext = 2;
      var DiscreteEventContext = 4;
      var LegacyUnbatchedContext = 8;
      var RenderContext = 16;
      var CommitContext = 32;
      var RootIncomplete = 0;
      var RootErrored = 1;
      var RootSuspended = 2;
      var RootSuspendedWithDelay = 3;
      var RootCompleted = 4;
      var executionContext = NoContext;
      var workInProgressRoot = null;
      var workInProgress = null;
      var renderExpirationTime = NoWork;
      var workInProgressRootExitStatus = RootIncomplete;
      var workInProgressRootLatestProcessedExpirationTime = Sync;
      var workInProgressRootLatestSuspenseTimeout = Sync;
      var workInProgressRootCanSuspendUsingConfig = null;
      var workInProgressRootHasPendingPing = false;
      var globalMostRecentFallbackTime = 0;
      var FALLBACK_THROTTLE_MS = 500;
      var nextEffect = null;
      var hasUncaughtError = false;
      var firstUncaughtError = null;
      var legacyErrorBoundariesThatAlreadyFailed = null;
      var rootDoesHavePassiveEffects = false;
      var rootWithPendingPassiveEffects = null;
      var pendingPassiveEffectsRenderPriority = NoPriority;
      var pendingPassiveEffectsExpirationTime = NoWork;
      var rootsWithPendingDiscreteUpdates = null;
      var NESTED_UPDATE_LIMIT = 50;
      var nestedUpdateCount = 0;
      var rootWithNestedUpdates = null;
      var NESTED_PASSIVE_UPDATE_LIMIT = 50;
      var nestedPassiveUpdateCount = 0;
      var interruptedBy = null;
      var spawnedWorkDuringRender = null;
      var currentEventTime = NoWork;

      function requestCurrentTime() {
        if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
          return msToExpirationTime(now());
        }

        if (currentEventTime !== NoWork) {
          return currentEventTime;
        }

        currentEventTime = msToExpirationTime(now());
        return currentEventTime;
      }

      function computeExpirationForFiber(currentTime, fiber, suspenseConfig) {
        var mode = fiber.mode;

        if ((mode & BatchedMode) === NoMode) {
          return Sync;
        }

        var priorityLevel = getCurrentPriorityLevel();

        if ((mode & ConcurrentMode) === NoMode) {
          return priorityLevel === ImmediatePriority ? Sync : Batched;
        }

        if ((executionContext & RenderContext) !== NoContext) {
          return renderExpirationTime;
        }

        var expirationTime = void 0;

        if (suspenseConfig !== null) {
          expirationTime = computeSuspenseExpiration(currentTime, suspenseConfig.timeoutMs | 0 || LOW_PRIORITY_EXPIRATION);
        } else {
          switch (priorityLevel) {
            case ImmediatePriority:
              expirationTime = Sync;
              break;

            case UserBlockingPriority$1:
              expirationTime = computeInteractiveExpiration(currentTime);
              break;

            case NormalPriority:
            case LowPriority:
              expirationTime = computeAsyncExpiration(currentTime);
              break;

            case IdlePriority:
              expirationTime = Never;
              break;

            default:
              (function () {
                {
                  throw ReactError(Error("Expected a valid priority level"));
                }
              })();

          }
        }

        if (workInProgressRoot !== null && expirationTime === renderExpirationTime) {
          expirationTime -= 1;
        }

        return expirationTime;
      }

      function scheduleUpdateOnFiber(fiber, expirationTime) {
        checkForNestedUpdates();
        warnAboutInvalidUpdatesOnClassComponentsInDEV(fiber);
        var root = markUpdateTimeFromFiberToRoot(fiber, expirationTime);

        if (root === null) {
          warnAboutUpdateOnUnmountedFiberInDEV(fiber);
          return;
        }

        root.pingTime = NoWork;
        checkForInterruption(fiber, expirationTime);
        recordScheduleUpdate();
        var priorityLevel = getCurrentPriorityLevel();

        if (expirationTime === Sync) {
          if ((executionContext & LegacyUnbatchedContext) !== NoContext && (executionContext & (RenderContext | CommitContext)) === NoContext) {
            schedulePendingInteractions(root, expirationTime);
            var callback = renderRoot(root, Sync, true);

            while (callback !== null) {
              callback = callback(true);
            }
          } else {
            scheduleCallbackForRoot(root, ImmediatePriority, Sync);

            if (executionContext === NoContext) {
              flushSyncCallbackQueue();
            }
          }
        } else {
          scheduleCallbackForRoot(root, priorityLevel, expirationTime);
        }

        if ((executionContext & DiscreteEventContext) !== NoContext && (priorityLevel === UserBlockingPriority$1 || priorityLevel === ImmediatePriority)) {
          if (rootsWithPendingDiscreteUpdates === null) {
            rootsWithPendingDiscreteUpdates = new Map([[root, expirationTime]]);
          } else {
            var lastDiscreteTime = rootsWithPendingDiscreteUpdates.get(root);

            if (lastDiscreteTime === undefined || lastDiscreteTime > expirationTime) {
              rootsWithPendingDiscreteUpdates.set(root, expirationTime);
            }
          }
        }
      }

      var scheduleWork = scheduleUpdateOnFiber;

      function markUpdateTimeFromFiberToRoot(fiber, expirationTime) {
        if (fiber.expirationTime < expirationTime) {
          fiber.expirationTime = expirationTime;
        }

        var alternate = fiber.alternate;

        if (alternate !== null && alternate.expirationTime < expirationTime) {
          alternate.expirationTime = expirationTime;
        }

        var node = fiber.return;
        var root = null;

        if (node === null && fiber.tag === HostRoot) {
          root = fiber.stateNode;
        } else {
          while (node !== null) {
            alternate = node.alternate;

            if (node.childExpirationTime < expirationTime) {
              node.childExpirationTime = expirationTime;

              if (alternate !== null && alternate.childExpirationTime < expirationTime) {
                alternate.childExpirationTime = expirationTime;
              }
            } else if (alternate !== null && alternate.childExpirationTime < expirationTime) {
              alternate.childExpirationTime = expirationTime;
            }

            if (node.return === null && node.tag === HostRoot) {
              root = node.stateNode;
              break;
            }

            node = node.return;
          }
        }

        if (root !== null) {
          var firstPendingTime = root.firstPendingTime;

          if (expirationTime > firstPendingTime) {
            root.firstPendingTime = expirationTime;
          }

          var lastPendingTime = root.lastPendingTime;

          if (lastPendingTime === NoWork || expirationTime < lastPendingTime) {
            root.lastPendingTime = expirationTime;
          }
        }

        return root;
      }

      function scheduleCallbackForRoot(root, priorityLevel, expirationTime) {
        var existingCallbackExpirationTime = root.callbackExpirationTime;

        if (existingCallbackExpirationTime < expirationTime) {
          var existingCallbackNode = root.callbackNode;

          if (existingCallbackNode !== null) {
            cancelCallback(existingCallbackNode);
          }

          root.callbackExpirationTime = expirationTime;

          if (expirationTime === Sync) {
            root.callbackNode = scheduleSyncCallback(runRootCallback.bind(null, root, renderRoot.bind(null, root, expirationTime)));
          } else {
            var options = null;

            if (!disableSchedulerTimeoutBasedOnReactExpirationTime && expirationTime !== Never) {
              var timeout = expirationTimeToMs(expirationTime) - now();
              options = {
                timeout: timeout
              };
            }

            root.callbackNode = scheduleCallback(priorityLevel, runRootCallback.bind(null, root, renderRoot.bind(null, root, expirationTime)), options);

            if (enableUserTimingAPI && expirationTime !== Sync && (executionContext & (RenderContext | CommitContext)) === NoContext) {
              startRequestCallbackTimer();
            }
          }
        }

        schedulePendingInteractions(root, expirationTime);
      }

      function runRootCallback(root, callback, isSync) {
        var prevCallbackNode = root.callbackNode;
        var continuation = null;

        try {
          continuation = callback(isSync);

          if (continuation !== null) {
            return runRootCallback.bind(null, root, continuation);
          } else {
            return null;
          }
        } finally {
          if (continuation === null && prevCallbackNode === root.callbackNode) {
            root.callbackNode = null;
            root.callbackExpirationTime = NoWork;
          }
        }
      }

      function flushDiscreteUpdates() {
        if ((executionContext & (BatchedContext | RenderContext | CommitContext)) !== NoContext) {
          if (true && (executionContext & RenderContext) !== NoContext) {
            warning$1(false, "unstable_flushDiscreteUpdates: Cannot flush updates when React is " + "already rendering.");
          }

          return;
        }

        flushPendingDiscreteUpdates();

        if (!revertPassiveEffectsChange) {
          flushPassiveEffects();
        }
      }

      function resolveLocksOnRoot(root, expirationTime) {
        var firstBatch = root.firstBatch;

        if (firstBatch !== null && firstBatch._defer && firstBatch._expirationTime >= expirationTime) {
          scheduleCallback(NormalPriority, function () {
            firstBatch._onComplete();

            return null;
          });
          return true;
        } else {
          return false;
        }
      }

      function flushPendingDiscreteUpdates() {
        if (rootsWithPendingDiscreteUpdates !== null) {
          var roots = rootsWithPendingDiscreteUpdates;
          rootsWithPendingDiscreteUpdates = null;
          roots.forEach(function (expirationTime, root) {
            scheduleSyncCallback(renderRoot.bind(null, root, expirationTime));
          });
          flushSyncCallbackQueue();
        }
      }

      function batchedUpdates$1(fn, a) {
        var prevExecutionContext = executionContext;
        executionContext |= BatchedContext;

        try {
          return fn(a);
        } finally {
          executionContext = prevExecutionContext;

          if (executionContext === NoContext) {
            flushSyncCallbackQueue();
          }
        }
      }

      function batchedEventUpdates$1(fn, a) {
        var prevExecutionContext = executionContext;
        executionContext |= EventContext;

        try {
          return fn(a);
        } finally {
          executionContext = prevExecutionContext;

          if (executionContext === NoContext) {
            flushSyncCallbackQueue();
          }
        }
      }

      function discreteUpdates$1(fn, a, b, c) {
        var prevExecutionContext = executionContext;
        executionContext |= DiscreteEventContext;

        try {
          return runWithPriority$1(UserBlockingPriority$1, fn.bind(null, a, b, c));
        } finally {
          executionContext = prevExecutionContext;

          if (executionContext === NoContext) {
            flushSyncCallbackQueue();
          }
        }
      }

      function flushSync(fn, a) {
        if ((executionContext & (RenderContext | CommitContext)) !== NoContext) {
          (function () {
            {
              throw ReactError(Error("flushSync was called from inside a lifecycle method. It cannot be called when React is already rendering."));
            }
          })();
        }

        var prevExecutionContext = executionContext;
        executionContext |= BatchedContext;

        try {
          return runWithPriority$1(ImmediatePriority, fn.bind(null, a));
        } finally {
          executionContext = prevExecutionContext;
          flushSyncCallbackQueue();
        }
      }

      function prepareFreshStack(root, expirationTime) {
        root.finishedWork = null;
        root.finishedExpirationTime = NoWork;
        var timeoutHandle = root.timeoutHandle;

        if (timeoutHandle !== noTimeout) {
          root.timeoutHandle = noTimeout;
          cancelTimeout(timeoutHandle);
        }

        if (workInProgress !== null) {
          var interruptedWork = workInProgress.return;

          while (interruptedWork !== null) {
            unwindInterruptedWork(interruptedWork);
            interruptedWork = interruptedWork.return;
          }
        }

        workInProgressRoot = root;
        workInProgress = createWorkInProgress(root.current, null, expirationTime);
        renderExpirationTime = expirationTime;
        workInProgressRootExitStatus = RootIncomplete;
        workInProgressRootLatestProcessedExpirationTime = Sync;
        workInProgressRootLatestSuspenseTimeout = Sync;
        workInProgressRootCanSuspendUsingConfig = null;
        workInProgressRootHasPendingPing = false;

        if (enableSchedulerTracing) {
          spawnedWorkDuringRender = null;
        }

        {
          ReactStrictModeWarnings.discardPendingWarnings();
          componentsThatTriggeredHighPriSuspend = null;
        }
      }

      function renderRoot(root, expirationTime, isSync) {
        (function () {
          if (!((executionContext & (RenderContext | CommitContext)) === NoContext)) {
            throw ReactError(Error("Should not already be working."));
          }
        })();

        if (enableUserTimingAPI && expirationTime !== Sync) {
          var didExpire = isSync;
          stopRequestCallbackTimer(didExpire);
        }

        if (root.firstPendingTime < expirationTime) {
          return null;
        }

        if (isSync && root.finishedExpirationTime === expirationTime) {
          return commitRoot.bind(null, root);
        }

        flushPassiveEffects();

        if (root !== workInProgressRoot || expirationTime !== renderExpirationTime) {
          prepareFreshStack(root, expirationTime);
          startWorkOnPendingInteractions(root, expirationTime);
        } else if (workInProgressRootExitStatus === RootSuspendedWithDelay) {
          if (workInProgressRootHasPendingPing) {
            prepareFreshStack(root, expirationTime);
          } else {
            var lastPendingTime = root.lastPendingTime;

            if (lastPendingTime < expirationTime) {
              return renderRoot.bind(null, root, lastPendingTime);
            }
          }
        }

        if (workInProgress !== null) {
          var prevExecutionContext = executionContext;
          executionContext |= RenderContext;
          var prevDispatcher = ReactCurrentDispatcher.current;

          if (prevDispatcher === null) {
            prevDispatcher = ContextOnlyDispatcher;
          }

          ReactCurrentDispatcher.current = ContextOnlyDispatcher;
          var prevInteractions = null;

          if (enableSchedulerTracing) {
            prevInteractions = tracing.__interactionsRef.current;
            tracing.__interactionsRef.current = root.memoizedInteractions;
          }

          startWorkLoopTimer(workInProgress);

          if (isSync) {
            if (expirationTime !== Sync) {
              var currentTime = requestCurrentTime();

              if (currentTime < expirationTime) {
                executionContext = prevExecutionContext;
                resetContextDependencies();
                ReactCurrentDispatcher.current = prevDispatcher;

                if (enableSchedulerTracing) {
                  tracing.__interactionsRef.current = prevInteractions;
                }

                return renderRoot.bind(null, root, currentTime);
              }
            }
          } else {
            currentEventTime = NoWork;
          }

          do {
            try {
              if (isSync) {
                workLoopSync();
              } else {
                workLoop();
              }

              break;
            } catch (thrownValue) {
              resetContextDependencies();
              resetHooks();
              var sourceFiber = workInProgress;

              if (sourceFiber === null || sourceFiber.return === null) {
                prepareFreshStack(root, expirationTime);
                executionContext = prevExecutionContext;
                throw thrownValue;
              }

              if (enableProfilerTimer && sourceFiber.mode & ProfileMode) {
                stopProfilerTimerIfRunningAndRecordDelta(sourceFiber, true);
              }

              var returnFiber = sourceFiber.return;
              throwException(root, returnFiber, sourceFiber, thrownValue, renderExpirationTime);
              workInProgress = completeUnitOfWork(sourceFiber);
            }
          } while (true);

          executionContext = prevExecutionContext;
          resetContextDependencies();
          ReactCurrentDispatcher.current = prevDispatcher;

          if (enableSchedulerTracing) {
            tracing.__interactionsRef.current = prevInteractions;
          }

          if (workInProgress !== null) {
            stopInterruptedWorkLoopTimer();

            if (expirationTime !== Sync) {
              startRequestCallbackTimer();
            }

            return renderRoot.bind(null, root, expirationTime);
          }
        }

        stopFinishedWorkLoopTimer();
        root.finishedWork = root.current.alternate;
        root.finishedExpirationTime = expirationTime;
        var isLocked = resolveLocksOnRoot(root, expirationTime);

        if (isLocked) {
          return null;
        }

        workInProgressRoot = null;

        switch (workInProgressRootExitStatus) {
          case RootIncomplete:
            {
              (function () {
                {
                  throw ReactError(Error("Should have a work-in-progress."));
                }
              })();
            }

          case RootErrored:
            {
              var _lastPendingTime = root.lastPendingTime;

              if (_lastPendingTime < expirationTime) {
                return renderRoot.bind(null, root, _lastPendingTime);
              }

              if (!isSync) {
                prepareFreshStack(root, expirationTime);
                scheduleSyncCallback(renderRoot.bind(null, root, expirationTime));
                return null;
              }

              return commitRoot.bind(null, root);
            }

          case RootSuspended:
            {
              flushSuspensePriorityWarningInDEV();
              var hasNotProcessedNewUpdates = workInProgressRootLatestProcessedExpirationTime === Sync;

              if (hasNotProcessedNewUpdates && !isSync && !(true && flushSuspenseFallbacksInTests && IsThisRendererActing.current)) {
                var msUntilTimeout = globalMostRecentFallbackTime + FALLBACK_THROTTLE_MS - now();

                if (msUntilTimeout > 10) {
                  if (workInProgressRootHasPendingPing) {
                    prepareFreshStack(root, expirationTime);
                    return renderRoot.bind(null, root, expirationTime);
                  }

                  var _lastPendingTime2 = root.lastPendingTime;

                  if (_lastPendingTime2 < expirationTime) {
                    return renderRoot.bind(null, root, _lastPendingTime2);
                  }

                  root.timeoutHandle = scheduleTimeout(commitRoot.bind(null, root), msUntilTimeout);
                  return null;
                }
              }

              return commitRoot.bind(null, root);
            }

          case RootSuspendedWithDelay:
            {
              flushSuspensePriorityWarningInDEV();

              if (!isSync && !(true && flushSuspenseFallbacksInTests && IsThisRendererActing.current)) {
                if (workInProgressRootHasPendingPing) {
                  prepareFreshStack(root, expirationTime);
                  return renderRoot.bind(null, root, expirationTime);
                }

                var _lastPendingTime3 = root.lastPendingTime;

                if (_lastPendingTime3 < expirationTime) {
                  return renderRoot.bind(null, root, _lastPendingTime3);
                }

                var _msUntilTimeout = void 0;

                if (workInProgressRootLatestSuspenseTimeout !== Sync) {
                  _msUntilTimeout = expirationTimeToMs(workInProgressRootLatestSuspenseTimeout) - now();
                } else if (workInProgressRootLatestProcessedExpirationTime === Sync) {
                  _msUntilTimeout = 0;
                } else {
                  var eventTimeMs = inferTimeFromExpirationTime(workInProgressRootLatestProcessedExpirationTime);
                  var currentTimeMs = now();
                  var timeUntilExpirationMs = expirationTimeToMs(expirationTime) - currentTimeMs;
                  var timeElapsed = currentTimeMs - eventTimeMs;

                  if (timeElapsed < 0) {
                    timeElapsed = 0;
                  }

                  _msUntilTimeout = jnd(timeElapsed) - timeElapsed;

                  if (timeUntilExpirationMs < _msUntilTimeout) {
                    _msUntilTimeout = timeUntilExpirationMs;
                  }
                }

                if (_msUntilTimeout > 10) {
                  root.timeoutHandle = scheduleTimeout(commitRoot.bind(null, root), _msUntilTimeout);
                  return null;
                }
              }

              return commitRoot.bind(null, root);
            }

          case RootCompleted:
            {
              if (!isSync && !(true && flushSuspenseFallbacksInTests && IsThisRendererActing.current) && workInProgressRootLatestProcessedExpirationTime !== Sync && workInProgressRootCanSuspendUsingConfig !== null) {
                var _msUntilTimeout2 = computeMsUntilSuspenseLoadingDelay(workInProgressRootLatestProcessedExpirationTime, expirationTime, workInProgressRootCanSuspendUsingConfig);

                if (_msUntilTimeout2 > 10) {
                  root.timeoutHandle = scheduleTimeout(commitRoot.bind(null, root), _msUntilTimeout2);
                  return null;
                }
              }

              return commitRoot.bind(null, root);
            }

          default:
            {
              (function () {
                {
                  throw ReactError(Error("Unknown root exit status."));
                }
              })();
            }
        }
      }

      function markCommitTimeOfFallback() {
        globalMostRecentFallbackTime = now();
      }

      function markRenderEventTimeAndConfig(expirationTime, suspenseConfig) {
        if (expirationTime < workInProgressRootLatestProcessedExpirationTime && expirationTime > Never) {
          workInProgressRootLatestProcessedExpirationTime = expirationTime;
        }

        if (suspenseConfig !== null) {
          if (expirationTime < workInProgressRootLatestSuspenseTimeout && expirationTime > Never) {
            workInProgressRootLatestSuspenseTimeout = expirationTime;
            workInProgressRootCanSuspendUsingConfig = suspenseConfig;
          }
        }
      }

      function renderDidSuspend() {
        if (workInProgressRootExitStatus === RootIncomplete) {
          workInProgressRootExitStatus = RootSuspended;
        }
      }

      function renderDidSuspendDelayIfPossible() {
        if (workInProgressRootExitStatus === RootIncomplete || workInProgressRootExitStatus === RootSuspended) {
          workInProgressRootExitStatus = RootSuspendedWithDelay;
        }
      }

      function renderDidError() {
        if (workInProgressRootExitStatus !== RootCompleted) {
          workInProgressRootExitStatus = RootErrored;
        }
      }

      function renderHasNotSuspendedYet() {
        return workInProgressRootExitStatus === RootIncomplete;
      }

      function inferTimeFromExpirationTime(expirationTime) {
        var earliestExpirationTimeMs = expirationTimeToMs(expirationTime);
        return earliestExpirationTimeMs - LOW_PRIORITY_EXPIRATION;
      }

      function inferTimeFromExpirationTimeWithSuspenseConfig(expirationTime, suspenseConfig) {
        var earliestExpirationTimeMs = expirationTimeToMs(expirationTime);
        return earliestExpirationTimeMs - (suspenseConfig.timeoutMs | 0 || LOW_PRIORITY_EXPIRATION);
      }

      function workLoopSync() {
        while (workInProgress !== null) {
          workInProgress = performUnitOfWork(workInProgress);
        }
      }

      function workLoop() {
        while (workInProgress !== null && !shouldYield()) {
          workInProgress = performUnitOfWork(workInProgress);
        }
      }

      function performUnitOfWork(unitOfWork) {
        var current$$1 = unitOfWork.alternate;
        startWorkTimer(unitOfWork);
        setCurrentFiber(unitOfWork);
        var next = void 0;

        if (enableProfilerTimer && (unitOfWork.mode & ProfileMode) !== NoMode) {
          startProfilerTimer(unitOfWork);
          next = beginWork$$1(current$$1, unitOfWork, renderExpirationTime);
          stopProfilerTimerIfRunningAndRecordDelta(unitOfWork, true);
        } else {
          next = beginWork$$1(current$$1, unitOfWork, renderExpirationTime);
        }

        resetCurrentFiber();
        unitOfWork.memoizedProps = unitOfWork.pendingProps;

        if (next === null) {
          next = completeUnitOfWork(unitOfWork);
        }

        ReactCurrentOwner$2.current = null;
        return next;
      }

      function completeUnitOfWork(unitOfWork) {
        workInProgress = unitOfWork;

        do {
          var current$$1 = workInProgress.alternate;
          var returnFiber = workInProgress.return;

          if ((workInProgress.effectTag & Incomplete) === NoEffect) {
            setCurrentFiber(workInProgress);
            var next = void 0;

            if (!enableProfilerTimer || (workInProgress.mode & ProfileMode) === NoMode) {
              next = completeWork(current$$1, workInProgress, renderExpirationTime);
            } else {
              startProfilerTimer(workInProgress);
              next = completeWork(current$$1, workInProgress, renderExpirationTime);
              stopProfilerTimerIfRunningAndRecordDelta(workInProgress, false);
            }

            stopWorkTimer(workInProgress);
            resetCurrentFiber();
            resetChildExpirationTime(workInProgress);

            if (next !== null) {
              return next;
            }

            if (returnFiber !== null && (returnFiber.effectTag & Incomplete) === NoEffect) {
              if (returnFiber.firstEffect === null) {
                returnFiber.firstEffect = workInProgress.firstEffect;
              }

              if (workInProgress.lastEffect !== null) {
                if (returnFiber.lastEffect !== null) {
                  returnFiber.lastEffect.nextEffect = workInProgress.firstEffect;
                }

                returnFiber.lastEffect = workInProgress.lastEffect;
              }

              var effectTag = workInProgress.effectTag;

              if (effectTag > PerformedWork) {
                if (returnFiber.lastEffect !== null) {
                  returnFiber.lastEffect.nextEffect = workInProgress;
                } else {
                  returnFiber.firstEffect = workInProgress;
                }

                returnFiber.lastEffect = workInProgress;
              }
            }
          } else {
            var _next = unwindWork(workInProgress, renderExpirationTime);

            if (enableProfilerTimer && (workInProgress.mode & ProfileMode) !== NoMode) {
              stopProfilerTimerIfRunningAndRecordDelta(workInProgress, false);
              var actualDuration = workInProgress.actualDuration;
              var child = workInProgress.child;

              while (child !== null) {
                actualDuration += child.actualDuration;
                child = child.sibling;
              }

              workInProgress.actualDuration = actualDuration;
            }

            if (_next !== null) {
              stopFailedWorkTimer(workInProgress);
              _next.effectTag &= HostEffectMask;
              return _next;
            }

            stopWorkTimer(workInProgress);

            if (returnFiber !== null) {
              returnFiber.firstEffect = returnFiber.lastEffect = null;
              returnFiber.effectTag |= Incomplete;
            }
          }

          var siblingFiber = workInProgress.sibling;

          if (siblingFiber !== null) {
            return siblingFiber;
          }

          workInProgress = returnFiber;
        } while (workInProgress !== null);

        if (workInProgressRootExitStatus === RootIncomplete) {
          workInProgressRootExitStatus = RootCompleted;
        }

        return null;
      }

      function resetChildExpirationTime(completedWork) {
        if (renderExpirationTime !== Never && completedWork.childExpirationTime === Never) {
          return;
        }

        var newChildExpirationTime = NoWork;

        if (enableProfilerTimer && (completedWork.mode & ProfileMode) !== NoMode) {
          var actualDuration = completedWork.actualDuration;
          var treeBaseDuration = completedWork.selfBaseDuration;
          var shouldBubbleActualDurations = completedWork.alternate === null || completedWork.child !== completedWork.alternate.child;
          var child = completedWork.child;

          while (child !== null) {
            var childUpdateExpirationTime = child.expirationTime;
            var childChildExpirationTime = child.childExpirationTime;

            if (childUpdateExpirationTime > newChildExpirationTime) {
              newChildExpirationTime = childUpdateExpirationTime;
            }

            if (childChildExpirationTime > newChildExpirationTime) {
              newChildExpirationTime = childChildExpirationTime;
            }

            if (shouldBubbleActualDurations) {
              actualDuration += child.actualDuration;
            }

            treeBaseDuration += child.treeBaseDuration;
            child = child.sibling;
          }

          completedWork.actualDuration = actualDuration;
          completedWork.treeBaseDuration = treeBaseDuration;
        } else {
          var _child = completedWork.child;

          while (_child !== null) {
            var _childUpdateExpirationTime = _child.expirationTime;
            var _childChildExpirationTime = _child.childExpirationTime;

            if (_childUpdateExpirationTime > newChildExpirationTime) {
              newChildExpirationTime = _childUpdateExpirationTime;
            }

            if (_childChildExpirationTime > newChildExpirationTime) {
              newChildExpirationTime = _childChildExpirationTime;
            }

            _child = _child.sibling;
          }
        }

        completedWork.childExpirationTime = newChildExpirationTime;
      }

      function commitRoot(root) {
        var renderPriorityLevel = getCurrentPriorityLevel();
        runWithPriority$1(ImmediatePriority, commitRootImpl.bind(null, root, renderPriorityLevel));

        if (rootWithPendingPassiveEffects !== null) {
          scheduleCallback(NormalPriority, function () {
            flushPassiveEffects();
            return null;
          });
        }

        return null;
      }

      function commitRootImpl(root, renderPriorityLevel) {
        flushPassiveEffects();
        flushRenderPhaseStrictModeWarningsInDEV();

        (function () {
          if (!((executionContext & (RenderContext | CommitContext)) === NoContext)) {
            throw ReactError(Error("Should not already be working."));
          }
        })();

        var finishedWork = root.finishedWork;
        var expirationTime = root.finishedExpirationTime;

        if (finishedWork === null) {
          return null;
        }

        root.finishedWork = null;
        root.finishedExpirationTime = NoWork;

        (function () {
          if (!(finishedWork !== root.current)) {
            throw ReactError(Error("Cannot commit the same tree as before. This error is likely caused by a bug in React. Please file an issue."));
          }
        })();

        root.callbackNode = null;
        root.callbackExpirationTime = NoWork;
        startCommitTimer();
        var updateExpirationTimeBeforeCommit = finishedWork.expirationTime;
        var childExpirationTimeBeforeCommit = finishedWork.childExpirationTime;
        var firstPendingTimeBeforeCommit = childExpirationTimeBeforeCommit > updateExpirationTimeBeforeCommit ? childExpirationTimeBeforeCommit : updateExpirationTimeBeforeCommit;
        root.firstPendingTime = firstPendingTimeBeforeCommit;

        if (firstPendingTimeBeforeCommit < root.lastPendingTime) {
          root.lastPendingTime = firstPendingTimeBeforeCommit;
        }

        if (root === workInProgressRoot) {
          workInProgressRoot = null;
          workInProgress = null;
          renderExpirationTime = NoWork;
        } else {}

        var firstEffect = void 0;

        if (finishedWork.effectTag > PerformedWork) {
          if (finishedWork.lastEffect !== null) {
            finishedWork.lastEffect.nextEffect = finishedWork;
            firstEffect = finishedWork.firstEffect;
          } else {
            firstEffect = finishedWork;
          }
        } else {
          firstEffect = finishedWork.firstEffect;
        }

        if (firstEffect !== null) {
          var prevExecutionContext = executionContext;
          executionContext |= CommitContext;
          var prevInteractions = null;

          if (enableSchedulerTracing) {
            prevInteractions = tracing.__interactionsRef.current;
            tracing.__interactionsRef.current = root.memoizedInteractions;
          }

          ReactCurrentOwner$2.current = null;
          startCommitSnapshotEffectsTimer();
          prepareForCommit(root.containerInfo);
          nextEffect = firstEffect;

          do {
            {
              invokeGuardedCallback(null, commitBeforeMutationEffects, null);

              if (hasCaughtError()) {
                (function () {
                  if (!(nextEffect !== null)) {
                    throw ReactError(Error("Should be working on an effect."));
                  }
                })();

                var error = clearCaughtError();
                captureCommitPhaseError(nextEffect, error);
                nextEffect = nextEffect.nextEffect;
              }
            }
          } while (nextEffect !== null);

          stopCommitSnapshotEffectsTimer();

          if (enableProfilerTimer) {
            recordCommitTime();
          }

          startCommitHostEffectsTimer();
          nextEffect = firstEffect;

          do {
            {
              invokeGuardedCallback(null, commitMutationEffects, null, renderPriorityLevel);

              if (hasCaughtError()) {
                (function () {
                  if (!(nextEffect !== null)) {
                    throw ReactError(Error("Should be working on an effect."));
                  }
                })();

                var _error = clearCaughtError();

                captureCommitPhaseError(nextEffect, _error);
                nextEffect = nextEffect.nextEffect;
              }
            }
          } while (nextEffect !== null);

          stopCommitHostEffectsTimer();
          resetAfterCommit(root.containerInfo);
          root.current = finishedWork;
          startCommitLifeCyclesTimer();
          nextEffect = firstEffect;

          do {
            {
              invokeGuardedCallback(null, commitLayoutEffects, null, root, expirationTime);

              if (hasCaughtError()) {
                (function () {
                  if (!(nextEffect !== null)) {
                    throw ReactError(Error("Should be working on an effect."));
                  }
                })();

                var _error2 = clearCaughtError();

                captureCommitPhaseError(nextEffect, _error2);
                nextEffect = nextEffect.nextEffect;
              }
            }
          } while (nextEffect !== null);

          stopCommitLifeCyclesTimer();
          nextEffect = null;
          requestPaint();

          if (enableSchedulerTracing) {
            tracing.__interactionsRef.current = prevInteractions;
          }

          executionContext = prevExecutionContext;
        } else {
          root.current = finishedWork;
          startCommitSnapshotEffectsTimer();
          stopCommitSnapshotEffectsTimer();

          if (enableProfilerTimer) {
            recordCommitTime();
          }

          startCommitHostEffectsTimer();
          stopCommitHostEffectsTimer();
          startCommitLifeCyclesTimer();
          stopCommitLifeCyclesTimer();
        }

        stopCommitTimer();
        var rootDidHavePassiveEffects = rootDoesHavePassiveEffects;

        if (rootDoesHavePassiveEffects) {
          rootDoesHavePassiveEffects = false;
          rootWithPendingPassiveEffects = root;
          pendingPassiveEffectsExpirationTime = expirationTime;
          pendingPassiveEffectsRenderPriority = renderPriorityLevel;
        } else {
          nextEffect = firstEffect;

          while (nextEffect !== null) {
            var nextNextEffect = nextEffect.nextEffect;
            nextEffect.nextEffect = null;
            nextEffect = nextNextEffect;
          }
        }

        var remainingExpirationTime = root.firstPendingTime;

        if (remainingExpirationTime !== NoWork) {
          var currentTime = requestCurrentTime();
          var priorityLevel = inferPriorityFromExpirationTime(currentTime, remainingExpirationTime);

          if (enableSchedulerTracing) {
            if (spawnedWorkDuringRender !== null) {
              var expirationTimes = spawnedWorkDuringRender;
              spawnedWorkDuringRender = null;

              for (var i = 0; i < expirationTimes.length; i++) {
                scheduleInteractions(root, expirationTimes[i], root.memoizedInteractions);
              }
            }
          }

          scheduleCallbackForRoot(root, priorityLevel, remainingExpirationTime);
        } else {
          legacyErrorBoundariesThatAlreadyFailed = null;
        }

        if (enableSchedulerTracing) {
          if (!rootDidHavePassiveEffects) {
            finishPendingInteractions(root, expirationTime);
          }
        }

        onCommitRoot(finishedWork.stateNode, expirationTime);

        if (remainingExpirationTime === Sync) {
          if (root === rootWithNestedUpdates) {
            nestedUpdateCount++;
          } else {
            nestedUpdateCount = 0;
            rootWithNestedUpdates = root;
          }
        } else {
          nestedUpdateCount = 0;
        }

        if (hasUncaughtError) {
          hasUncaughtError = false;
          var _error3 = firstUncaughtError;
          firstUncaughtError = null;
          throw _error3;
        }

        if ((executionContext & LegacyUnbatchedContext) !== NoContext) {
          return null;
        }

        flushSyncCallbackQueue();
        return null;
      }

      function commitBeforeMutationEffects() {
        while (nextEffect !== null) {
          if ((nextEffect.effectTag & Snapshot) !== NoEffect) {
            setCurrentFiber(nextEffect);
            recordEffect();
            var current$$1 = nextEffect.alternate;
            commitBeforeMutationLifeCycles(current$$1, nextEffect);
            resetCurrentFiber();
          }

          nextEffect = nextEffect.nextEffect;
        }
      }

      function commitMutationEffects(renderPriorityLevel) {
        while (nextEffect !== null) {
          setCurrentFiber(nextEffect);
          var effectTag = nextEffect.effectTag;

          if (effectTag & ContentReset) {
            commitResetTextContent(nextEffect);
          }

          if (effectTag & Ref) {
            var current$$1 = nextEffect.alternate;

            if (current$$1 !== null) {
              commitDetachRef(current$$1);
            }
          }

          var primaryEffectTag = effectTag & (Placement | Update | Deletion);

          switch (primaryEffectTag) {
            case Placement:
              {
                commitPlacement(nextEffect);
                nextEffect.effectTag &= ~Placement;
                break;
              }

            case PlacementAndUpdate:
              {
                commitPlacement(nextEffect);
                nextEffect.effectTag &= ~Placement;
                var _current = nextEffect.alternate;
                commitWork(_current, nextEffect);
                break;
              }

            case Update:
              {
                var _current2 = nextEffect.alternate;
                commitWork(_current2, nextEffect);
                break;
              }

            case Deletion:
              {
                commitDeletion(nextEffect, renderPriorityLevel);
                break;
              }
          }

          recordEffect();
          resetCurrentFiber();
          nextEffect = nextEffect.nextEffect;
        }
      }

      function commitLayoutEffects(root, committedExpirationTime) {
        while (nextEffect !== null) {
          setCurrentFiber(nextEffect);
          var effectTag = nextEffect.effectTag;

          if (effectTag & (Update | Callback)) {
            recordEffect();
            var current$$1 = nextEffect.alternate;
            commitLifeCycles(root, current$$1, nextEffect, committedExpirationTime);
          }

          if (effectTag & Ref) {
            recordEffect();
            commitAttachRef(nextEffect);
          }

          if (effectTag & Passive) {
            rootDoesHavePassiveEffects = true;
          }

          resetCurrentFiber();
          nextEffect = nextEffect.nextEffect;
        }
      }

      function flushPassiveEffects() {
        if (rootWithPendingPassiveEffects === null) {
          return false;
        }

        var root = rootWithPendingPassiveEffects;
        var expirationTime = pendingPassiveEffectsExpirationTime;
        var renderPriorityLevel = pendingPassiveEffectsRenderPriority;
        rootWithPendingPassiveEffects = null;
        pendingPassiveEffectsExpirationTime = NoWork;
        pendingPassiveEffectsRenderPriority = NoPriority;
        var priorityLevel = renderPriorityLevel > NormalPriority ? NormalPriority : renderPriorityLevel;
        return runWithPriority$1(priorityLevel, flushPassiveEffectsImpl.bind(null, root, expirationTime));
      }

      function flushPassiveEffectsImpl(root, expirationTime) {
        var prevInteractions = null;

        if (enableSchedulerTracing) {
          prevInteractions = tracing.__interactionsRef.current;
          tracing.__interactionsRef.current = root.memoizedInteractions;
        }

        (function () {
          if (!((executionContext & (RenderContext | CommitContext)) === NoContext)) {
            throw ReactError(Error("Cannot flush passive effects while already rendering."));
          }
        })();

        var prevExecutionContext = executionContext;
        executionContext |= CommitContext;
        var effect = root.current.firstEffect;

        while (effect !== null) {
          {
            setCurrentFiber(effect);
            invokeGuardedCallback(null, commitPassiveHookEffects, null, effect);

            if (hasCaughtError()) {
              (function () {
                if (!(effect !== null)) {
                  throw ReactError(Error("Should be working on an effect."));
                }
              })();

              var error = clearCaughtError();
              captureCommitPhaseError(effect, error);
            }

            resetCurrentFiber();
          }
          var nextNextEffect = effect.nextEffect;
          effect.nextEffect = null;
          effect = nextNextEffect;
        }

        if (enableSchedulerTracing) {
          tracing.__interactionsRef.current = prevInteractions;
          finishPendingInteractions(root, expirationTime);
        }

        executionContext = prevExecutionContext;
        flushSyncCallbackQueue();
        nestedPassiveUpdateCount = rootWithPendingPassiveEffects === null ? 0 : nestedPassiveUpdateCount + 1;
        return true;
      }

      function isAlreadyFailedLegacyErrorBoundary(instance) {
        return legacyErrorBoundariesThatAlreadyFailed !== null && legacyErrorBoundariesThatAlreadyFailed.has(instance);
      }

      function markLegacyErrorBoundaryAsFailed(instance) {
        if (legacyErrorBoundariesThatAlreadyFailed === null) {
          legacyErrorBoundariesThatAlreadyFailed = new Set([instance]);
        } else {
          legacyErrorBoundariesThatAlreadyFailed.add(instance);
        }
      }

      function prepareToThrowUncaughtError(error) {
        if (!hasUncaughtError) {
          hasUncaughtError = true;
          firstUncaughtError = error;
        }
      }

      var onUncaughtError = prepareToThrowUncaughtError;

      function captureCommitPhaseErrorOnRoot(rootFiber, sourceFiber, error) {
        var errorInfo = createCapturedValue(error, sourceFiber);
        var update = createRootErrorUpdate(rootFiber, errorInfo, Sync);
        enqueueUpdate(rootFiber, update);
        var root = markUpdateTimeFromFiberToRoot(rootFiber, Sync);

        if (root !== null) {
          scheduleCallbackForRoot(root, ImmediatePriority, Sync);
        }
      }

      function captureCommitPhaseError(sourceFiber, error) {
        if (sourceFiber.tag === HostRoot) {
          captureCommitPhaseErrorOnRoot(sourceFiber, sourceFiber, error);
          return;
        }

        var fiber = sourceFiber.return;

        while (fiber !== null) {
          if (fiber.tag === HostRoot) {
            captureCommitPhaseErrorOnRoot(fiber, sourceFiber, error);
            return;
          } else if (fiber.tag === ClassComponent) {
            var ctor = fiber.type;
            var instance = fiber.stateNode;

            if (typeof ctor.getDerivedStateFromError === "function" || typeof instance.componentDidCatch === "function" && !isAlreadyFailedLegacyErrorBoundary(instance)) {
              var errorInfo = createCapturedValue(error, sourceFiber);
              var update = createClassErrorUpdate(fiber, errorInfo, Sync);
              enqueueUpdate(fiber, update);
              var root = markUpdateTimeFromFiberToRoot(fiber, Sync);

              if (root !== null) {
                scheduleCallbackForRoot(root, ImmediatePriority, Sync);
              }

              return;
            }
          }

          fiber = fiber.return;
        }
      }

      function pingSuspendedRoot(root, thenable, suspendedTime) {
        var pingCache = root.pingCache;

        if (pingCache !== null) {
          pingCache.delete(thenable);
        }

        if (workInProgressRoot === root && renderExpirationTime === suspendedTime) {
          if (workInProgressRootExitStatus === RootSuspendedWithDelay || workInProgressRootExitStatus === RootSuspended && workInProgressRootLatestProcessedExpirationTime === Sync && now() - globalMostRecentFallbackTime < FALLBACK_THROTTLE_MS) {
            prepareFreshStack(root, renderExpirationTime);
          } else {
            workInProgressRootHasPendingPing = true;
          }

          return;
        }

        var lastPendingTime = root.lastPendingTime;

        if (lastPendingTime < suspendedTime) {
          return;
        }

        var pingTime = root.pingTime;

        if (pingTime !== NoWork && pingTime < suspendedTime) {
          return;
        }

        root.pingTime = suspendedTime;

        if (root.finishedExpirationTime === suspendedTime) {
          root.finishedExpirationTime = NoWork;
          root.finishedWork = null;
        }

        var currentTime = requestCurrentTime();
        var priorityLevel = inferPriorityFromExpirationTime(currentTime, suspendedTime);
        scheduleCallbackForRoot(root, priorityLevel, suspendedTime);
      }

      function retryTimedOutBoundary(boundaryFiber) {
        var currentTime = requestCurrentTime();
        var suspenseConfig = null;
        var retryTime = computeExpirationForFiber(currentTime, boundaryFiber, suspenseConfig);
        var priorityLevel = inferPriorityFromExpirationTime(currentTime, retryTime);
        var root = markUpdateTimeFromFiberToRoot(boundaryFiber, retryTime);

        if (root !== null) {
          scheduleCallbackForRoot(root, priorityLevel, retryTime);
        }
      }

      function resolveRetryThenable(boundaryFiber, thenable) {
        var retryCache = void 0;

        if (enableSuspenseServerRenderer) {
          switch (boundaryFiber.tag) {
            case SuspenseComponent:
              retryCache = boundaryFiber.stateNode;
              break;

            case DehydratedSuspenseComponent:
              retryCache = boundaryFiber.memoizedState;
              break;

            default:
              (function () {
                {
                  throw ReactError(Error("Pinged unknown suspense boundary type. This is probably a bug in React."));
                }
              })();

          }
        } else {
          retryCache = boundaryFiber.stateNode;
        }

        if (retryCache !== null) {
          retryCache.delete(thenable);
        }

        retryTimedOutBoundary(boundaryFiber);
      }

      function jnd(timeElapsed) {
        return timeElapsed < 120 ? 120 : timeElapsed < 480 ? 480 : timeElapsed < 1080 ? 1080 : timeElapsed < 1920 ? 1920 : timeElapsed < 3000 ? 3000 : timeElapsed < 4320 ? 4320 : ceil(timeElapsed / 1960) * 1960;
      }

      function computeMsUntilSuspenseLoadingDelay(mostRecentEventTime, committedExpirationTime, suspenseConfig) {
        var busyMinDurationMs = suspenseConfig.busyMinDurationMs | 0;

        if (busyMinDurationMs <= 0) {
          return 0;
        }

        var busyDelayMs = suspenseConfig.busyDelayMs | 0;
        var currentTimeMs = now();
        var eventTimeMs = inferTimeFromExpirationTimeWithSuspenseConfig(mostRecentEventTime, suspenseConfig);
        var timeElapsed = currentTimeMs - eventTimeMs;

        if (timeElapsed <= busyDelayMs) {
          return 0;
        }

        var msUntilTimeout = busyDelayMs + busyMinDurationMs - timeElapsed;
        return msUntilTimeout;
      }

      function checkForNestedUpdates() {
        if (nestedUpdateCount > NESTED_UPDATE_LIMIT) {
          nestedUpdateCount = 0;
          rootWithNestedUpdates = null;

          (function () {
            {
              throw ReactError(Error("Maximum update depth exceeded. This can happen when a component repeatedly calls setState inside componentWillUpdate or componentDidUpdate. React limits the number of nested updates to prevent infinite loops."));
            }
          })();
        }

        {
          if (nestedPassiveUpdateCount > NESTED_PASSIVE_UPDATE_LIMIT) {
            nestedPassiveUpdateCount = 0;
            warning$1(false, "Maximum update depth exceeded. This can happen when a component " + "calls setState inside useEffect, but useEffect either doesn't " + "have a dependency array, or one of the dependencies changes on " + "every render.");
          }
        }
      }

      function flushRenderPhaseStrictModeWarningsInDEV() {
        {
          ReactStrictModeWarnings.flushLegacyContextWarning();

          if (warnAboutDeprecatedLifecycles) {
            ReactStrictModeWarnings.flushPendingUnsafeLifecycleWarnings();
          }
        }
      }

      function stopFinishedWorkLoopTimer() {
        var didCompleteRoot = true;
        stopWorkLoopTimer(interruptedBy, didCompleteRoot);
        interruptedBy = null;
      }

      function stopInterruptedWorkLoopTimer() {
        var didCompleteRoot = false;
        stopWorkLoopTimer(interruptedBy, didCompleteRoot);
        interruptedBy = null;
      }

      function checkForInterruption(fiberThatReceivedUpdate, updateExpirationTime) {
        if (enableUserTimingAPI && workInProgressRoot !== null && updateExpirationTime > renderExpirationTime) {
          interruptedBy = fiberThatReceivedUpdate;
        }
      }

      var didWarnStateUpdateForUnmountedComponent = null;

      function warnAboutUpdateOnUnmountedFiberInDEV(fiber) {
        {
          var tag = fiber.tag;

          if (tag !== HostRoot && tag !== ClassComponent && tag !== FunctionComponent && tag !== ForwardRef && tag !== MemoComponent && tag !== SimpleMemoComponent) {
            return;
          }

          var componentName = getComponentName(fiber.type) || "ReactComponent";

          if (didWarnStateUpdateForUnmountedComponent !== null) {
            if (didWarnStateUpdateForUnmountedComponent.has(componentName)) {
              return;
            }

            didWarnStateUpdateForUnmountedComponent.add(componentName);
          } else {
            didWarnStateUpdateForUnmountedComponent = new Set([componentName]);
          }

          warningWithoutStack$1(false, "Can't perform a React state update on an unmounted component. This " + "is a no-op, but it indicates a memory leak in your application. To " + "fix, cancel all subscriptions and asynchronous tasks in %s.%s", tag === ClassComponent ? "the componentWillUnmount method" : "a useEffect cleanup function", getStackByFiberInDevAndProd(fiber));
        }
      }

      var beginWork$$1 = void 0;

      if (true && replayFailedUnitOfWorkWithInvokeGuardedCallback) {
        var dummyFiber = null;

        beginWork$$1 = function beginWork$$1(current$$1, unitOfWork, expirationTime) {
          var originalWorkInProgressCopy = assignFiberPropertiesInDEV(dummyFiber, unitOfWork);

          try {
            return beginWork$1(current$$1, unitOfWork, expirationTime);
          } catch (originalError) {
            if (originalError !== null && typeof originalError === "object" && typeof originalError.then === "function") {
              throw originalError;
            }

            resetContextDependencies();
            resetHooks();
            unwindInterruptedWork(unitOfWork);
            assignFiberPropertiesInDEV(unitOfWork, originalWorkInProgressCopy);

            if (enableProfilerTimer && unitOfWork.mode & ProfileMode) {
              startProfilerTimer(unitOfWork);
            }

            invokeGuardedCallback(null, beginWork$1, null, current$$1, unitOfWork, expirationTime);

            if (hasCaughtError()) {
              var replayError = clearCaughtError();
              throw replayError;
            } else {
              throw originalError;
            }
          }
        };
      } else {
        beginWork$$1 = beginWork$1;
      }

      var didWarnAboutUpdateInRender = false;
      var didWarnAboutUpdateInGetChildContext = false;

      function warnAboutInvalidUpdatesOnClassComponentsInDEV(fiber) {
        {
          if (fiber.tag === ClassComponent) {
            switch (phase) {
              case "getChildContext":
                if (didWarnAboutUpdateInGetChildContext) {
                  return;
                }

                warningWithoutStack$1(false, "setState(...): Cannot call setState() inside getChildContext()");
                didWarnAboutUpdateInGetChildContext = true;
                break;

              case "render":
                if (didWarnAboutUpdateInRender) {
                  return;
                }

                warningWithoutStack$1(false, "Cannot update during an existing state transition (such as " + "within `render`). Render methods should be a pure function of " + "props and state.");
                didWarnAboutUpdateInRender = true;
                break;
            }
          }
        }
      }

      var IsThisRendererActing = {
        current: false
      };

      function warnIfNotScopedWithMatchingAct(fiber) {
        {
          if (warnsIfNotActing === true && IsSomeRendererActing.current === true && IsThisRendererActing.current !== true) {
            warningWithoutStack$1(false, "It looks like you're using the wrong act() around your test interactions.\n" + "Be sure to use the matching version of act() corresponding to your renderer:\n\n" + "// for react-dom:\n" + "import {act} from 'react-dom/test-utils';\n" + "// ...\n" + "act(() => ...);\n\n" + "// for react-test-renderer:\n" + "import TestRenderer from 'react-test-renderer';\n" + "const {act} = TestRenderer;\n" + "// ...\n" + "act(() => ...);" + "%s", getStackByFiberInDevAndProd(fiber));
          }
        }
      }

      function warnIfNotCurrentlyActingEffectsInDEV(fiber) {
        {
          if (warnsIfNotActing === true && (fiber.mode & StrictMode) !== NoMode && IsSomeRendererActing.current === false && IsThisRendererActing.current === false) {
            warningWithoutStack$1(false, "An update to %s ran an effect, but was not wrapped in act(...).\n\n" + "When testing, code that causes React state updates should be " + "wrapped into act(...):\n\n" + "act(() => {\n" + "  /* fire events that update state */\n" + "});\n" + "/* assert on the output */\n\n" + "This ensures that you're testing the behavior the user would see " + "in the browser." + " Learn more at https://fb.me/react-wrap-tests-with-act" + "%s", getComponentName(fiber.type), getStackByFiberInDevAndProd(fiber));
          }
        }
      }

      function warnIfNotCurrentlyActingUpdatesInDEV(fiber) {
        {
          if (warnsIfNotActing === true && executionContext === NoContext && IsSomeRendererActing.current === false && IsThisRendererActing.current === false) {
            warningWithoutStack$1(false, "An update to %s inside a test was not wrapped in act(...).\n\n" + "When testing, code that causes React state updates should be " + "wrapped into act(...):\n\n" + "act(() => {\n" + "  /* fire events that update state */\n" + "});\n" + "/* assert on the output */\n\n" + "This ensures that you're testing the behavior the user would see " + "in the browser." + " Learn more at https://fb.me/react-wrap-tests-with-act" + "%s", getComponentName(fiber.type), getStackByFiberInDevAndProd(fiber));
          }
        }
      }

      var warnIfNotCurrentlyActingUpdatesInDev = warnIfNotCurrentlyActingUpdatesInDEV;
      var didWarnAboutUnmockedScheduler = false;

      function warnIfUnmockedScheduler(fiber) {
        {
          if (didWarnAboutUnmockedScheduler === false && Scheduler.unstable_flushAllWithoutAsserting === undefined) {
            if (fiber.mode & BatchedMode || fiber.mode & ConcurrentMode) {
              didWarnAboutUnmockedScheduler = true;
              warningWithoutStack$1(false, 'In Concurrent or Sync modes, the "scheduler" module needs to be mocked ' + "to guarantee consistent behaviour across tests and browsers. " + "For example, with jest: \n" + "jest.mock('scheduler', () => require('scheduler/unstable_mock'));\n\n" + "For more info, visit https://fb.me/react-mock-scheduler");
            } else if (warnAboutUnmockedScheduler === true) {
              didWarnAboutUnmockedScheduler = true;
              warningWithoutStack$1(false, 'Starting from React v17, the "scheduler" module will need to be mocked ' + "to guarantee consistent behaviour across tests and browsers. " + "For example, with jest: \n" + "jest.mock('scheduler', () => require('scheduler/unstable_mock'));\n\n" + "For more info, visit https://fb.me/react-mock-scheduler");
            }
          }
        }
      }

      var componentsThatTriggeredHighPriSuspend = null;

      function checkForWrongSuspensePriorityInDEV(sourceFiber) {
        {
          var currentPriorityLevel = getCurrentPriorityLevel();

          if ((sourceFiber.mode & ConcurrentMode) !== NoEffect && (currentPriorityLevel === UserBlockingPriority$1 || currentPriorityLevel === ImmediatePriority)) {
            var workInProgressNode = sourceFiber;

            while (workInProgressNode !== null) {
              var current$$1 = workInProgressNode.alternate;

              if (current$$1 !== null) {
                switch (workInProgressNode.tag) {
                  case ClassComponent:
                    var updateQueue = current$$1.updateQueue;

                    if (updateQueue !== null) {
                      var update = updateQueue.firstUpdate;

                      while (update !== null) {
                        var priorityLevel = update.priority;

                        if (priorityLevel === UserBlockingPriority$1 || priorityLevel === ImmediatePriority) {
                          if (componentsThatTriggeredHighPriSuspend === null) {
                            componentsThatTriggeredHighPriSuspend = new Set([getComponentName(workInProgressNode.type)]);
                          } else {
                            componentsThatTriggeredHighPriSuspend.add(getComponentName(workInProgressNode.type));
                          }

                          break;
                        }

                        update = update.next;
                      }
                    }

                    break;

                  case FunctionComponent:
                  case ForwardRef:
                  case SimpleMemoComponent:
                    if (workInProgressNode.memoizedState !== null && workInProgressNode.memoizedState.baseUpdate !== null) {
                      var _update = workInProgressNode.memoizedState.baseUpdate;

                      while (_update !== null) {
                        var priority = _update.priority;

                        if (priority === UserBlockingPriority$1 || priority === ImmediatePriority) {
                          if (componentsThatTriggeredHighPriSuspend === null) {
                            componentsThatTriggeredHighPriSuspend = new Set([getComponentName(workInProgressNode.type)]);
                          } else {
                            componentsThatTriggeredHighPriSuspend.add(getComponentName(workInProgressNode.type));
                          }

                          break;
                        }

                        if (_update.next === workInProgressNode.memoizedState.baseUpdate) {
                          break;
                        }

                        _update = _update.next;
                      }
                    }

                    break;

                  default:
                    break;
                }
              }

              workInProgressNode = workInProgressNode.return;
            }
          }
        }
      }

      function flushSuspensePriorityWarningInDEV() {
        {
          if (componentsThatTriggeredHighPriSuspend !== null) {
            var componentNames = [];
            componentsThatTriggeredHighPriSuspend.forEach(function (name) {
              return componentNames.push(name);
            });
            componentsThatTriggeredHighPriSuspend = null;

            if (componentNames.length > 0) {
              warningWithoutStack$1(false, "%s triggered a user-blocking update that suspended." + "\n\n" + "The fix is to split the update into multiple parts: a user-blocking " + "update to provide immediate feedback, and another update that " + "triggers the bulk of the changes." + "\n\n" + "Refer to the documentation for useSuspenseTransition to learn how " + "to implement this pattern.", componentNames.sort().join(", "));
            }
          }
        }
      }

      function computeThreadID(root, expirationTime) {
        return expirationTime * 1000 + root.interactionThreadID;
      }

      function markSpawnedWork(expirationTime) {
        if (!enableSchedulerTracing) {
          return;
        }

        if (spawnedWorkDuringRender === null) {
          spawnedWorkDuringRender = [expirationTime];
        } else {
          spawnedWorkDuringRender.push(expirationTime);
        }
      }

      function scheduleInteractions(root, expirationTime, interactions) {
        if (!enableSchedulerTracing) {
          return;
        }

        if (interactions.size > 0) {
          var pendingInteractionMap = root.pendingInteractionMap;
          var pendingInteractions = pendingInteractionMap.get(expirationTime);

          if (pendingInteractions != null) {
            interactions.forEach(function (interaction) {
              if (!pendingInteractions.has(interaction)) {
                interaction.__count++;
              }

              pendingInteractions.add(interaction);
            });
          } else {
            pendingInteractionMap.set(expirationTime, new Set(interactions));
            interactions.forEach(function (interaction) {
              interaction.__count++;
            });
          }

          var subscriber = tracing.__subscriberRef.current;

          if (subscriber !== null) {
            var threadID = computeThreadID(root, expirationTime);
            subscriber.onWorkScheduled(interactions, threadID);
          }
        }
      }

      function schedulePendingInteractions(root, expirationTime) {
        if (!enableSchedulerTracing) {
          return;
        }

        scheduleInteractions(root, expirationTime, tracing.__interactionsRef.current);
      }

      function startWorkOnPendingInteractions(root, expirationTime) {
        if (!enableSchedulerTracing) {
          return;
        }

        var interactions = new Set();
        root.pendingInteractionMap.forEach(function (scheduledInteractions, scheduledExpirationTime) {
          if (scheduledExpirationTime >= expirationTime) {
            scheduledInteractions.forEach(function (interaction) {
              return interactions.add(interaction);
            });
          }
        });
        root.memoizedInteractions = interactions;

        if (interactions.size > 0) {
          var subscriber = tracing.__subscriberRef.current;

          if (subscriber !== null) {
            var threadID = computeThreadID(root, expirationTime);

            try {
              subscriber.onWorkStarted(interactions, threadID);
            } catch (error) {
              scheduleCallback(ImmediatePriority, function () {
                throw error;
              });
            }
          }
        }
      }

      function finishPendingInteractions(root, committedExpirationTime) {
        if (!enableSchedulerTracing) {
          return;
        }

        var earliestRemainingTimeAfterCommit = root.firstPendingTime;
        var subscriber = void 0;

        try {
          subscriber = tracing.__subscriberRef.current;

          if (subscriber !== null && root.memoizedInteractions.size > 0) {
            var threadID = computeThreadID(root, committedExpirationTime);
            subscriber.onWorkStopped(root.memoizedInteractions, threadID);
          }
        } catch (error) {
          scheduleCallback(ImmediatePriority, function () {
            throw error;
          });
        } finally {
          var pendingInteractionMap = root.pendingInteractionMap;
          pendingInteractionMap.forEach(function (scheduledInteractions, scheduledExpirationTime) {
            if (scheduledExpirationTime > earliestRemainingTimeAfterCommit) {
              pendingInteractionMap.delete(scheduledExpirationTime);
              scheduledInteractions.forEach(function (interaction) {
                interaction.__count--;

                if (subscriber !== null && interaction.__count === 0) {
                  try {
                    subscriber.onInteractionScheduledWorkCompleted(interaction);
                  } catch (error) {
                    scheduleCallback(ImmediatePriority, function () {
                      throw error;
                    });
                  }
                }
              });
            }
          });
        }
      }

      var onCommitFiberRoot = null;
      var onCommitFiberUnmount = null;
      var hasLoggedError = false;
      var isDevToolsPresent = typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined";

      function injectInternals(internals) {
        if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ === "undefined") {
          return false;
        }

        var hook = __REACT_DEVTOOLS_GLOBAL_HOOK__;

        if (hook.isDisabled) {
          return true;
        }

        if (!hook.supportsFiber) {
          {
            warningWithoutStack$1(false, "The installed version of React DevTools is too old and will not work " + "with the current version of React. Please update React DevTools. " + "https://fb.me/react-devtools");
          }
          return true;
        }

        try {
          var rendererID = hook.inject(internals);

          onCommitFiberRoot = function onCommitFiberRoot(root, expirationTime) {
            try {
              var didError = (root.current.effectTag & DidCapture) === DidCapture;

              if (enableProfilerTimer) {
                var currentTime = requestCurrentTime();
                var priorityLevel = inferPriorityFromExpirationTime(currentTime, expirationTime);
                hook.onCommitFiberRoot(rendererID, root, priorityLevel, didError);
              } else {
                hook.onCommitFiberRoot(rendererID, root, undefined, didError);
              }
            } catch (err) {
              if (true && !hasLoggedError) {
                hasLoggedError = true;
                warningWithoutStack$1(false, "React DevTools encountered an error: %s", err);
              }
            }
          };

          onCommitFiberUnmount = function onCommitFiberUnmount(fiber) {
            try {
              hook.onCommitFiberUnmount(rendererID, fiber);
            } catch (err) {
              if (true && !hasLoggedError) {
                hasLoggedError = true;
                warningWithoutStack$1(false, "React DevTools encountered an error: %s", err);
              }
            }
          };
        } catch (err) {
          {
            warningWithoutStack$1(false, "React DevTools encountered an error: %s.", err);
          }
        }

        return true;
      }

      function onCommitRoot(root, expirationTime) {
        if (typeof onCommitFiberRoot === "function") {
          onCommitFiberRoot(root, expirationTime);
        }
      }

      function onCommitUnmount(fiber) {
        if (typeof onCommitFiberUnmount === "function") {
          onCommitFiberUnmount(fiber);
        }
      }

      var hasBadMapPolyfill = void 0;
      {
        hasBadMapPolyfill = false;

        try {
          var nonExtensibleObject = Object.preventExtensions({});
          var testMap = new Map([[nonExtensibleObject, null]]);
          var testSet = new Set([nonExtensibleObject]);
          testMap.set(0, 0);
          testSet.add(0);
        } catch (e) {
          hasBadMapPolyfill = true;
        }
      }
      var debugCounter = void 0;
      {
        debugCounter = 1;
      }

      function FiberNode(tag, pendingProps, key, mode) {
        this.tag = tag;
        this.key = key;
        this.elementType = null;
        this.type = null;
        this.stateNode = null;
        this.return = null;
        this.child = null;
        this.sibling = null;
        this.index = 0;
        this.ref = null;
        this.pendingProps = pendingProps;
        this.memoizedProps = null;
        this.updateQueue = null;
        this.memoizedState = null;
        this.dependencies = null;
        this.mode = mode;
        this.effectTag = NoEffect;
        this.nextEffect = null;
        this.firstEffect = null;
        this.lastEffect = null;
        this.expirationTime = NoWork;
        this.childExpirationTime = NoWork;
        this.alternate = null;

        if (enableProfilerTimer) {
          this.actualDuration = Number.NaN;
          this.actualStartTime = Number.NaN;
          this.selfBaseDuration = Number.NaN;
          this.treeBaseDuration = Number.NaN;
          this.actualDuration = 0;
          this.actualStartTime = -1;
          this.selfBaseDuration = 0;
          this.treeBaseDuration = 0;
        }

        {
          this._debugID = debugCounter++;
          this._debugSource = null;
          this._debugOwner = null;
          this._debugIsCurrentlyTiming = false;
          this._debugNeedsRemount = false;
          this._debugHookTypes = null;

          if (!hasBadMapPolyfill && typeof Object.preventExtensions === "function") {
            Object.preventExtensions(this);
          }
        }
      }

      var createFiber = function createFiber(tag, pendingProps, key, mode) {
        return new FiberNode(tag, pendingProps, key, mode);
      };

      function shouldConstruct(Component) {
        var prototype = Component.prototype;
        return !!(prototype && prototype.isReactComponent);
      }

      function isSimpleFunctionComponent(type) {
        return typeof type === "function" && !shouldConstruct(type) && type.defaultProps === undefined;
      }

      function resolveLazyComponentTag(Component) {
        if (typeof Component === "function") {
          return shouldConstruct(Component) ? ClassComponent : FunctionComponent;
        } else if (Component !== undefined && Component !== null) {
          var $$typeof = Component.$$typeof;

          if ($$typeof === REACT_FORWARD_REF_TYPE) {
            return ForwardRef;
          }

          if ($$typeof === REACT_MEMO_TYPE) {
            return MemoComponent;
          }
        }

        return IndeterminateComponent;
      }

      function createWorkInProgress(current, pendingProps, expirationTime) {
        var workInProgress = current.alternate;

        if (workInProgress === null) {
          workInProgress = createFiber(current.tag, pendingProps, current.key, current.mode);
          workInProgress.elementType = current.elementType;
          workInProgress.type = current.type;
          workInProgress.stateNode = current.stateNode;
          {
            workInProgress._debugID = current._debugID;
            workInProgress._debugSource = current._debugSource;
            workInProgress._debugOwner = current._debugOwner;
            workInProgress._debugHookTypes = current._debugHookTypes;
          }
          workInProgress.alternate = current;
          current.alternate = workInProgress;
        } else {
          workInProgress.pendingProps = pendingProps;
          workInProgress.effectTag = NoEffect;
          workInProgress.nextEffect = null;
          workInProgress.firstEffect = null;
          workInProgress.lastEffect = null;

          if (enableProfilerTimer) {
            workInProgress.actualDuration = 0;
            workInProgress.actualStartTime = -1;
          }
        }

        workInProgress.childExpirationTime = current.childExpirationTime;
        workInProgress.expirationTime = current.expirationTime;
        workInProgress.child = current.child;
        workInProgress.memoizedProps = current.memoizedProps;
        workInProgress.memoizedState = current.memoizedState;
        workInProgress.updateQueue = current.updateQueue;
        var currentDependencies = current.dependencies;
        workInProgress.dependencies = currentDependencies === null ? null : {
          expirationTime: currentDependencies.expirationTime,
          firstContext: currentDependencies.firstContext,
          responders: currentDependencies.responders
        };
        workInProgress.sibling = current.sibling;
        workInProgress.index = current.index;
        workInProgress.ref = current.ref;

        if (enableProfilerTimer) {
          workInProgress.selfBaseDuration = current.selfBaseDuration;
          workInProgress.treeBaseDuration = current.treeBaseDuration;
        }

        {
          workInProgress._debugNeedsRemount = current._debugNeedsRemount;

          switch (workInProgress.tag) {
            case IndeterminateComponent:
            case FunctionComponent:
            case SimpleMemoComponent:
              workInProgress.type = resolveFunctionForHotReloading(current.type);
              break;

            case ClassComponent:
              workInProgress.type = resolveClassForHotReloading(current.type);
              break;

            case ForwardRef:
              workInProgress.type = resolveForwardRefForHotReloading(current.type);
              break;

            default:
              break;
          }
        }
        return workInProgress;
      }

      function resetWorkInProgress(workInProgress, renderExpirationTime) {
        workInProgress.effectTag &= Placement;
        workInProgress.nextEffect = null;
        workInProgress.firstEffect = null;
        workInProgress.lastEffect = null;
        var current = workInProgress.alternate;

        if (current === null) {
          workInProgress.childExpirationTime = NoWork;
          workInProgress.expirationTime = renderExpirationTime;
          workInProgress.child = null;
          workInProgress.memoizedProps = null;
          workInProgress.memoizedState = null;
          workInProgress.updateQueue = null;
          workInProgress.dependencies = null;

          if (enableProfilerTimer) {
            workInProgress.selfBaseDuration = 0;
            workInProgress.treeBaseDuration = 0;
          }
        } else {
          workInProgress.childExpirationTime = current.childExpirationTime;
          workInProgress.expirationTime = current.expirationTime;
          workInProgress.child = current.child;
          workInProgress.memoizedProps = current.memoizedProps;
          workInProgress.memoizedState = current.memoizedState;
          workInProgress.updateQueue = current.updateQueue;
          var currentDependencies = current.dependencies;
          workInProgress.dependencies = currentDependencies === null ? null : {
            expirationTime: currentDependencies.expirationTime,
            firstContext: currentDependencies.firstContext,
            responders: currentDependencies.responders
          };

          if (enableProfilerTimer) {
            workInProgress.selfBaseDuration = current.selfBaseDuration;
            workInProgress.treeBaseDuration = current.treeBaseDuration;
          }
        }

        return workInProgress;
      }

      function createHostRootFiber(tag) {
        var mode = void 0;

        if (tag === ConcurrentRoot) {
          mode = ConcurrentMode | BatchedMode | StrictMode;
        } else if (tag === BatchedRoot) {
          mode = BatchedMode | StrictMode;
        } else {
          mode = NoMode;
        }

        if (enableProfilerTimer && isDevToolsPresent) {
          mode |= ProfileMode;
        }

        return createFiber(HostRoot, null, null, mode);
      }

      function createFiberFromTypeAndProps(type, key, pendingProps, owner, mode, expirationTime) {
        var fiber = void 0;
        var fiberTag = IndeterminateComponent;
        var resolvedType = type;

        if (typeof type === "function") {
          if (shouldConstruct(type)) {
            fiberTag = ClassComponent;
            {
              resolvedType = resolveClassForHotReloading(resolvedType);
            }
          } else {
            {
              resolvedType = resolveFunctionForHotReloading(resolvedType);
            }
          }
        } else if (typeof type === "string") {
          fiberTag = HostComponent;
        } else {
          getTag: switch (type) {
            case REACT_FRAGMENT_TYPE:
              return createFiberFromFragment(pendingProps.children, mode, expirationTime, key);

            case REACT_CONCURRENT_MODE_TYPE:
              fiberTag = Mode;
              mode |= ConcurrentMode | BatchedMode | StrictMode;
              break;

            case REACT_STRICT_MODE_TYPE:
              fiberTag = Mode;
              mode |= StrictMode;
              break;

            case REACT_PROFILER_TYPE:
              return createFiberFromProfiler(pendingProps, mode, expirationTime, key);

            case REACT_SUSPENSE_TYPE:
              return createFiberFromSuspense(pendingProps, mode, expirationTime, key);

            case REACT_SUSPENSE_LIST_TYPE:
              return createFiberFromSuspenseList(pendingProps, mode, expirationTime, key);

            default:
              {
                if (typeof type === "object" && type !== null) {
                  switch (type.$$typeof) {
                    case REACT_PROVIDER_TYPE:
                      fiberTag = ContextProvider;
                      break getTag;

                    case REACT_CONTEXT_TYPE:
                      fiberTag = ContextConsumer;
                      break getTag;

                    case REACT_FORWARD_REF_TYPE:
                      fiberTag = ForwardRef;
                      {
                        resolvedType = resolveForwardRefForHotReloading(resolvedType);
                      }
                      break getTag;

                    case REACT_MEMO_TYPE:
                      fiberTag = MemoComponent;
                      break getTag;

                    case REACT_LAZY_TYPE:
                      fiberTag = LazyComponent;
                      resolvedType = null;
                      break getTag;

                    case REACT_FUNDAMENTAL_TYPE:
                      if (enableFundamentalAPI) {
                        return createFiberFromFundamental(type, pendingProps, mode, expirationTime, key);
                      }

                      break;
                  }
                }

                var info = "";
                {
                  if (type === undefined || typeof type === "object" && type !== null && Object.keys(type).length === 0) {
                    info += " You likely forgot to export your component from the file " + "it's defined in, or you might have mixed up default and " + "named imports.";
                  }

                  var ownerName = owner ? getComponentName(owner.type) : null;

                  if (ownerName) {
                    info += "\n\nCheck the render method of `" + ownerName + "`.";
                  }
                }

                (function () {
                  {
                    throw ReactError(Error("Element type is invalid: expected a string (for built-in components) or a class/function (for composite components) but got: " + (type == null ? type : typeof type) + "." + info));
                  }
                })();
              }
          }
        }

        fiber = createFiber(fiberTag, pendingProps, key, mode);
        fiber.elementType = type;
        fiber.type = resolvedType;
        fiber.expirationTime = expirationTime;
        return fiber;
      }

      function createFiberFromElement(element, mode, expirationTime) {
        var owner = null;
        {
          owner = element._owner;
        }
        var type = element.type;
        var key = element.key;
        var pendingProps = element.props;
        var fiber = createFiberFromTypeAndProps(type, key, pendingProps, owner, mode, expirationTime);
        {
          fiber._debugSource = element._source;
          fiber._debugOwner = element._owner;
        }
        return fiber;
      }

      function createFiberFromFragment(elements, mode, expirationTime, key) {
        var fiber = createFiber(Fragment, elements, key, mode);
        fiber.expirationTime = expirationTime;
        return fiber;
      }

      function createFiberFromFundamental(fundamentalComponent, pendingProps, mode, expirationTime, key) {
        var fiber = createFiber(FundamentalComponent, pendingProps, key, mode);
        fiber.elementType = fundamentalComponent;
        fiber.type = fundamentalComponent;
        fiber.expirationTime = expirationTime;
        return fiber;
      }

      function createFiberFromProfiler(pendingProps, mode, expirationTime, key) {
        {
          if (typeof pendingProps.id !== "string" || typeof pendingProps.onRender !== "function") {
            warningWithoutStack$1(false, 'Profiler must specify an "id" string and "onRender" function as props');
          }
        }
        var fiber = createFiber(Profiler, pendingProps, key, mode | ProfileMode);
        fiber.elementType = REACT_PROFILER_TYPE;
        fiber.type = REACT_PROFILER_TYPE;
        fiber.expirationTime = expirationTime;
        return fiber;
      }

      function createFiberFromSuspense(pendingProps, mode, expirationTime, key) {
        var fiber = createFiber(SuspenseComponent, pendingProps, key, mode);
        fiber.type = REACT_SUSPENSE_TYPE;
        fiber.elementType = REACT_SUSPENSE_TYPE;
        fiber.expirationTime = expirationTime;
        return fiber;
      }

      function createFiberFromSuspenseList(pendingProps, mode, expirationTime, key) {
        var fiber = createFiber(SuspenseListComponent, pendingProps, key, mode);
        {
          fiber.type = REACT_SUSPENSE_LIST_TYPE;
        }
        fiber.elementType = REACT_SUSPENSE_LIST_TYPE;
        fiber.expirationTime = expirationTime;
        return fiber;
      }

      function createFiberFromText(content, mode, expirationTime) {
        var fiber = createFiber(HostText, content, null, mode);
        fiber.expirationTime = expirationTime;
        return fiber;
      }

      function createFiberFromHostInstanceForDeletion() {
        var fiber = createFiber(HostComponent, null, null, NoMode);
        fiber.elementType = "DELETED";
        fiber.type = "DELETED";
        return fiber;
      }

      function createFiberFromPortal(portal, mode, expirationTime) {
        var pendingProps = portal.children !== null ? portal.children : [];
        var fiber = createFiber(HostPortal, pendingProps, portal.key, mode);
        fiber.expirationTime = expirationTime;
        fiber.stateNode = {
          containerInfo: portal.containerInfo,
          pendingChildren: null,
          implementation: portal.implementation
        };
        return fiber;
      }

      function assignFiberPropertiesInDEV(target, source) {
        if (target === null) {
          target = createFiber(IndeterminateComponent, null, null, NoMode);
        }

        target.tag = source.tag;
        target.key = source.key;
        target.elementType = source.elementType;
        target.type = source.type;
        target.stateNode = source.stateNode;
        target.return = source.return;
        target.child = source.child;
        target.sibling = source.sibling;
        target.index = source.index;
        target.ref = source.ref;
        target.pendingProps = source.pendingProps;
        target.memoizedProps = source.memoizedProps;
        target.updateQueue = source.updateQueue;
        target.memoizedState = source.memoizedState;
        target.dependencies = source.dependencies;
        target.mode = source.mode;
        target.effectTag = source.effectTag;
        target.nextEffect = source.nextEffect;
        target.firstEffect = source.firstEffect;
        target.lastEffect = source.lastEffect;
        target.expirationTime = source.expirationTime;
        target.childExpirationTime = source.childExpirationTime;
        target.alternate = source.alternate;

        if (enableProfilerTimer) {
          target.actualDuration = source.actualDuration;
          target.actualStartTime = source.actualStartTime;
          target.selfBaseDuration = source.selfBaseDuration;
          target.treeBaseDuration = source.treeBaseDuration;
        }

        target._debugID = source._debugID;
        target._debugSource = source._debugSource;
        target._debugOwner = source._debugOwner;
        target._debugIsCurrentlyTiming = source._debugIsCurrentlyTiming;
        target._debugNeedsRemount = source._debugNeedsRemount;
        target._debugHookTypes = source._debugHookTypes;
        return target;
      }

      function FiberRootNode(containerInfo, tag, hydrate) {
        this.tag = tag;
        this.current = null;
        this.containerInfo = containerInfo;
        this.pendingChildren = null;
        this.pingCache = null;
        this.finishedExpirationTime = NoWork;
        this.finishedWork = null;
        this.timeoutHandle = noTimeout;
        this.context = null;
        this.pendingContext = null;
        this.hydrate = hydrate;
        this.firstBatch = null;
        this.callbackNode = null;
        this.callbackExpirationTime = NoWork;
        this.firstPendingTime = NoWork;
        this.lastPendingTime = NoWork;
        this.pingTime = NoWork;

        if (enableSchedulerTracing) {
          this.interactionThreadID = tracing.unstable_getThreadID();
          this.memoizedInteractions = new Set();
          this.pendingInteractionMap = new Map();
        }
      }

      function createFiberRoot(containerInfo, tag, hydrate) {
        var root = new FiberRootNode(containerInfo, tag, hydrate);
        var uninitializedFiber = createHostRootFiber(tag);
        root.current = uninitializedFiber;
        uninitializedFiber.stateNode = root;
        return root;
      }

      var ReactFiberInstrumentation = {
        debugTool: null
      };
      var ReactFiberInstrumentation_1 = ReactFiberInstrumentation;
      var didWarnAboutNestedUpdates = void 0;
      var didWarnAboutFindNodeInStrictMode = void 0;
      {
        didWarnAboutNestedUpdates = false;
        didWarnAboutFindNodeInStrictMode = {};
      }

      function getContextForSubtree(parentComponent) {
        if (!parentComponent) {
          return emptyContextObject;
        }

        var fiber = get(parentComponent);
        var parentContext = findCurrentUnmaskedContext(fiber);

        if (fiber.tag === ClassComponent) {
          var Component = fiber.type;

          if (isContextProvider(Component)) {
            return processChildContext(fiber, Component, parentContext);
          }
        }

        return parentContext;
      }

      function scheduleRootUpdate(current$$1, element, expirationTime, suspenseConfig, callback) {
        {
          if (phase === "render" && current !== null && !didWarnAboutNestedUpdates) {
            didWarnAboutNestedUpdates = true;
            warningWithoutStack$1(false, "Render methods should be a pure function of props and state; " + "triggering nested component updates from render is not allowed. " + "If necessary, trigger nested updates in componentDidUpdate.\n\n" + "Check the render method of %s.", getComponentName(current.type) || "Unknown");
          }
        }
        var update = createUpdate(expirationTime, suspenseConfig);
        update.payload = {
          element: element
        };
        callback = callback === undefined ? null : callback;

        if (callback !== null) {
          !(typeof callback === "function") ? warningWithoutStack$1(false, "render(...): Expected the last optional `callback` argument to be a " + "function. Instead received: %s.", callback) : void 0;
          update.callback = callback;
        }

        if (revertPassiveEffectsChange) {
          flushPassiveEffects();
        }

        enqueueUpdate(current$$1, update);
        scheduleWork(current$$1, expirationTime);
        return expirationTime;
      }

      function updateContainerAtExpirationTime(element, container, parentComponent, expirationTime, suspenseConfig, callback) {
        var current$$1 = container.current;
        {
          if (ReactFiberInstrumentation_1.debugTool) {
            if (current$$1.alternate === null) {
              ReactFiberInstrumentation_1.debugTool.onMountContainer(container);
            } else if (element === null) {
              ReactFiberInstrumentation_1.debugTool.onUnmountContainer(container);
            } else {
              ReactFiberInstrumentation_1.debugTool.onUpdateContainer(container);
            }
          }
        }
        var context = getContextForSubtree(parentComponent);

        if (container.context === null) {
          container.context = context;
        } else {
          container.pendingContext = context;
        }

        return scheduleRootUpdate(current$$1, element, expirationTime, suspenseConfig, callback);
      }

      function findHostInstance(component) {
        var fiber = get(component);

        if (fiber === undefined) {
          if (typeof component.render === "function") {
            (function () {
              {
                throw ReactError(Error("Unable to find node on an unmounted component."));
              }
            })();
          } else {
            (function () {
              {
                throw ReactError(Error("Argument appears to not be a ReactComponent. Keys: " + Object.keys(component)));
              }
            })();
          }
        }

        var hostFiber = findCurrentHostFiber(fiber);

        if (hostFiber === null) {
          return null;
        }

        return hostFiber.stateNode;
      }

      function findHostInstanceWithWarning(component, methodName) {
        {
          var fiber = get(component);

          if (fiber === undefined) {
            if (typeof component.render === "function") {
              (function () {
                {
                  throw ReactError(Error("Unable to find node on an unmounted component."));
                }
              })();
            } else {
              (function () {
                {
                  throw ReactError(Error("Argument appears to not be a ReactComponent. Keys: " + Object.keys(component)));
                }
              })();
            }
          }

          var hostFiber = findCurrentHostFiber(fiber);

          if (hostFiber === null) {
            return null;
          }

          if (hostFiber.mode & StrictMode) {
            var componentName = getComponentName(fiber.type) || "Component";

            if (!didWarnAboutFindNodeInStrictMode[componentName]) {
              didWarnAboutFindNodeInStrictMode[componentName] = true;

              if (fiber.mode & StrictMode) {
                warningWithoutStack$1(false, "%s is deprecated in StrictMode. " + "%s was passed an instance of %s which is inside StrictMode. " + "Instead, add a ref directly to the element you want to reference." + "\n%s" + "\n\nLearn more about using refs safely here:" + "\nhttps://fb.me/react-strict-mode-find-node", methodName, methodName, componentName, getStackByFiberInDevAndProd(hostFiber));
              } else {
                warningWithoutStack$1(false, "%s is deprecated in StrictMode. " + "%s was passed an instance of %s which renders StrictMode children. " + "Instead, add a ref directly to the element you want to reference." + "\n%s" + "\n\nLearn more about using refs safely here:" + "\nhttps://fb.me/react-strict-mode-find-node", methodName, methodName, componentName, getStackByFiberInDevAndProd(hostFiber));
              }
            }
          }

          return hostFiber.stateNode;
        }
        return findHostInstance(component);
      }

      function createContainer(containerInfo, tag, hydrate) {
        return createFiberRoot(containerInfo, tag, hydrate);
      }

      function updateContainer(element, container, parentComponent, callback) {
        var current$$1 = container.current;
        var currentTime = requestCurrentTime();
        {
          if ("undefined" !== typeof jest) {
            warnIfUnmockedScheduler(current$$1);
            warnIfNotScopedWithMatchingAct(current$$1);
          }
        }
        var suspenseConfig = requestCurrentSuspenseConfig();
        var expirationTime = computeExpirationForFiber(currentTime, current$$1, suspenseConfig);
        return updateContainerAtExpirationTime(element, container, parentComponent, expirationTime, suspenseConfig, callback);
      }

      function getPublicRootInstance(container) {
        var containerFiber = container.current;

        if (!containerFiber.child) {
          return null;
        }

        switch (containerFiber.child.tag) {
          case HostComponent:
            return getPublicInstance(containerFiber.child.stateNode);

          default:
            return containerFiber.child.stateNode;
        }
      }

      var shouldSuspendImpl = function shouldSuspendImpl(fiber) {
        return false;
      };

      function shouldSuspend(fiber) {
        return shouldSuspendImpl(fiber);
      }

      var overrideHookState = null;
      var overrideProps = null;
      var scheduleUpdate = null;
      var setSuspenseHandler = null;
      {
        var copyWithSetImpl = function copyWithSetImpl(obj, path, idx, value) {
          if (idx >= path.length) {
            return value;
          }

          var key = path[idx];
          var updated = Array.isArray(obj) ? obj.slice() : _extends({}, obj);
          updated[key] = copyWithSetImpl(obj[key], path, idx + 1, value);
          return updated;
        };

        var copyWithSet = function copyWithSet(obj, path, value) {
          return copyWithSetImpl(obj, path, 0, value);
        };

        overrideHookState = function overrideHookState(fiber, id, path, value) {
          var currentHook = fiber.memoizedState;

          while (currentHook !== null && id > 0) {
            currentHook = currentHook.next;
            id--;
          }

          if (currentHook !== null) {
            if (revertPassiveEffectsChange) {
              flushPassiveEffects();
            }

            var newState = copyWithSet(currentHook.memoizedState, path, value);
            currentHook.memoizedState = newState;
            currentHook.baseState = newState;
            fiber.memoizedProps = _extends({}, fiber.memoizedProps);
            scheduleWork(fiber, Sync);
          }
        };

        overrideProps = function overrideProps(fiber, path, value) {
          if (revertPassiveEffectsChange) {
            flushPassiveEffects();
          }

          fiber.pendingProps = copyWithSet(fiber.memoizedProps, path, value);

          if (fiber.alternate) {
            fiber.alternate.pendingProps = fiber.pendingProps;
          }

          scheduleWork(fiber, Sync);
        };

        scheduleUpdate = function scheduleUpdate(fiber) {
          if (revertPassiveEffectsChange) {
            flushPassiveEffects();
          }

          scheduleWork(fiber, Sync);
        };

        setSuspenseHandler = function setSuspenseHandler(newShouldSuspendImpl) {
          shouldSuspendImpl = newShouldSuspendImpl;
        };
      }

      function injectIntoDevTools(devToolsConfig) {
        var _findFiberByHostInstance = devToolsConfig.findFiberByHostInstance;
        var ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
        return injectInternals(_extends({}, devToolsConfig, {
          overrideHookState: overrideHookState,
          overrideProps: overrideProps,
          setSuspenseHandler: setSuspenseHandler,
          scheduleUpdate: scheduleUpdate,
          currentDispatcherRef: ReactCurrentDispatcher,
          findHostInstanceByFiber: function findHostInstanceByFiber(fiber) {
            var hostFiber = findCurrentHostFiber(fiber);

            if (hostFiber === null) {
              return null;
            }

            return hostFiber.stateNode;
          },
          findFiberByHostInstance: function findFiberByHostInstance(instance) {
            if (!_findFiberByHostInstance) {
              return null;
            }

            return _findFiberByHostInstance(instance);
          },
          findHostInstancesForRefresh: findHostInstancesForRefresh,
          scheduleRefresh: scheduleRefresh,
          scheduleRoot: scheduleRoot,
          setRefreshHandler: setRefreshHandler,
          getCurrentFiber: function getCurrentFiber() {
            return current;
          }
        }));
      }

      function _createPortal(children, containerInfo, implementation) {
        var key = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
        return {
          $$typeof: REACT_PORTAL_TYPE,
          key: key == null ? null : "" + key,
          children: children,
          containerInfo: containerInfo,
          implementation: implementation
        };
      }

      var ReactVersion = "16.8.6";

      var NativeMethodsMixin = function NativeMethodsMixin(findNodeHandle, findHostInstance) {
        var NativeMethodsMixin = {
          measure: function measure(callback) {
            var maybeInstance = void 0;

            try {
              maybeInstance = findHostInstance(this);
            } catch (error) {}

            if (maybeInstance == null) {
              return;
            }

            if (maybeInstance.canonical) {
              nativeFabricUIManager.measure(maybeInstance.node, mountSafeCallback_NOT_REALLY_SAFE(this, callback));
            } else {
              ReactNativePrivateInterface.UIManager.measure(findNodeHandle(this), mountSafeCallback_NOT_REALLY_SAFE(this, callback));
            }
          },
          measureInWindow: function measureInWindow(callback) {
            var maybeInstance = void 0;

            try {
              maybeInstance = findHostInstance(this);
            } catch (error) {}

            if (maybeInstance == null) {
              return;
            }

            if (maybeInstance.canonical) {
              nativeFabricUIManager.measureInWindow(maybeInstance.node, mountSafeCallback_NOT_REALLY_SAFE(this, callback));
            } else {
              ReactNativePrivateInterface.UIManager.measureInWindow(findNodeHandle(this), mountSafeCallback_NOT_REALLY_SAFE(this, callback));
            }
          },
          measureLayout: function measureLayout(relativeToNativeNode, onSuccess, onFail) {
            var maybeInstance = void 0;

            try {
              maybeInstance = findHostInstance(this);
            } catch (error) {}

            if (maybeInstance == null) {
              return;
            }

            if (maybeInstance.canonical) {
              warningWithoutStack$1(false, "Warning: measureLayout on components using NativeMethodsMixin " + "or ReactNative.NativeComponent is not currently supported in Fabric. " + "measureLayout must be called on a native ref. Consider using forwardRef.");
              return;
            } else {
              var relativeNode = void 0;

              if (typeof relativeToNativeNode === "number") {
                relativeNode = relativeToNativeNode;
              } else if (relativeToNativeNode._nativeTag) {
                relativeNode = relativeToNativeNode._nativeTag;
              }

              if (relativeNode == null) {
                warningWithoutStack$1(false, "Warning: ref.measureLayout must be called with a node handle or a ref to a native component.");
                return;
              }

              ReactNativePrivateInterface.UIManager.measureLayout(findNodeHandle(this), relativeNode, mountSafeCallback_NOT_REALLY_SAFE(this, onFail), mountSafeCallback_NOT_REALLY_SAFE(this, onSuccess));
            }
          },
          setNativeProps: function setNativeProps(nativeProps) {
            var maybeInstance = void 0;

            try {
              maybeInstance = findHostInstance(this);
            } catch (error) {}

            if (maybeInstance == null) {
              return;
            }

            if (maybeInstance.canonical) {
              warningWithoutStack$1(false, "Warning: setNativeProps is not currently supported in Fabric");
              return;
            }

            {
              if (warnAboutDeprecatedSetNativeProps) {
                warningWithoutStack$1(false, "Warning: Calling ref.setNativeProps(nativeProps) " + "is deprecated and will be removed in a future release. " + "Use the setNativeProps export from the react-native package instead." + "\n\timport {setNativeProps} from 'react-native';\n\tsetNativeProps(ref, nativeProps);\n");
              }
            }
            var nativeTag = maybeInstance._nativeTag || maybeInstance.canonical._nativeTag;
            var viewConfig = maybeInstance.viewConfig || maybeInstance.canonical.viewConfig;
            {
              warnForStyleProps(nativeProps, viewConfig.validAttributes);
            }
            var updatePayload = create(nativeProps, viewConfig.validAttributes);

            if (updatePayload != null) {
              ReactNativePrivateInterface.UIManager.updateView(nativeTag, viewConfig.uiViewClassName, updatePayload);
            }
          },
          focus: function focus() {
            ReactNativePrivateInterface.TextInputState.focusTextInput(findNodeHandle(this));
          },
          blur: function blur() {
            ReactNativePrivateInterface.TextInputState.blurTextInput(findNodeHandle(this));
          }
        };
        {
          var NativeMethodsMixin_DEV = NativeMethodsMixin;

          (function () {
            if (!(!NativeMethodsMixin_DEV.componentWillMount && !NativeMethodsMixin_DEV.componentWillReceiveProps && !NativeMethodsMixin_DEV.UNSAFE_componentWillMount && !NativeMethodsMixin_DEV.UNSAFE_componentWillReceiveProps)) {
              throw ReactError(Error("Do not override existing functions."));
            }
          })();

          NativeMethodsMixin_DEV.componentWillMount = function () {
            throwOnStylesProp(this, this.props);
          };

          NativeMethodsMixin_DEV.componentWillReceiveProps = function (newProps) {
            throwOnStylesProp(this, newProps);
          };

          NativeMethodsMixin_DEV.UNSAFE_componentWillMount = function () {
            throwOnStylesProp(this, this.props);
          };

          NativeMethodsMixin_DEV.UNSAFE_componentWillReceiveProps = function (newProps) {
            throwOnStylesProp(this, newProps);
          };

          NativeMethodsMixin_DEV.componentWillMount.__suppressDeprecationWarning = true;
          NativeMethodsMixin_DEV.componentWillReceiveProps.__suppressDeprecationWarning = true;
        }
        return NativeMethodsMixin;
      };

      function _classCallCheck$2(instance, Constructor) {
        if (!(instance instanceof Constructor)) {
          throw new TypeError("Cannot call a class as a function");
        }
      }

      function _possibleConstructorReturn$1(self, call) {
        if (!self) {
          throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
        }

        return call && (typeof call === "object" || typeof call === "function") ? call : self;
      }

      function _inherits$1(subClass, superClass) {
        if (typeof superClass !== "function" && superClass !== null) {
          throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
        }

        subClass.prototype = Object.create(superClass && superClass.prototype, {
          constructor: {
            value: subClass,
            enumerable: false,
            writable: true,
            configurable: true
          }
        });
        if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
      }

      var ReactNativeComponent$1 = function ReactNativeComponent$1(findNodeHandle, findHostInstance) {
        var ReactNativeComponent = function (_React$Component) {
          _inherits$1(ReactNativeComponent, _React$Component);

          function ReactNativeComponent() {
            _classCallCheck$2(this, ReactNativeComponent);

            return _possibleConstructorReturn$1(this, _React$Component.apply(this, arguments));
          }

          ReactNativeComponent.prototype.blur = function blur() {
            ReactNativePrivateInterface.TextInputState.blurTextInput(findNodeHandle(this));
          };

          ReactNativeComponent.prototype.focus = function focus() {
            ReactNativePrivateInterface.TextInputState.focusTextInput(findNodeHandle(this));
          };

          ReactNativeComponent.prototype.measure = function measure(callback) {
            var maybeInstance = void 0;

            try {
              maybeInstance = findHostInstance(this);
            } catch (error) {}

            if (maybeInstance == null) {
              return;
            }

            if (maybeInstance.canonical) {
              nativeFabricUIManager.measure(maybeInstance.node, mountSafeCallback_NOT_REALLY_SAFE(this, callback));
            } else {
              ReactNativePrivateInterface.UIManager.measure(findNodeHandle(this), mountSafeCallback_NOT_REALLY_SAFE(this, callback));
            }
          };

          ReactNativeComponent.prototype.measureInWindow = function measureInWindow(callback) {
            var maybeInstance = void 0;

            try {
              maybeInstance = findHostInstance(this);
            } catch (error) {}

            if (maybeInstance == null) {
              return;
            }

            if (maybeInstance.canonical) {
              nativeFabricUIManager.measureInWindow(maybeInstance.node, mountSafeCallback_NOT_REALLY_SAFE(this, callback));
            } else {
              ReactNativePrivateInterface.UIManager.measureInWindow(findNodeHandle(this), mountSafeCallback_NOT_REALLY_SAFE(this, callback));
            }
          };

          ReactNativeComponent.prototype.measureLayout = function measureLayout(relativeToNativeNode, onSuccess, onFail) {
            var maybeInstance = void 0;

            try {
              maybeInstance = findHostInstance(this);
            } catch (error) {}

            if (maybeInstance == null) {
              return;
            }

            if (maybeInstance.canonical) {
              warningWithoutStack$1(false, "Warning: measureLayout on components using NativeMethodsMixin " + "or ReactNative.NativeComponent is not currently supported in Fabric. " + "measureLayout must be called on a native ref. Consider using forwardRef.");
              return;
            } else {
              var relativeNode = void 0;

              if (typeof relativeToNativeNode === "number") {
                relativeNode = relativeToNativeNode;
              } else if (relativeToNativeNode._nativeTag) {
                relativeNode = relativeToNativeNode._nativeTag;
              }

              if (relativeNode == null) {
                warningWithoutStack$1(false, "Warning: ref.measureLayout must be called with a node handle or a ref to a native component.");
                return;
              }

              ReactNativePrivateInterface.UIManager.measureLayout(findNodeHandle(this), relativeNode, mountSafeCallback_NOT_REALLY_SAFE(this, onFail), mountSafeCallback_NOT_REALLY_SAFE(this, onSuccess));
            }
          };

          ReactNativeComponent.prototype.setNativeProps = function setNativeProps(nativeProps) {
            var maybeInstance = void 0;

            try {
              maybeInstance = findHostInstance(this);
            } catch (error) {}

            if (maybeInstance == null) {
              return;
            }

            if (maybeInstance.canonical) {
              warningWithoutStack$1(false, "Warning: setNativeProps is not currently supported in Fabric");
              return;
            }

            {
              if (warnAboutDeprecatedSetNativeProps) {
                warningWithoutStack$1(false, "Warning: Calling ref.setNativeProps(nativeProps) " + "is deprecated and will be removed in a future release. " + "Use the setNativeProps export from the react-native package instead." + "\n\timport {setNativeProps} from 'react-native';\n\tsetNativeProps(ref, nativeProps);\n");
              }
            }
            var nativeTag = maybeInstance._nativeTag || maybeInstance.canonical._nativeTag;
            var viewConfig = maybeInstance.viewConfig || maybeInstance.canonical.viewConfig;
            var updatePayload = create(nativeProps, viewConfig.validAttributes);

            if (updatePayload != null) {
              ReactNativePrivateInterface.UIManager.updateView(nativeTag, viewConfig.uiViewClassName, updatePayload);
            }
          };

          return ReactNativeComponent;
        }(React.Component);

        return ReactNativeComponent;
      };

      var instanceCache = new Map();

      function getInstanceFromTag(tag) {
        return instanceCache.get(tag) || null;
      }

      var emptyObject$2 = {};
      {
        Object.freeze(emptyObject$2);
      }
      var getInspectorDataForViewTag = void 0;
      {
        var traverseOwnerTreeUp = function traverseOwnerTreeUp(hierarchy, instance) {
          if (instance) {
            hierarchy.unshift(instance);
            traverseOwnerTreeUp(hierarchy, instance._debugOwner);
          }
        };

        var getOwnerHierarchy = function getOwnerHierarchy(instance) {
          var hierarchy = [];
          traverseOwnerTreeUp(hierarchy, instance);
          return hierarchy;
        };

        var lastNonHostInstance = function lastNonHostInstance(hierarchy) {
          for (var i = hierarchy.length - 1; i > 1; i--) {
            var instance = hierarchy[i];

            if (instance.tag !== HostComponent) {
              return instance;
            }
          }

          return hierarchy[0];
        };

        var getHostProps = function getHostProps(fiber) {
          var host = findCurrentHostFiber(fiber);

          if (host) {
            return host.memoizedProps || emptyObject$2;
          }

          return emptyObject$2;
        };

        var getHostNode = function getHostNode(fiber, findNodeHandle) {
          var hostNode = void 0;

          while (fiber) {
            if (fiber.stateNode !== null && fiber.tag === HostComponent) {
              hostNode = findNodeHandle(fiber.stateNode);
            }

            if (hostNode) {
              return hostNode;
            }

            fiber = fiber.child;
          }

          return null;
        };

        var createHierarchy = function createHierarchy(fiberHierarchy) {
          return fiberHierarchy.map(function (fiber) {
            return {
              name: getComponentName(fiber.type),
              getInspectorData: function getInspectorData(findNodeHandle) {
                return {
                  measure: function measure(callback) {
                    return ReactNativePrivateInterface.UIManager.measure(getHostNode(fiber, findNodeHandle), callback);
                  },
                  props: getHostProps(fiber),
                  source: fiber._debugSource
                };
              }
            };
          });
        };

        getInspectorDataForViewTag = function getInspectorDataForViewTag(viewTag) {
          var closestInstance = getInstanceFromTag(viewTag);

          if (!closestInstance) {
            return {
              hierarchy: [],
              props: emptyObject$2,
              selection: null,
              source: null
            };
          }

          var fiber = findCurrentFiberUsingSlowPath(closestInstance);
          var fiberHierarchy = getOwnerHierarchy(fiber);
          var instance = lastNonHostInstance(fiberHierarchy);
          var hierarchy = createHierarchy(fiberHierarchy);
          var props = getHostProps(instance);
          var source = instance._debugSource;
          var selection = fiberHierarchy.indexOf(instance);
          return {
            hierarchy: hierarchy,
            props: props,
            selection: selection,
            source: source
          };
        };
      }
      var _nativeFabricUIManage = nativeFabricUIManager;
      var fabricDispatchCommand = _nativeFabricUIManage.dispatchCommand;
      var ReactCurrentOwner = ReactSharedInternals.ReactCurrentOwner;

      function findNodeHandle(componentOrHandle) {
        {
          var owner = ReactCurrentOwner.current;

          if (owner !== null && owner.stateNode !== null) {
            !owner.stateNode._warnedAboutRefsInRender ? warningWithoutStack$1(false, "%s is accessing findNodeHandle inside its render(). " + "render() should be a pure function of props and state. It should " + "never access something that requires stale data from the previous " + "render, such as refs. Move this logic to componentDidMount and " + "componentDidUpdate instead.", getComponentName(owner.type) || "A component") : void 0;
            owner.stateNode._warnedAboutRefsInRender = true;
          }
        }

        if (componentOrHandle == null) {
          return null;
        }

        if (typeof componentOrHandle === "number") {
          return componentOrHandle;
        }

        if (componentOrHandle._nativeTag) {
          return componentOrHandle._nativeTag;
        }

        if (componentOrHandle.canonical && componentOrHandle.canonical._nativeTag) {
          return componentOrHandle.canonical._nativeTag;
        }

        var hostInstance = void 0;
        {
          hostInstance = findHostInstanceWithWarning(componentOrHandle, "findNodeHandle");
        }

        if (hostInstance == null) {
          return hostInstance;
        }

        if (hostInstance.canonical) {
          return hostInstance.canonical._nativeTag;
        }

        return hostInstance._nativeTag;
      }

      setBatchingImplementation(batchedUpdates$1, discreteUpdates$1, flushDiscreteUpdates, batchedEventUpdates$1);
      var roots = new Map();
      var ReactFabric = {
        NativeComponent: ReactNativeComponent$1(findNodeHandle, findHostInstance),
        findNodeHandle: findNodeHandle,
        setNativeProps: function setNativeProps(handle, nativeProps) {
          warningWithoutStack$1(false, "Warning: setNativeProps is not currently supported in Fabric");
          return;
        },
        dispatchCommand: function dispatchCommand(handle, command, args) {
          var invalid = handle._nativeTag == null || handle._internalInstanceHandle == null;

          if (invalid) {
            !!invalid ? warningWithoutStack$1(false, "dispatchCommand was called with a ref that isn't a " + "native component. Use React.forwardRef to get access to the underlying native component") : void 0;
            return;
          }

          fabricDispatchCommand(handle._internalInstanceHandle.stateNode.node, command, args);
        },
        render: function render(element, containerTag, callback) {
          var root = roots.get(containerTag);

          if (!root) {
            root = createContainer(containerTag, LegacyRoot, false);
            roots.set(containerTag, root);
          }

          updateContainer(element, root, null, callback);
          return getPublicRootInstance(root);
        },
        unmountComponentAtNode: function unmountComponentAtNode(containerTag) {
          var root = roots.get(containerTag);

          if (root) {
            updateContainer(null, root, null, function () {
              roots.delete(containerTag);
            });
          }
        },
        createPortal: function createPortal(children, containerTag) {
          var key = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
          return _createPortal(children, containerTag, null, key);
        },
        __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED: {
          NativeMethodsMixin: NativeMethodsMixin(findNodeHandle, findHostInstance)
        }
      };
      injectIntoDevTools({
        findFiberByHostInstance: getInstanceFromInstance,
        getInspectorDataForViewTag: getInspectorDataForViewTag,
        bundleType: 1,
        version: ReactVersion,
        rendererPackageName: "react-native-renderer"
      });
      var ReactFabric$2 = Object.freeze({
        default: ReactFabric
      });
      var ReactFabric$3 = ReactFabric$2 && ReactFabric || ReactFabric$2;
      var fabric = ReactFabric$3.default || ReactFabric$3;
      module.exports = fabric;
    })();
  }
},418,[13,90,192,54,198,58,201],"node_modules/react-native/Libraries/Renderer/implementations/ReactFabric-dev.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  "use strict";

  var _extends = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/extends");

  _$$_REQUIRE(_dependencyMap[1], "react-native/Libraries/ReactPrivate/ReactNativePrivateInitializeCore");

  var ReactNativePrivateInterface = _$$_REQUIRE(_dependencyMap[2], "react-native/Libraries/ReactPrivate/ReactNativePrivateInterface"),
      React = _$$_REQUIRE(_dependencyMap[3], "react"),
      Scheduler = _$$_REQUIRE(_dependencyMap[4], "scheduler");

  function ReactError(error) {
    error.name = "Invariant Violation";
    return error;
  }

  var eventPluginOrder = null,
      namesToPlugins = {};

  function recomputePluginOrdering() {
    if (eventPluginOrder) for (var pluginName in namesToPlugins) {
      var pluginModule = namesToPlugins[pluginName],
          pluginIndex = eventPluginOrder.indexOf(pluginName);
      if (!(-1 < pluginIndex)) throw ReactError(Error("EventPluginRegistry: Cannot inject event plugins that do not exist in the plugin ordering, `" + pluginName + "`."));

      if (!plugins[pluginIndex]) {
        if (!pluginModule.extractEvents) throw ReactError(Error("EventPluginRegistry: Event plugins must implement an `extractEvents` method, but `" + pluginName + "` does not."));
        plugins[pluginIndex] = pluginModule;
        pluginIndex = pluginModule.eventTypes;

        for (var eventName in pluginIndex) {
          var JSCompiler_inline_result = void 0;
          var dispatchConfig = pluginIndex[eventName],
              pluginModule$jscomp$0 = pluginModule,
              eventName$jscomp$0 = eventName;
          if (eventNameDispatchConfigs.hasOwnProperty(eventName$jscomp$0)) throw ReactError(Error("EventPluginHub: More than one plugin attempted to publish the same event name, `" + eventName$jscomp$0 + "`."));
          eventNameDispatchConfigs[eventName$jscomp$0] = dispatchConfig;
          var phasedRegistrationNames = dispatchConfig.phasedRegistrationNames;

          if (phasedRegistrationNames) {
            for (JSCompiler_inline_result in phasedRegistrationNames) {
              phasedRegistrationNames.hasOwnProperty(JSCompiler_inline_result) && publishRegistrationName(phasedRegistrationNames[JSCompiler_inline_result], pluginModule$jscomp$0, eventName$jscomp$0);
            }

            JSCompiler_inline_result = !0;
          } else dispatchConfig.registrationName ? (publishRegistrationName(dispatchConfig.registrationName, pluginModule$jscomp$0, eventName$jscomp$0), JSCompiler_inline_result = !0) : JSCompiler_inline_result = !1;

          if (!JSCompiler_inline_result) throw ReactError(Error("EventPluginRegistry: Failed to publish event `" + eventName + "` for plugin `" + pluginName + "`."));
        }
      }
    }
  }

  function publishRegistrationName(registrationName, pluginModule) {
    if (registrationNameModules[registrationName]) throw ReactError(Error("EventPluginHub: More than one plugin attempted to publish the same registration name, `" + registrationName + "`."));
    registrationNameModules[registrationName] = pluginModule;
  }

  var plugins = [],
      eventNameDispatchConfigs = {},
      registrationNameModules = {};

  function invokeGuardedCallbackImpl(name, func, context, a, b, c, d, e, f) {
    var funcArgs = Array.prototype.slice.call(arguments, 3);

    try {
      func.apply(context, funcArgs);
    } catch (error) {
      this.onError(error);
    }
  }

  var hasError = !1,
      caughtError = null,
      hasRethrowError = !1,
      rethrowError = null,
      reporter = {
    onError: function onError(error) {
      hasError = !0;
      caughtError = error;
    }
  };

  function invokeGuardedCallback(name, func, context, a, b, c, d, e, f) {
    hasError = !1;
    caughtError = null;
    invokeGuardedCallbackImpl.apply(reporter, arguments);
  }

  function invokeGuardedCallbackAndCatchFirstError(name, func, context, a, b, c, d, e, f) {
    invokeGuardedCallback.apply(this, arguments);

    if (hasError) {
      if (hasError) {
        var error = caughtError;
        hasError = !1;
        caughtError = null;
      } else throw ReactError(Error("clearCaughtError was called but no error was captured. This error is likely caused by a bug in React. Please file an issue."));

      hasRethrowError || (hasRethrowError = !0, rethrowError = error);
    }
  }

  var getFiberCurrentPropsFromNode = null,
      getInstanceFromNode = null,
      getNodeFromInstance = null;

  function executeDispatch(event, listener, inst) {
    var type = event.type || "unknown-event";
    event.currentTarget = getNodeFromInstance(inst);
    invokeGuardedCallbackAndCatchFirstError(type, listener, void 0, event);
    event.currentTarget = null;
  }

  function executeDirectDispatch(event) {
    var dispatchListener = event._dispatchListeners,
        dispatchInstance = event._dispatchInstances;
    if (Array.isArray(dispatchListener)) throw ReactError(Error("executeDirectDispatch(...): Invalid `event`."));
    event.currentTarget = dispatchListener ? getNodeFromInstance(dispatchInstance) : null;
    dispatchListener = dispatchListener ? dispatchListener(event) : null;
    event.currentTarget = null;
    event._dispatchListeners = null;
    event._dispatchInstances = null;
    return dispatchListener;
  }

  function accumulateInto(current, next) {
    if (null == next) throw ReactError(Error("accumulateInto(...): Accumulated items must not be null or undefined."));
    if (null == current) return next;

    if (Array.isArray(current)) {
      if (Array.isArray(next)) return current.push.apply(current, next), current;
      current.push(next);
      return current;
    }

    return Array.isArray(next) ? [current].concat(next) : [current, next];
  }

  function forEachAccumulated(arr, cb, scope) {
    Array.isArray(arr) ? arr.forEach(cb, scope) : arr && cb.call(scope, arr);
  }

  var eventQueue = null;

  function executeDispatchesAndReleaseTopLevel(e) {
    if (e) {
      var dispatchListeners = e._dispatchListeners,
          dispatchInstances = e._dispatchInstances;
      if (Array.isArray(dispatchListeners)) for (var i = 0; i < dispatchListeners.length && !e.isPropagationStopped(); i++) {
        executeDispatch(e, dispatchListeners[i], dispatchInstances[i]);
      } else dispatchListeners && executeDispatch(e, dispatchListeners, dispatchInstances);
      e._dispatchListeners = null;
      e._dispatchInstances = null;
      e.isPersistent() || e.constructor.release(e);
    }
  }

  var injection = {
    injectEventPluginOrder: function injectEventPluginOrder(injectedEventPluginOrder) {
      if (eventPluginOrder) throw ReactError(Error("EventPluginRegistry: Cannot inject event plugin ordering more than once. You are likely trying to load more than one copy of React."));
      eventPluginOrder = Array.prototype.slice.call(injectedEventPluginOrder);
      recomputePluginOrdering();
    },
    injectEventPluginsByName: function injectEventPluginsByName(injectedNamesToPlugins) {
      var isOrderingDirty = !1,
          pluginName;

      for (pluginName in injectedNamesToPlugins) {
        if (injectedNamesToPlugins.hasOwnProperty(pluginName)) {
          var pluginModule = injectedNamesToPlugins[pluginName];

          if (!namesToPlugins.hasOwnProperty(pluginName) || namesToPlugins[pluginName] !== pluginModule) {
            if (namesToPlugins[pluginName]) throw ReactError(Error("EventPluginRegistry: Cannot inject two different event plugins using the same name, `" + pluginName + "`."));
            namesToPlugins[pluginName] = pluginModule;
            isOrderingDirty = !0;
          }
        }
      }

      isOrderingDirty && recomputePluginOrdering();
    }
  };

  function getListener(inst, registrationName) {
    var listener = inst.stateNode;
    if (!listener) return null;
    var props = getFiberCurrentPropsFromNode(listener);
    if (!props) return null;
    listener = props[registrationName];

    a: switch (registrationName) {
      case "onClick":
      case "onClickCapture":
      case "onDoubleClick":
      case "onDoubleClickCapture":
      case "onMouseDown":
      case "onMouseDownCapture":
      case "onMouseMove":
      case "onMouseMoveCapture":
      case "onMouseUp":
      case "onMouseUpCapture":
        (props = !props.disabled) || (inst = inst.type, props = !("button" === inst || "input" === inst || "select" === inst || "textarea" === inst));
        inst = !props;
        break a;

      default:
        inst = !1;
    }

    if (inst) return null;
    if (listener && "function" !== typeof listener) throw ReactError(Error("Expected `" + registrationName + "` listener to be a function, instead got a value of `" + typeof listener + "` type."));
    return listener;
  }

  function getParent(inst) {
    do {
      inst = inst.return;
    } while (inst && 5 !== inst.tag);

    return inst ? inst : null;
  }

  function traverseTwoPhase(inst, fn, arg) {
    for (var path = []; inst;) {
      path.push(inst), inst = getParent(inst);
    }

    for (inst = path.length; 0 < inst--;) {
      fn(path[inst], "captured", arg);
    }

    for (inst = 0; inst < path.length; inst++) {
      fn(path[inst], "bubbled", arg);
    }
  }

  function accumulateDirectionalDispatches(inst, phase, event) {
    if (phase = getListener(inst, event.dispatchConfig.phasedRegistrationNames[phase])) event._dispatchListeners = accumulateInto(event._dispatchListeners, phase), event._dispatchInstances = accumulateInto(event._dispatchInstances, inst);
  }

  function accumulateTwoPhaseDispatchesSingle(event) {
    event && event.dispatchConfig.phasedRegistrationNames && traverseTwoPhase(event._targetInst, accumulateDirectionalDispatches, event);
  }

  function accumulateTwoPhaseDispatchesSingleSkipTarget(event) {
    if (event && event.dispatchConfig.phasedRegistrationNames) {
      var targetInst = event._targetInst;
      targetInst = targetInst ? getParent(targetInst) : null;
      traverseTwoPhase(targetInst, accumulateDirectionalDispatches, event);
    }
  }

  function accumulateDirectDispatchesSingle(event) {
    if (event && event.dispatchConfig.registrationName) {
      var inst = event._targetInst;

      if (inst && event && event.dispatchConfig.registrationName) {
        var listener = getListener(inst, event.dispatchConfig.registrationName);
        listener && (event._dispatchListeners = accumulateInto(event._dispatchListeners, listener), event._dispatchInstances = accumulateInto(event._dispatchInstances, inst));
      }
    }
  }

  function functionThatReturnsTrue() {
    return !0;
  }

  function functionThatReturnsFalse() {
    return !1;
  }

  function SyntheticEvent(dispatchConfig, targetInst, nativeEvent, nativeEventTarget) {
    this.dispatchConfig = dispatchConfig;
    this._targetInst = targetInst;
    this.nativeEvent = nativeEvent;
    dispatchConfig = this.constructor.Interface;

    for (var propName in dispatchConfig) {
      dispatchConfig.hasOwnProperty(propName) && ((targetInst = dispatchConfig[propName]) ? this[propName] = targetInst(nativeEvent) : "target" === propName ? this.target = nativeEventTarget : this[propName] = nativeEvent[propName]);
    }

    this.isDefaultPrevented = (null != nativeEvent.defaultPrevented ? nativeEvent.defaultPrevented : !1 === nativeEvent.returnValue) ? functionThatReturnsTrue : functionThatReturnsFalse;
    this.isPropagationStopped = functionThatReturnsFalse;
    return this;
  }

  _extends(SyntheticEvent.prototype, {
    preventDefault: function preventDefault() {
      this.defaultPrevented = !0;
      var event = this.nativeEvent;
      event && (event.preventDefault ? event.preventDefault() : "unknown" !== typeof event.returnValue && (event.returnValue = !1), this.isDefaultPrevented = functionThatReturnsTrue);
    },
    stopPropagation: function stopPropagation() {
      var event = this.nativeEvent;
      event && (event.stopPropagation ? event.stopPropagation() : "unknown" !== typeof event.cancelBubble && (event.cancelBubble = !0), this.isPropagationStopped = functionThatReturnsTrue);
    },
    persist: function persist() {
      this.isPersistent = functionThatReturnsTrue;
    },
    isPersistent: functionThatReturnsFalse,
    destructor: function destructor() {
      var Interface = this.constructor.Interface,
          propName;

      for (propName in Interface) {
        this[propName] = null;
      }

      this.nativeEvent = this._targetInst = this.dispatchConfig = null;
      this.isPropagationStopped = this.isDefaultPrevented = functionThatReturnsFalse;
      this._dispatchInstances = this._dispatchListeners = null;
    }
  });

  SyntheticEvent.Interface = {
    type: null,
    target: null,
    currentTarget: function currentTarget() {
      return null;
    },
    eventPhase: null,
    bubbles: null,
    cancelable: null,
    timeStamp: function timeStamp(event) {
      return event.timeStamp || Date.now();
    },
    defaultPrevented: null,
    isTrusted: null
  };

  SyntheticEvent.extend = function (Interface) {
    function E() {}

    function Class() {
      return Super.apply(this, arguments);
    }

    var Super = this;
    E.prototype = Super.prototype;
    var prototype = new E();

    _extends(prototype, Class.prototype);

    Class.prototype = prototype;
    Class.prototype.constructor = Class;
    Class.Interface = _extends({}, Super.Interface, Interface);
    Class.extend = Super.extend;
    addEventPoolingTo(Class);
    return Class;
  };

  addEventPoolingTo(SyntheticEvent);

  function getPooledEvent(dispatchConfig, targetInst, nativeEvent, nativeInst) {
    if (this.eventPool.length) {
      var instance = this.eventPool.pop();
      this.call(instance, dispatchConfig, targetInst, nativeEvent, nativeInst);
      return instance;
    }

    return new this(dispatchConfig, targetInst, nativeEvent, nativeInst);
  }

  function releasePooledEvent(event) {
    if (!(event instanceof this)) throw ReactError(Error("Trying to release an event instance into a pool of a different type."));
    event.destructor();
    10 > this.eventPool.length && this.eventPool.push(event);
  }

  function addEventPoolingTo(EventConstructor) {
    EventConstructor.eventPool = [];
    EventConstructor.getPooled = getPooledEvent;
    EventConstructor.release = releasePooledEvent;
  }

  var ResponderSyntheticEvent = SyntheticEvent.extend({
    touchHistory: function touchHistory() {
      return null;
    }
  });

  function isStartish(topLevelType) {
    return "topTouchStart" === topLevelType;
  }

  function isMoveish(topLevelType) {
    return "topTouchMove" === topLevelType;
  }

  var startDependencies = ["topTouchStart"],
      moveDependencies = ["topTouchMove"],
      endDependencies = ["topTouchCancel", "topTouchEnd"],
      touchBank = [],
      touchHistory = {
    touchBank: touchBank,
    numberActiveTouches: 0,
    indexOfSingleActiveTouch: -1,
    mostRecentTimeStamp: 0
  };

  function timestampForTouch(touch) {
    return touch.timeStamp || touch.timestamp;
  }

  function getTouchIdentifier(_ref) {
    _ref = _ref.identifier;
    if (null == _ref) throw ReactError(Error("Touch object is missing identifier."));
    return _ref;
  }

  function recordTouchStart(touch) {
    var identifier = getTouchIdentifier(touch),
        touchRecord = touchBank[identifier];
    touchRecord ? (touchRecord.touchActive = !0, touchRecord.startPageX = touch.pageX, touchRecord.startPageY = touch.pageY, touchRecord.startTimeStamp = timestampForTouch(touch), touchRecord.currentPageX = touch.pageX, touchRecord.currentPageY = touch.pageY, touchRecord.currentTimeStamp = timestampForTouch(touch), touchRecord.previousPageX = touch.pageX, touchRecord.previousPageY = touch.pageY, touchRecord.previousTimeStamp = timestampForTouch(touch)) : (touchRecord = {
      touchActive: !0,
      startPageX: touch.pageX,
      startPageY: touch.pageY,
      startTimeStamp: timestampForTouch(touch),
      currentPageX: touch.pageX,
      currentPageY: touch.pageY,
      currentTimeStamp: timestampForTouch(touch),
      previousPageX: touch.pageX,
      previousPageY: touch.pageY,
      previousTimeStamp: timestampForTouch(touch)
    }, touchBank[identifier] = touchRecord);
    touchHistory.mostRecentTimeStamp = timestampForTouch(touch);
  }

  function recordTouchMove(touch) {
    var touchRecord = touchBank[getTouchIdentifier(touch)];
    touchRecord ? (touchRecord.touchActive = !0, touchRecord.previousPageX = touchRecord.currentPageX, touchRecord.previousPageY = touchRecord.currentPageY, touchRecord.previousTimeStamp = touchRecord.currentTimeStamp, touchRecord.currentPageX = touch.pageX, touchRecord.currentPageY = touch.pageY, touchRecord.currentTimeStamp = timestampForTouch(touch), touchHistory.mostRecentTimeStamp = timestampForTouch(touch)) : console.warn("Cannot record touch move without a touch start.\nTouch Move: %s\n", "Touch Bank: %s", printTouch(touch), printTouchBank());
  }

  function recordTouchEnd(touch) {
    var touchRecord = touchBank[getTouchIdentifier(touch)];
    touchRecord ? (touchRecord.touchActive = !1, touchRecord.previousPageX = touchRecord.currentPageX, touchRecord.previousPageY = touchRecord.currentPageY, touchRecord.previousTimeStamp = touchRecord.currentTimeStamp, touchRecord.currentPageX = touch.pageX, touchRecord.currentPageY = touch.pageY, touchRecord.currentTimeStamp = timestampForTouch(touch), touchHistory.mostRecentTimeStamp = timestampForTouch(touch)) : console.warn("Cannot record touch end without a touch start.\nTouch End: %s\n", "Touch Bank: %s", printTouch(touch), printTouchBank());
  }

  function printTouch(touch) {
    return JSON.stringify({
      identifier: touch.identifier,
      pageX: touch.pageX,
      pageY: touch.pageY,
      timestamp: timestampForTouch(touch)
    });
  }

  function printTouchBank() {
    var printed = JSON.stringify(touchBank.slice(0, 20));
    20 < touchBank.length && (printed += " (original size: " + touchBank.length + ")");
    return printed;
  }

  var ResponderTouchHistoryStore = {
    recordTouchTrack: function recordTouchTrack(topLevelType, nativeEvent) {
      if (isMoveish(topLevelType)) nativeEvent.changedTouches.forEach(recordTouchMove);else if (isStartish(topLevelType)) nativeEvent.changedTouches.forEach(recordTouchStart), touchHistory.numberActiveTouches = nativeEvent.touches.length, 1 === touchHistory.numberActiveTouches && (touchHistory.indexOfSingleActiveTouch = nativeEvent.touches[0].identifier);else if ("topTouchEnd" === topLevelType || "topTouchCancel" === topLevelType) if (nativeEvent.changedTouches.forEach(recordTouchEnd), touchHistory.numberActiveTouches = nativeEvent.touches.length, 1 === touchHistory.numberActiveTouches) for (topLevelType = 0; topLevelType < touchBank.length; topLevelType++) {
        if (nativeEvent = touchBank[topLevelType], null != nativeEvent && nativeEvent.touchActive) {
          touchHistory.indexOfSingleActiveTouch = topLevelType;
          break;
        }
      }
    },
    touchHistory: touchHistory
  };

  function accumulate(current, next) {
    if (null == next) throw ReactError(Error("accumulate(...): Accumulated items must not be null or undefined."));
    return null == current ? next : Array.isArray(current) ? current.concat(next) : Array.isArray(next) ? [current].concat(next) : [current, next];
  }

  var responderInst = null,
      trackedTouchCount = 0;

  function changeResponder(nextResponderInst, blockHostResponder) {
    var oldResponderInst = responderInst;
    responderInst = nextResponderInst;
    if (null !== ResponderEventPlugin.GlobalResponderHandler) ResponderEventPlugin.GlobalResponderHandler.onChange(oldResponderInst, nextResponderInst, blockHostResponder);
  }

  var eventTypes = {
    startShouldSetResponder: {
      phasedRegistrationNames: {
        bubbled: "onStartShouldSetResponder",
        captured: "onStartShouldSetResponderCapture"
      },
      dependencies: startDependencies
    },
    scrollShouldSetResponder: {
      phasedRegistrationNames: {
        bubbled: "onScrollShouldSetResponder",
        captured: "onScrollShouldSetResponderCapture"
      },
      dependencies: ["topScroll"]
    },
    selectionChangeShouldSetResponder: {
      phasedRegistrationNames: {
        bubbled: "onSelectionChangeShouldSetResponder",
        captured: "onSelectionChangeShouldSetResponderCapture"
      },
      dependencies: ["topSelectionChange"]
    },
    moveShouldSetResponder: {
      phasedRegistrationNames: {
        bubbled: "onMoveShouldSetResponder",
        captured: "onMoveShouldSetResponderCapture"
      },
      dependencies: moveDependencies
    },
    responderStart: {
      registrationName: "onResponderStart",
      dependencies: startDependencies
    },
    responderMove: {
      registrationName: "onResponderMove",
      dependencies: moveDependencies
    },
    responderEnd: {
      registrationName: "onResponderEnd",
      dependencies: endDependencies
    },
    responderRelease: {
      registrationName: "onResponderRelease",
      dependencies: endDependencies
    },
    responderTerminationRequest: {
      registrationName: "onResponderTerminationRequest",
      dependencies: []
    },
    responderGrant: {
      registrationName: "onResponderGrant",
      dependencies: []
    },
    responderReject: {
      registrationName: "onResponderReject",
      dependencies: []
    },
    responderTerminate: {
      registrationName: "onResponderTerminate",
      dependencies: []
    }
  },
      ResponderEventPlugin = {
    _getResponder: function _getResponder() {
      return responderInst;
    },
    eventTypes: eventTypes,
    extractEvents: function extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
      if (isStartish(topLevelType)) trackedTouchCount += 1;else if ("topTouchEnd" === topLevelType || "topTouchCancel" === topLevelType) if (0 <= trackedTouchCount) --trackedTouchCount;else return console.error("Ended a touch event which was not counted in `trackedTouchCount`."), null;
      ResponderTouchHistoryStore.recordTouchTrack(topLevelType, nativeEvent);

      if (targetInst && ("topScroll" === topLevelType && !nativeEvent.responderIgnoreScroll || 0 < trackedTouchCount && "topSelectionChange" === topLevelType || isStartish(topLevelType) || isMoveish(topLevelType))) {
        var JSCompiler_temp = isStartish(topLevelType) ? eventTypes.startShouldSetResponder : isMoveish(topLevelType) ? eventTypes.moveShouldSetResponder : "topSelectionChange" === topLevelType ? eventTypes.selectionChangeShouldSetResponder : eventTypes.scrollShouldSetResponder;
        if (responderInst) b: {
          var JSCompiler_temp$jscomp$0 = responderInst;

          for (var depthA = 0, tempA = JSCompiler_temp$jscomp$0; tempA; tempA = getParent(tempA)) {
            depthA++;
          }

          tempA = 0;

          for (var tempB = targetInst; tempB; tempB = getParent(tempB)) {
            tempA++;
          }

          for (; 0 < depthA - tempA;) {
            JSCompiler_temp$jscomp$0 = getParent(JSCompiler_temp$jscomp$0), depthA--;
          }

          for (; 0 < tempA - depthA;) {
            targetInst = getParent(targetInst), tempA--;
          }

          for (; depthA--;) {
            if (JSCompiler_temp$jscomp$0 === targetInst || JSCompiler_temp$jscomp$0 === targetInst.alternate) break b;
            JSCompiler_temp$jscomp$0 = getParent(JSCompiler_temp$jscomp$0);
            targetInst = getParent(targetInst);
          }

          JSCompiler_temp$jscomp$0 = null;
        } else JSCompiler_temp$jscomp$0 = targetInst;
        targetInst = JSCompiler_temp$jscomp$0 === responderInst;
        JSCompiler_temp$jscomp$0 = ResponderSyntheticEvent.getPooled(JSCompiler_temp, JSCompiler_temp$jscomp$0, nativeEvent, nativeEventTarget);
        JSCompiler_temp$jscomp$0.touchHistory = ResponderTouchHistoryStore.touchHistory;
        targetInst ? forEachAccumulated(JSCompiler_temp$jscomp$0, accumulateTwoPhaseDispatchesSingleSkipTarget) : forEachAccumulated(JSCompiler_temp$jscomp$0, accumulateTwoPhaseDispatchesSingle);

        b: {
          JSCompiler_temp = JSCompiler_temp$jscomp$0._dispatchListeners;
          targetInst = JSCompiler_temp$jscomp$0._dispatchInstances;
          if (Array.isArray(JSCompiler_temp)) for (depthA = 0; depthA < JSCompiler_temp.length && !JSCompiler_temp$jscomp$0.isPropagationStopped(); depthA++) {
            if (JSCompiler_temp[depthA](JSCompiler_temp$jscomp$0, targetInst[depthA])) {
              JSCompiler_temp = targetInst[depthA];
              break b;
            }
          } else if (JSCompiler_temp && JSCompiler_temp(JSCompiler_temp$jscomp$0, targetInst)) {
            JSCompiler_temp = targetInst;
            break b;
          }
          JSCompiler_temp = null;
        }

        JSCompiler_temp$jscomp$0._dispatchInstances = null;
        JSCompiler_temp$jscomp$0._dispatchListeners = null;
        JSCompiler_temp$jscomp$0.isPersistent() || JSCompiler_temp$jscomp$0.constructor.release(JSCompiler_temp$jscomp$0);
        JSCompiler_temp && JSCompiler_temp !== responderInst ? (JSCompiler_temp$jscomp$0 = void 0, targetInst = ResponderSyntheticEvent.getPooled(eventTypes.responderGrant, JSCompiler_temp, nativeEvent, nativeEventTarget), targetInst.touchHistory = ResponderTouchHistoryStore.touchHistory, forEachAccumulated(targetInst, accumulateDirectDispatchesSingle), depthA = !0 === executeDirectDispatch(targetInst), responderInst ? (tempA = ResponderSyntheticEvent.getPooled(eventTypes.responderTerminationRequest, responderInst, nativeEvent, nativeEventTarget), tempA.touchHistory = ResponderTouchHistoryStore.touchHistory, forEachAccumulated(tempA, accumulateDirectDispatchesSingle), tempB = !tempA._dispatchListeners || executeDirectDispatch(tempA), tempA.isPersistent() || tempA.constructor.release(tempA), tempB ? (tempA = ResponderSyntheticEvent.getPooled(eventTypes.responderTerminate, responderInst, nativeEvent, nativeEventTarget), tempA.touchHistory = ResponderTouchHistoryStore.touchHistory, forEachAccumulated(tempA, accumulateDirectDispatchesSingle), JSCompiler_temp$jscomp$0 = accumulate(JSCompiler_temp$jscomp$0, [targetInst, tempA]), changeResponder(JSCompiler_temp, depthA)) : (JSCompiler_temp = ResponderSyntheticEvent.getPooled(eventTypes.responderReject, JSCompiler_temp, nativeEvent, nativeEventTarget), JSCompiler_temp.touchHistory = ResponderTouchHistoryStore.touchHistory, forEachAccumulated(JSCompiler_temp, accumulateDirectDispatchesSingle), JSCompiler_temp$jscomp$0 = accumulate(JSCompiler_temp$jscomp$0, JSCompiler_temp))) : (JSCompiler_temp$jscomp$0 = accumulate(JSCompiler_temp$jscomp$0, targetInst), changeResponder(JSCompiler_temp, depthA)), JSCompiler_temp = JSCompiler_temp$jscomp$0) : JSCompiler_temp = null;
      } else JSCompiler_temp = null;

      JSCompiler_temp$jscomp$0 = responderInst && isStartish(topLevelType);
      targetInst = responderInst && isMoveish(topLevelType);
      depthA = responderInst && ("topTouchEnd" === topLevelType || "topTouchCancel" === topLevelType);
      if (JSCompiler_temp$jscomp$0 = JSCompiler_temp$jscomp$0 ? eventTypes.responderStart : targetInst ? eventTypes.responderMove : depthA ? eventTypes.responderEnd : null) JSCompiler_temp$jscomp$0 = ResponderSyntheticEvent.getPooled(JSCompiler_temp$jscomp$0, responderInst, nativeEvent, nativeEventTarget), JSCompiler_temp$jscomp$0.touchHistory = ResponderTouchHistoryStore.touchHistory, forEachAccumulated(JSCompiler_temp$jscomp$0, accumulateDirectDispatchesSingle), JSCompiler_temp = accumulate(JSCompiler_temp, JSCompiler_temp$jscomp$0);
      JSCompiler_temp$jscomp$0 = responderInst && "topTouchCancel" === topLevelType;
      if (topLevelType = responderInst && !JSCompiler_temp$jscomp$0 && ("topTouchEnd" === topLevelType || "topTouchCancel" === topLevelType)) a: {
        if ((topLevelType = nativeEvent.touches) && 0 !== topLevelType.length) for (targetInst = 0; targetInst < topLevelType.length; targetInst++) {
          if (depthA = topLevelType[targetInst].target, null !== depthA && void 0 !== depthA && 0 !== depthA) {
            tempA = getInstanceFromNode(depthA);

            b: {
              for (depthA = responderInst; tempA;) {
                if (depthA === tempA || depthA === tempA.alternate) {
                  depthA = !0;
                  break b;
                }

                tempA = getParent(tempA);
              }

              depthA = !1;
            }

            if (depthA) {
              topLevelType = !1;
              break a;
            }
          }
        }
        topLevelType = !0;
      }
      if (topLevelType = JSCompiler_temp$jscomp$0 ? eventTypes.responderTerminate : topLevelType ? eventTypes.responderRelease : null) nativeEvent = ResponderSyntheticEvent.getPooled(topLevelType, responderInst, nativeEvent, nativeEventTarget), nativeEvent.touchHistory = ResponderTouchHistoryStore.touchHistory, forEachAccumulated(nativeEvent, accumulateDirectDispatchesSingle), JSCompiler_temp = accumulate(JSCompiler_temp, nativeEvent), changeResponder(null);
      return JSCompiler_temp;
    },
    GlobalResponderHandler: null,
    injection: {
      injectGlobalResponderHandler: function injectGlobalResponderHandler(GlobalResponderHandler) {
        ResponderEventPlugin.GlobalResponderHandler = GlobalResponderHandler;
      }
    }
  },
      customBubblingEventTypes = ReactNativePrivateInterface.ReactNativeViewConfigRegistry.customBubblingEventTypes,
      customDirectEventTypes = ReactNativePrivateInterface.ReactNativeViewConfigRegistry.customDirectEventTypes;
  injection.injectEventPluginOrder(["ResponderEventPlugin", "ReactNativeBridgeEventPlugin"]);
  injection.injectEventPluginsByName({
    ResponderEventPlugin: ResponderEventPlugin,
    ReactNativeBridgeEventPlugin: {
      eventTypes: {},
      extractEvents: function extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
        if (null == targetInst) return null;
        var bubbleDispatchConfig = customBubblingEventTypes[topLevelType],
            directDispatchConfig = customDirectEventTypes[topLevelType];
        if (!bubbleDispatchConfig && !directDispatchConfig) throw ReactError(Error('Unsupported top level event type "' + topLevelType + '" dispatched'));
        topLevelType = SyntheticEvent.getPooled(bubbleDispatchConfig || directDispatchConfig, targetInst, nativeEvent, nativeEventTarget);
        if (bubbleDispatchConfig) forEachAccumulated(topLevelType, accumulateTwoPhaseDispatchesSingle);else if (directDispatchConfig) forEachAccumulated(topLevelType, accumulateDirectDispatchesSingle);else return null;
        return topLevelType;
      }
    }
  });

  function getInstanceFromInstance(instanceHandle) {
    return instanceHandle;
  }

  getFiberCurrentPropsFromNode = function getFiberCurrentPropsFromNode(inst) {
    return inst.canonical.currentProps;
  };

  getInstanceFromNode = getInstanceFromInstance;

  getNodeFromInstance = function getNodeFromInstance(inst) {
    inst = inst.stateNode.canonical._nativeTag;
    if (!inst) throw ReactError(Error("All native instances should have a tag."));
    return inst;
  };

  ResponderEventPlugin.injection.injectGlobalResponderHandler({
    onChange: function onChange(from, to, blockNativeResponder) {
      null !== to ? ReactNativePrivateInterface.UIManager.setJSResponder(to.stateNode.canonical._nativeTag, blockNativeResponder) : ReactNativePrivateInterface.UIManager.clearJSResponder();
    }
  });
  var ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
  ReactSharedInternals.hasOwnProperty("ReactCurrentDispatcher") || (ReactSharedInternals.ReactCurrentDispatcher = {
    current: null
  });
  ReactSharedInternals.hasOwnProperty("ReactCurrentBatchConfig") || (ReactSharedInternals.ReactCurrentBatchConfig = {
    suspense: null
  });
  var hasSymbol = "function" === typeof Symbol && (typeof Symbol === "function" ? Symbol.for : "@@for"),
      REACT_ELEMENT_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.element") : 60103,
      REACT_PORTAL_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.portal") : 60106,
      REACT_FRAGMENT_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.fragment") : 60107,
      REACT_STRICT_MODE_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.strict_mode") : 60108,
      REACT_PROFILER_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.profiler") : 60114,
      REACT_PROVIDER_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.provider") : 60109,
      REACT_CONTEXT_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.context") : 60110,
      REACT_CONCURRENT_MODE_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.concurrent_mode") : 60111,
      REACT_FORWARD_REF_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.forward_ref") : 60112,
      REACT_SUSPENSE_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.suspense") : 60113,
      REACT_SUSPENSE_LIST_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.suspense_list") : 60120,
      REACT_MEMO_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.memo") : 60115,
      REACT_LAZY_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.lazy") : 60116;
  hasSymbol && (typeof Symbol === "function" ? Symbol.for : "@@for")("react.fundamental");
  hasSymbol && (typeof Symbol === "function" ? Symbol.for : "@@for")("react.responder");
  var MAYBE_ITERATOR_SYMBOL = "function" === typeof Symbol && (typeof Symbol === "function" ? Symbol.iterator : "@@iterator");

  function getIteratorFn(maybeIterable) {
    if (null === maybeIterable || "object" !== typeof maybeIterable) return null;
    maybeIterable = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable["@@iterator"];
    return "function" === typeof maybeIterable ? maybeIterable : null;
  }

  function getComponentName(type) {
    if (null == type) return null;
    if ("function" === typeof type) return type.displayName || type.name || null;
    if ("string" === typeof type) return type;

    switch (type) {
      case REACT_FRAGMENT_TYPE:
        return "Fragment";

      case REACT_PORTAL_TYPE:
        return "Portal";

      case REACT_PROFILER_TYPE:
        return "Profiler";

      case REACT_STRICT_MODE_TYPE:
        return "StrictMode";

      case REACT_SUSPENSE_TYPE:
        return "Suspense";

      case REACT_SUSPENSE_LIST_TYPE:
        return "SuspenseList";
    }

    if ("object" === typeof type) switch (type.$$typeof) {
      case REACT_CONTEXT_TYPE:
        return "Context.Consumer";

      case REACT_PROVIDER_TYPE:
        return "Context.Provider";

      case REACT_FORWARD_REF_TYPE:
        var innerType = type.render;
        innerType = innerType.displayName || innerType.name || "";
        return type.displayName || ("" !== innerType ? "ForwardRef(" + innerType + ")" : "ForwardRef");

      case REACT_MEMO_TYPE:
        return getComponentName(type.type);

      case REACT_LAZY_TYPE:
        if (type = 1 === type._status ? type._result : null) return getComponentName(type);
    }
    return null;
  }

  function isFiberMountedImpl(fiber) {
    var node = fiber;
    if (fiber.alternate) for (; node.return;) {
      node = node.return;
    } else {
      if (0 !== (node.effectTag & 2)) return 1;

      for (; node.return;) {
        if (node = node.return, 0 !== (node.effectTag & 2)) return 1;
      }
    }
    return 3 === node.tag ? 2 : 3;
  }

  function assertIsMounted(fiber) {
    if (2 !== isFiberMountedImpl(fiber)) throw ReactError(Error("Unable to find node on an unmounted component."));
  }

  function findCurrentFiberUsingSlowPath(fiber) {
    var alternate = fiber.alternate;

    if (!alternate) {
      alternate = isFiberMountedImpl(fiber);
      if (3 === alternate) throw ReactError(Error("Unable to find node on an unmounted component."));
      return 1 === alternate ? null : fiber;
    }

    for (var a = fiber, b = alternate;;) {
      var parentA = a.return;
      if (null === parentA) break;
      var parentB = parentA.alternate;

      if (null === parentB) {
        b = parentA.return;

        if (null !== b) {
          a = b;
          continue;
        }

        break;
      }

      if (parentA.child === parentB.child) {
        for (parentB = parentA.child; parentB;) {
          if (parentB === a) return assertIsMounted(parentA), fiber;
          if (parentB === b) return assertIsMounted(parentA), alternate;
          parentB = parentB.sibling;
        }

        throw ReactError(Error("Unable to find node on an unmounted component."));
      }

      if (a.return !== b.return) a = parentA, b = parentB;else {
        for (var didFindChild = !1, _child = parentA.child; _child;) {
          if (_child === a) {
            didFindChild = !0;
            a = parentA;
            b = parentB;
            break;
          }

          if (_child === b) {
            didFindChild = !0;
            b = parentA;
            a = parentB;
            break;
          }

          _child = _child.sibling;
        }

        if (!didFindChild) {
          for (_child = parentB.child; _child;) {
            if (_child === a) {
              didFindChild = !0;
              a = parentB;
              b = parentA;
              break;
            }

            if (_child === b) {
              didFindChild = !0;
              b = parentB;
              a = parentA;
              break;
            }

            _child = _child.sibling;
          }

          if (!didFindChild) throw ReactError(Error("Child was not found in either parent set. This indicates a bug in React related to the return pointer. Please file an issue."));
        }
      }
      if (a.alternate !== b) throw ReactError(Error("Return fibers should always be each others' alternates. This error is likely caused by a bug in React. Please file an issue."));
    }

    if (3 !== a.tag) throw ReactError(Error("Unable to find node on an unmounted component."));
    return a.stateNode.current === a ? fiber : alternate;
  }

  function findCurrentHostFiber(parent) {
    parent = findCurrentFiberUsingSlowPath(parent);
    if (!parent) return null;

    for (var node = parent;;) {
      if (5 === node.tag || 6 === node.tag) return node;
      if (node.child) node.child.return = node, node = node.child;else {
        if (node === parent) break;

        for (; !node.sibling;) {
          if (!node.return || node.return === parent) return null;
          node = node.return;
        }

        node.sibling.return = node.return;
        node = node.sibling;
      }
    }

    return null;
  }

  function mountSafeCallback_NOT_REALLY_SAFE(context, callback) {
    return function () {
      if (callback && ("boolean" !== typeof context.__isMounted || context.__isMounted)) return callback.apply(context, arguments);
    };
  }

  var emptyObject = {},
      removedKeys = null,
      removedKeyCount = 0;

  function restoreDeletedValuesInNestedArray(updatePayload, node, validAttributes) {
    if (Array.isArray(node)) for (var i = node.length; i-- && 0 < removedKeyCount;) {
      restoreDeletedValuesInNestedArray(updatePayload, node[i], validAttributes);
    } else if (node && 0 < removedKeyCount) for (i in removedKeys) {
      if (removedKeys[i]) {
        var nextProp = node[i];

        if (void 0 !== nextProp) {
          var attributeConfig = validAttributes[i];

          if (attributeConfig) {
            "function" === typeof nextProp && (nextProp = !0);
            "undefined" === typeof nextProp && (nextProp = null);
            if ("object" !== typeof attributeConfig) updatePayload[i] = nextProp;else if ("function" === typeof attributeConfig.diff || "function" === typeof attributeConfig.process) nextProp = "function" === typeof attributeConfig.process ? attributeConfig.process(nextProp) : nextProp, updatePayload[i] = nextProp;
            removedKeys[i] = !1;
            removedKeyCount--;
          }
        }
      }
    }
  }

  function diffNestedProperty(updatePayload, prevProp, nextProp, validAttributes) {
    if (!updatePayload && prevProp === nextProp) return updatePayload;
    if (!prevProp || !nextProp) return nextProp ? addNestedProperty(updatePayload, nextProp, validAttributes) : prevProp ? clearNestedProperty(updatePayload, prevProp, validAttributes) : updatePayload;
    if (!Array.isArray(prevProp) && !Array.isArray(nextProp)) return diffProperties(updatePayload, prevProp, nextProp, validAttributes);

    if (Array.isArray(prevProp) && Array.isArray(nextProp)) {
      var minLength = prevProp.length < nextProp.length ? prevProp.length : nextProp.length,
          i;

      for (i = 0; i < minLength; i++) {
        updatePayload = diffNestedProperty(updatePayload, prevProp[i], nextProp[i], validAttributes);
      }

      for (; i < prevProp.length; i++) {
        updatePayload = clearNestedProperty(updatePayload, prevProp[i], validAttributes);
      }

      for (; i < nextProp.length; i++) {
        updatePayload = addNestedProperty(updatePayload, nextProp[i], validAttributes);
      }

      return updatePayload;
    }

    return Array.isArray(prevProp) ? diffProperties(updatePayload, ReactNativePrivateInterface.flattenStyle(prevProp), nextProp, validAttributes) : diffProperties(updatePayload, prevProp, ReactNativePrivateInterface.flattenStyle(nextProp), validAttributes);
  }

  function addNestedProperty(updatePayload, nextProp, validAttributes) {
    if (!nextProp) return updatePayload;
    if (!Array.isArray(nextProp)) return diffProperties(updatePayload, emptyObject, nextProp, validAttributes);

    for (var i = 0; i < nextProp.length; i++) {
      updatePayload = addNestedProperty(updatePayload, nextProp[i], validAttributes);
    }

    return updatePayload;
  }

  function clearNestedProperty(updatePayload, prevProp, validAttributes) {
    if (!prevProp) return updatePayload;
    if (!Array.isArray(prevProp)) return diffProperties(updatePayload, prevProp, emptyObject, validAttributes);

    for (var i = 0; i < prevProp.length; i++) {
      updatePayload = clearNestedProperty(updatePayload, prevProp[i], validAttributes);
    }

    return updatePayload;
  }

  function diffProperties(updatePayload, prevProps, nextProps, validAttributes) {
    var attributeConfig, propKey;

    for (propKey in nextProps) {
      if (attributeConfig = validAttributes[propKey]) {
        var prevProp = prevProps[propKey];
        var nextProp = nextProps[propKey];
        "function" === typeof nextProp && (nextProp = !0, "function" === typeof prevProp && (prevProp = !0));
        "undefined" === typeof nextProp && (nextProp = null, "undefined" === typeof prevProp && (prevProp = null));
        removedKeys && (removedKeys[propKey] = !1);
        if (updatePayload && void 0 !== updatePayload[propKey]) {
          if ("object" !== typeof attributeConfig) updatePayload[propKey] = nextProp;else {
            if ("function" === typeof attributeConfig.diff || "function" === typeof attributeConfig.process) attributeConfig = "function" === typeof attributeConfig.process ? attributeConfig.process(nextProp) : nextProp, updatePayload[propKey] = attributeConfig;
          }
        } else if (prevProp !== nextProp) if ("object" !== typeof attributeConfig) ("object" !== typeof nextProp || null === nextProp || ReactNativePrivateInterface.deepDiffer(prevProp, nextProp)) && ((updatePayload || (updatePayload = {}))[propKey] = nextProp);else if ("function" === typeof attributeConfig.diff || "function" === typeof attributeConfig.process) {
          if (void 0 === prevProp || ("function" === typeof attributeConfig.diff ? attributeConfig.diff(prevProp, nextProp) : "object" !== typeof nextProp || null === nextProp || ReactNativePrivateInterface.deepDiffer(prevProp, nextProp))) attributeConfig = "function" === typeof attributeConfig.process ? attributeConfig.process(nextProp) : nextProp, (updatePayload || (updatePayload = {}))[propKey] = attributeConfig;
        } else removedKeys = null, removedKeyCount = 0, updatePayload = diffNestedProperty(updatePayload, prevProp, nextProp, attributeConfig), 0 < removedKeyCount && updatePayload && (restoreDeletedValuesInNestedArray(updatePayload, nextProp, attributeConfig), removedKeys = null);
      }
    }

    for (var _propKey in prevProps) {
      void 0 === nextProps[_propKey] && (!(attributeConfig = validAttributes[_propKey]) || updatePayload && void 0 !== updatePayload[_propKey] || (prevProp = prevProps[_propKey], void 0 !== prevProp && ("object" !== typeof attributeConfig || "function" === typeof attributeConfig.diff || "function" === typeof attributeConfig.process ? ((updatePayload || (updatePayload = {}))[_propKey] = null, removedKeys || (removedKeys = {}), removedKeys[_propKey] || (removedKeys[_propKey] = !0, removedKeyCount++)) : updatePayload = clearNestedProperty(updatePayload, prevProp, attributeConfig))));
    }

    return updatePayload;
  }

  var restoreTarget = null,
      restoreQueue = null;

  function restoreStateOfTarget(target) {
    if (getInstanceFromNode(target)) throw ReactError(Error("setRestoreImplementation() needs to be called to handle a target for controlled events. This error is likely caused by a bug in React. Please file an issue."));
  }

  function batchedUpdatesImpl(fn, bookkeeping) {
    return fn(bookkeeping);
  }

  function flushDiscreteUpdatesImpl() {}

  var isInsideEventHandler = !1;

  function batchedUpdates(fn, bookkeeping) {
    if (isInsideEventHandler) return fn(bookkeeping);
    isInsideEventHandler = !0;

    try {
      return batchedUpdatesImpl(fn, bookkeeping);
    } finally {
      if (isInsideEventHandler = !1, null !== restoreTarget || null !== restoreQueue) if (flushDiscreteUpdatesImpl(), restoreTarget && (bookkeeping = restoreTarget, fn = restoreQueue, restoreQueue = restoreTarget = null, restoreStateOfTarget(bookkeeping), fn)) for (bookkeeping = 0; bookkeeping < fn.length; bookkeeping++) {
        restoreStateOfTarget(fn[bookkeeping]);
      }
    }
  }

  function _inherits(subClass, superClass) {
    if ("function" !== typeof superClass && null !== superClass) throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
    subClass.prototype = Object.create(superClass && superClass.prototype, {
      constructor: {
        value: subClass,
        enumerable: !1,
        writable: !0,
        configurable: !0
      }
    });
    superClass && (Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass);
  }

  (function (_React$Component) {
    function ReactNativeComponent() {
      if (!(this instanceof ReactNativeComponent)) throw new TypeError("Cannot call a class as a function");

      var call = _React$Component.apply(this, arguments);

      if (!this) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
      return !call || "object" !== typeof call && "function" !== typeof call ? this : call;
    }

    _inherits(ReactNativeComponent, _React$Component);

    ReactNativeComponent.prototype.blur = function () {};

    ReactNativeComponent.prototype.focus = function () {};

    ReactNativeComponent.prototype.measure = function () {};

    ReactNativeComponent.prototype.measureInWindow = function () {};

    ReactNativeComponent.prototype.measureLayout = function () {};

    ReactNativeComponent.prototype.setNativeProps = function () {};

    return ReactNativeComponent;
  })(React.Component);

  new Map();
  new Map();
  new Set();
  new Map();

  function dispatchEvent(target, topLevelType, nativeEvent) {
    batchedUpdates(function () {
      var events = nativeEvent.target;

      for (var events$jscomp$0 = null, i = 0; i < plugins.length; i++) {
        var possiblePlugin = plugins[i];
        possiblePlugin && (possiblePlugin = possiblePlugin.extractEvents(topLevelType, target, nativeEvent, events)) && (events$jscomp$0 = accumulateInto(events$jscomp$0, possiblePlugin));
      }

      events = events$jscomp$0;
      null !== events && (eventQueue = accumulateInto(eventQueue, events));
      events = eventQueue;
      eventQueue = null;

      if (events) {
        forEachAccumulated(events, executeDispatchesAndReleaseTopLevel);
        if (eventQueue) throw ReactError(Error("processEventQueue(): Additional events were enqueued while processing an event queue. Support for this has not yet been implemented."));
        if (hasRethrowError) throw events = rethrowError, hasRethrowError = !1, rethrowError = null, events;
      }
    });
  }

  function shim$1() {
    throw ReactError(Error("The current renderer does not support hydration. This error is likely caused by a bug in React. Please file an issue."));
  }

  var _nativeFabricUIManage$1 = nativeFabricUIManager,
      createNode = _nativeFabricUIManage$1.createNode,
      cloneNode = _nativeFabricUIManage$1.cloneNode,
      cloneNodeWithNewChildren = _nativeFabricUIManage$1.cloneNodeWithNewChildren,
      cloneNodeWithNewChildrenAndProps = _nativeFabricUIManage$1.cloneNodeWithNewChildrenAndProps,
      cloneNodeWithNewProps = _nativeFabricUIManage$1.cloneNodeWithNewProps,
      createChildNodeSet = _nativeFabricUIManage$1.createChildSet,
      appendChildNode = _nativeFabricUIManage$1.appendChild,
      appendChildNodeToSet = _nativeFabricUIManage$1.appendChildToSet,
      completeRoot = _nativeFabricUIManage$1.completeRoot,
      registerEventHandler = _nativeFabricUIManage$1.registerEventHandler,
      fabricMeasure = _nativeFabricUIManage$1.measure,
      fabricMeasureInWindow = _nativeFabricUIManage$1.measureInWindow,
      fabricMeasureLayout = _nativeFabricUIManage$1.measureLayout,
      getViewConfigForType = ReactNativePrivateInterface.ReactNativeViewConfigRegistry.get,
      nextReactTag = 2;
  registerEventHandler && registerEventHandler(dispatchEvent);

  var ReactFabricHostComponent = function () {
    function ReactFabricHostComponent(tag, viewConfig, props, internalInstanceHandle) {
      if (!(this instanceof ReactFabricHostComponent)) throw new TypeError("Cannot call a class as a function");
      this._nativeTag = tag;
      this.viewConfig = viewConfig;
      this.currentProps = props;
      this._internalInstanceHandle = internalInstanceHandle;
    }

    ReactFabricHostComponent.prototype.blur = function () {
      ReactNativePrivateInterface.TextInputState.blurTextInput(this._nativeTag);
    };

    ReactFabricHostComponent.prototype.focus = function () {
      ReactNativePrivateInterface.TextInputState.focusTextInput(this._nativeTag);
    };

    ReactFabricHostComponent.prototype.measure = function (callback) {
      fabricMeasure(this._internalInstanceHandle.stateNode.node, mountSafeCallback_NOT_REALLY_SAFE(this, callback));
    };

    ReactFabricHostComponent.prototype.measureInWindow = function (callback) {
      fabricMeasureInWindow(this._internalInstanceHandle.stateNode.node, mountSafeCallback_NOT_REALLY_SAFE(this, callback));
    };

    ReactFabricHostComponent.prototype.measureLayout = function (relativeToNativeNode, onSuccess, onFail) {
      "number" !== typeof relativeToNativeNode && relativeToNativeNode instanceof ReactFabricHostComponent && fabricMeasureLayout(this._internalInstanceHandle.stateNode.node, relativeToNativeNode._internalInstanceHandle.stateNode.node, mountSafeCallback_NOT_REALLY_SAFE(this, onFail), mountSafeCallback_NOT_REALLY_SAFE(this, onSuccess));
    };

    ReactFabricHostComponent.prototype.setNativeProps = function () {};

    return ReactFabricHostComponent;
  }();

  function createTextInstance(text, rootContainerInstance, hostContext, internalInstanceHandle) {
    if (!hostContext.isInAParentText) throw ReactError(Error("Text strings must be rendered within a <Text> component."));
    hostContext = nextReactTag;
    nextReactTag += 2;
    return {
      node: createNode(hostContext, "RCTRawText", rootContainerInstance, {
        text: text
      }, internalInstanceHandle)
    };
  }

  var scheduleTimeout = setTimeout,
      cancelTimeout = clearTimeout;

  function cloneHiddenInstance(instance) {
    var node = instance.node;
    var updatePayload = diffProperties(null, emptyObject, {
      style: {
        display: "none"
      }
    }, instance.canonical.viewConfig.validAttributes);
    return {
      node: cloneNodeWithNewProps(node, updatePayload),
      canonical: instance.canonical
    };
  }

  var BEFORE_SLASH_RE = /^(.*)[\\\/]/;

  function getStackByFiberInDevAndProd(workInProgress) {
    var info = "";

    do {
      a: switch (workInProgress.tag) {
        case 3:
        case 4:
        case 6:
        case 7:
        case 10:
        case 9:
          var JSCompiler_inline_result = "";
          break a;

        default:
          var owner = workInProgress._debugOwner,
              source = workInProgress._debugSource,
              name = getComponentName(workInProgress.type);
          JSCompiler_inline_result = null;
          owner && (JSCompiler_inline_result = getComponentName(owner.type));
          owner = name;
          name = "";
          source ? name = " (at " + source.fileName.replace(BEFORE_SLASH_RE, "") + ":" + source.lineNumber + ")" : JSCompiler_inline_result && (name = " (created by " + JSCompiler_inline_result + ")");
          JSCompiler_inline_result = "\n    in " + (owner || "Unknown") + name;
      }

      info += JSCompiler_inline_result;
      workInProgress = workInProgress.return;
    } while (workInProgress);

    return info;
  }

  new Set();
  var valueStack = [],
      index = -1;

  function pop(cursor) {
    0 > index || (cursor.current = valueStack[index], valueStack[index] = null, index--);
  }

  function push(cursor, value) {
    index++;
    valueStack[index] = cursor.current;
    cursor.current = value;
  }

  var emptyContextObject = {},
      contextStackCursor = {
    current: emptyContextObject
  },
      didPerformWorkStackCursor = {
    current: !1
  },
      previousContext = emptyContextObject;

  function getMaskedContext(workInProgress, unmaskedContext) {
    var contextTypes = workInProgress.type.contextTypes;
    if (!contextTypes) return emptyContextObject;
    var instance = workInProgress.stateNode;
    if (instance && instance.__reactInternalMemoizedUnmaskedChildContext === unmaskedContext) return instance.__reactInternalMemoizedMaskedChildContext;
    var context = {},
        key;

    for (key in contextTypes) {
      context[key] = unmaskedContext[key];
    }

    instance && (workInProgress = workInProgress.stateNode, workInProgress.__reactInternalMemoizedUnmaskedChildContext = unmaskedContext, workInProgress.__reactInternalMemoizedMaskedChildContext = context);
    return context;
  }

  function isContextProvider(type) {
    type = type.childContextTypes;
    return null !== type && void 0 !== type;
  }

  function popContext(fiber) {
    pop(didPerformWorkStackCursor, fiber);
    pop(contextStackCursor, fiber);
  }

  function popTopLevelContextObject(fiber) {
    pop(didPerformWorkStackCursor, fiber);
    pop(contextStackCursor, fiber);
  }

  function pushTopLevelContextObject(fiber, context, didChange) {
    if (contextStackCursor.current !== emptyContextObject) throw ReactError(Error("Unexpected context found on stack. This error is likely caused by a bug in React. Please file an issue."));
    push(contextStackCursor, context, fiber);
    push(didPerformWorkStackCursor, didChange, fiber);
  }

  function processChildContext(fiber, type, parentContext) {
    var instance = fiber.stateNode;
    fiber = type.childContextTypes;
    if ("function" !== typeof instance.getChildContext) return parentContext;
    instance = instance.getChildContext();

    for (var contextKey in instance) {
      if (!(contextKey in fiber)) throw ReactError(Error((getComponentName(type) || "Unknown") + '.getChildContext(): key "' + contextKey + '" is not defined in childContextTypes.'));
    }

    return _extends({}, parentContext, instance);
  }

  function pushContextProvider(workInProgress) {
    var instance = workInProgress.stateNode;
    instance = instance && instance.__reactInternalMemoizedMergedChildContext || emptyContextObject;
    previousContext = contextStackCursor.current;
    push(contextStackCursor, instance, workInProgress);
    push(didPerformWorkStackCursor, didPerformWorkStackCursor.current, workInProgress);
    return !0;
  }

  function invalidateContextProvider(workInProgress, type, didChange) {
    var instance = workInProgress.stateNode;
    if (!instance) throw ReactError(Error("Expected to have an instance by this point. This error is likely caused by a bug in React. Please file an issue."));
    didChange ? (type = processChildContext(workInProgress, type, previousContext), instance.__reactInternalMemoizedMergedChildContext = type, pop(didPerformWorkStackCursor, workInProgress), pop(contextStackCursor, workInProgress), push(contextStackCursor, type, workInProgress)) : pop(didPerformWorkStackCursor, workInProgress);
    push(didPerformWorkStackCursor, didChange, workInProgress);
  }

  var Scheduler_runWithPriority = Scheduler.unstable_runWithPriority,
      Scheduler_scheduleCallback = Scheduler.unstable_scheduleCallback,
      Scheduler_cancelCallback = Scheduler.unstable_cancelCallback,
      Scheduler_shouldYield = Scheduler.unstable_shouldYield,
      Scheduler_requestPaint = Scheduler.unstable_requestPaint,
      Scheduler_now = Scheduler.unstable_now,
      Scheduler_getCurrentPriorityLevel = Scheduler.unstable_getCurrentPriorityLevel,
      Scheduler_ImmediatePriority = Scheduler.unstable_ImmediatePriority,
      Scheduler_UserBlockingPriority = Scheduler.unstable_UserBlockingPriority,
      Scheduler_NormalPriority = Scheduler.unstable_NormalPriority,
      Scheduler_LowPriority = Scheduler.unstable_LowPriority,
      Scheduler_IdlePriority = Scheduler.unstable_IdlePriority,
      fakeCallbackNode = {},
      requestPaint = void 0 !== Scheduler_requestPaint ? Scheduler_requestPaint : function () {},
      syncQueue = null,
      immediateQueueCallbackNode = null,
      isFlushingSyncQueue = !1,
      initialTimeMs = Scheduler_now(),
      now = 1e4 > initialTimeMs ? Scheduler_now : function () {
    return Scheduler_now() - initialTimeMs;
  };

  function getCurrentPriorityLevel() {
    switch (Scheduler_getCurrentPriorityLevel()) {
      case Scheduler_ImmediatePriority:
        return 99;

      case Scheduler_UserBlockingPriority:
        return 98;

      case Scheduler_NormalPriority:
        return 97;

      case Scheduler_LowPriority:
        return 96;

      case Scheduler_IdlePriority:
        return 95;

      default:
        throw ReactError(Error("Unknown priority level."));
    }
  }

  function reactPriorityToSchedulerPriority(reactPriorityLevel) {
    switch (reactPriorityLevel) {
      case 99:
        return Scheduler_ImmediatePriority;

      case 98:
        return Scheduler_UserBlockingPriority;

      case 97:
        return Scheduler_NormalPriority;

      case 96:
        return Scheduler_LowPriority;

      case 95:
        return Scheduler_IdlePriority;

      default:
        throw ReactError(Error("Unknown priority level."));
    }
  }

  function runWithPriority$1(reactPriorityLevel, fn) {
    reactPriorityLevel = reactPriorityToSchedulerPriority(reactPriorityLevel);
    return Scheduler_runWithPriority(reactPriorityLevel, fn);
  }

  function scheduleCallback(reactPriorityLevel, callback, options) {
    reactPriorityLevel = reactPriorityToSchedulerPriority(reactPriorityLevel);
    return Scheduler_scheduleCallback(reactPriorityLevel, callback, options);
  }

  function scheduleSyncCallback(callback) {
    null === syncQueue ? (syncQueue = [callback], immediateQueueCallbackNode = Scheduler_scheduleCallback(Scheduler_ImmediatePriority, flushSyncCallbackQueueImpl)) : syncQueue.push(callback);
    return fakeCallbackNode;
  }

  function flushSyncCallbackQueue() {
    null !== immediateQueueCallbackNode && Scheduler_cancelCallback(immediateQueueCallbackNode);
    flushSyncCallbackQueueImpl();
  }

  function flushSyncCallbackQueueImpl() {
    if (!isFlushingSyncQueue && null !== syncQueue) {
      isFlushingSyncQueue = !0;
      var i = 0;

      try {
        var queue = syncQueue;
        runWithPriority$1(99, function () {
          for (; i < queue.length; i++) {
            var callback = queue[i];

            do {
              callback = callback(!0);
            } while (null !== callback);
          }
        });
        syncQueue = null;
      } catch (error) {
        throw null !== syncQueue && (syncQueue = syncQueue.slice(i + 1)), Scheduler_scheduleCallback(Scheduler_ImmediatePriority, flushSyncCallbackQueue), error;
      } finally {
        isFlushingSyncQueue = !1;
      }
    }
  }

  function inferPriorityFromExpirationTime(currentTime, expirationTime) {
    if (1073741823 === expirationTime) return 99;
    if (1 === expirationTime) return 95;
    currentTime = 10 * (1073741821 - expirationTime) - 10 * (1073741821 - currentTime);
    return 0 >= currentTime ? 99 : 250 >= currentTime ? 98 : 5250 >= currentTime ? 97 : 95;
  }

  function is(x, y) {
    return x === y && (0 !== x || 1 / x === 1 / y) || x !== x && y !== y;
  }

  var hasOwnProperty = Object.prototype.hasOwnProperty;

  function shallowEqual(objA, objB) {
    if (is(objA, objB)) return !0;
    if ("object" !== typeof objA || null === objA || "object" !== typeof objB || null === objB) return !1;
    var keysA = Object.keys(objA),
        keysB = Object.keys(objB);
    if (keysA.length !== keysB.length) return !1;

    for (keysB = 0; keysB < keysA.length; keysB++) {
      if (!hasOwnProperty.call(objB, keysA[keysB]) || !is(objA[keysA[keysB]], objB[keysA[keysB]])) return !1;
    }

    return !0;
  }

  function resolveDefaultProps(Component, baseProps) {
    if (Component && Component.defaultProps) {
      baseProps = _extends({}, baseProps);
      Component = Component.defaultProps;

      for (var propName in Component) {
        void 0 === baseProps[propName] && (baseProps[propName] = Component[propName]);
      }
    }

    return baseProps;
  }

  function readLazyComponentType(lazyComponent) {
    var result = lazyComponent._result;

    switch (lazyComponent._status) {
      case 1:
        return result;

      case 2:
        throw result;

      case 0:
        throw result;

      default:
        lazyComponent._status = 0;
        result = lazyComponent._ctor;
        result = result();
        result.then(function (moduleObject) {
          0 === lazyComponent._status && (moduleObject = moduleObject.default, lazyComponent._status = 1, lazyComponent._result = moduleObject);
        }, function (error) {
          0 === lazyComponent._status && (lazyComponent._status = 2, lazyComponent._result = error);
        });

        switch (lazyComponent._status) {
          case 1:
            return lazyComponent._result;

          case 2:
            throw lazyComponent._result;
        }

        lazyComponent._result = result;
        throw result;
    }
  }

  var valueCursor = {
    current: null
  },
      currentlyRenderingFiber = null,
      lastContextDependency = null,
      lastContextWithAllBitsObserved = null;

  function resetContextDependencies() {
    lastContextWithAllBitsObserved = lastContextDependency = currentlyRenderingFiber = null;
  }

  function pushProvider(providerFiber, nextValue) {
    var context = providerFiber.type._context;
    push(valueCursor, context._currentValue2, providerFiber);
    context._currentValue2 = nextValue;
  }

  function popProvider(providerFiber) {
    var currentValue = valueCursor.current;
    pop(valueCursor, providerFiber);
    providerFiber.type._context._currentValue2 = currentValue;
  }

  function scheduleWorkOnParentPath(parent, renderExpirationTime) {
    for (; null !== parent;) {
      var alternate = parent.alternate;
      if (parent.childExpirationTime < renderExpirationTime) parent.childExpirationTime = renderExpirationTime, null !== alternate && alternate.childExpirationTime < renderExpirationTime && (alternate.childExpirationTime = renderExpirationTime);else if (null !== alternate && alternate.childExpirationTime < renderExpirationTime) alternate.childExpirationTime = renderExpirationTime;else break;
      parent = parent.return;
    }
  }

  function prepareToReadContext(workInProgress, renderExpirationTime) {
    currentlyRenderingFiber = workInProgress;
    lastContextWithAllBitsObserved = lastContextDependency = null;
    workInProgress = workInProgress.dependencies;
    null !== workInProgress && null !== workInProgress.firstContext && (workInProgress.expirationTime >= renderExpirationTime && (didReceiveUpdate = !0), workInProgress.firstContext = null);
  }

  function readContext(context, observedBits) {
    if (lastContextWithAllBitsObserved !== context && !1 !== observedBits && 0 !== observedBits) {
      if ("number" !== typeof observedBits || 1073741823 === observedBits) lastContextWithAllBitsObserved = context, observedBits = 1073741823;
      observedBits = {
        context: context,
        observedBits: observedBits,
        next: null
      };

      if (null === lastContextDependency) {
        if (null === currentlyRenderingFiber) throw ReactError(Error("Context can only be read while React is rendering. In classes, you can read it in the render method or getDerivedStateFromProps. In function components, you can read it directly in the function body, but not inside Hooks like useReducer() or useMemo()."));
        lastContextDependency = observedBits;
        currentlyRenderingFiber.dependencies = {
          expirationTime: 0,
          firstContext: observedBits,
          responders: null
        };
      } else lastContextDependency = lastContextDependency.next = observedBits;
    }

    return context._currentValue2;
  }

  var hasForceUpdate = !1;

  function createUpdateQueue(baseState) {
    return {
      baseState: baseState,
      firstUpdate: null,
      lastUpdate: null,
      firstCapturedUpdate: null,
      lastCapturedUpdate: null,
      firstEffect: null,
      lastEffect: null,
      firstCapturedEffect: null,
      lastCapturedEffect: null
    };
  }

  function cloneUpdateQueue(currentQueue) {
    return {
      baseState: currentQueue.baseState,
      firstUpdate: currentQueue.firstUpdate,
      lastUpdate: currentQueue.lastUpdate,
      firstCapturedUpdate: null,
      lastCapturedUpdate: null,
      firstEffect: null,
      lastEffect: null,
      firstCapturedEffect: null,
      lastCapturedEffect: null
    };
  }

  function createUpdate(expirationTime, suspenseConfig) {
    return {
      expirationTime: expirationTime,
      suspenseConfig: suspenseConfig,
      tag: 0,
      payload: null,
      callback: null,
      next: null,
      nextEffect: null
    };
  }

  function appendUpdateToQueue(queue, update) {
    null === queue.lastUpdate ? queue.firstUpdate = queue.lastUpdate = update : (queue.lastUpdate.next = update, queue.lastUpdate = update);
  }

  function enqueueUpdate(fiber, update) {
    var alternate = fiber.alternate;

    if (null === alternate) {
      var queue1 = fiber.updateQueue;
      var queue2 = null;
      null === queue1 && (queue1 = fiber.updateQueue = createUpdateQueue(fiber.memoizedState));
    } else queue1 = fiber.updateQueue, queue2 = alternate.updateQueue, null === queue1 ? null === queue2 ? (queue1 = fiber.updateQueue = createUpdateQueue(fiber.memoizedState), queue2 = alternate.updateQueue = createUpdateQueue(alternate.memoizedState)) : queue1 = fiber.updateQueue = cloneUpdateQueue(queue2) : null === queue2 && (queue2 = alternate.updateQueue = cloneUpdateQueue(queue1));

    null === queue2 || queue1 === queue2 ? appendUpdateToQueue(queue1, update) : null === queue1.lastUpdate || null === queue2.lastUpdate ? (appendUpdateToQueue(queue1, update), appendUpdateToQueue(queue2, update)) : (appendUpdateToQueue(queue1, update), queue2.lastUpdate = update);
  }

  function enqueueCapturedUpdate(workInProgress, update) {
    var workInProgressQueue = workInProgress.updateQueue;
    workInProgressQueue = null === workInProgressQueue ? workInProgress.updateQueue = createUpdateQueue(workInProgress.memoizedState) : ensureWorkInProgressQueueIsAClone(workInProgress, workInProgressQueue);
    null === workInProgressQueue.lastCapturedUpdate ? workInProgressQueue.firstCapturedUpdate = workInProgressQueue.lastCapturedUpdate = update : (workInProgressQueue.lastCapturedUpdate.next = update, workInProgressQueue.lastCapturedUpdate = update);
  }

  function ensureWorkInProgressQueueIsAClone(workInProgress, queue) {
    var current = workInProgress.alternate;
    null !== current && queue === current.updateQueue && (queue = workInProgress.updateQueue = cloneUpdateQueue(queue));
    return queue;
  }

  function getStateFromUpdate(workInProgress, queue, update, prevState, nextProps, instance) {
    switch (update.tag) {
      case 1:
        return workInProgress = update.payload, "function" === typeof workInProgress ? workInProgress.call(instance, prevState, nextProps) : workInProgress;

      case 3:
        workInProgress.effectTag = workInProgress.effectTag & -2049 | 64;

      case 0:
        workInProgress = update.payload;
        nextProps = "function" === typeof workInProgress ? workInProgress.call(instance, prevState, nextProps) : workInProgress;
        if (null === nextProps || void 0 === nextProps) break;
        return _extends({}, prevState, nextProps);

      case 2:
        hasForceUpdate = !0;
    }

    return prevState;
  }

  function processUpdateQueue(workInProgress, queue, props, instance, renderExpirationTime) {
    hasForceUpdate = !1;
    queue = ensureWorkInProgressQueueIsAClone(workInProgress, queue);

    for (var newBaseState = queue.baseState, newFirstUpdate = null, newExpirationTime = 0, update = queue.firstUpdate, resultState = newBaseState; null !== update;) {
      var updateExpirationTime = update.expirationTime;
      updateExpirationTime < renderExpirationTime ? (null === newFirstUpdate && (newFirstUpdate = update, newBaseState = resultState), newExpirationTime < updateExpirationTime && (newExpirationTime = updateExpirationTime)) : (markRenderEventTimeAndConfig(updateExpirationTime, update.suspenseConfig), resultState = getStateFromUpdate(workInProgress, queue, update, resultState, props, instance), null !== update.callback && (workInProgress.effectTag |= 32, update.nextEffect = null, null === queue.lastEffect ? queue.firstEffect = queue.lastEffect = update : (queue.lastEffect.nextEffect = update, queue.lastEffect = update)));
      update = update.next;
    }

    updateExpirationTime = null;

    for (update = queue.firstCapturedUpdate; null !== update;) {
      var _updateExpirationTime = update.expirationTime;
      _updateExpirationTime < renderExpirationTime ? (null === updateExpirationTime && (updateExpirationTime = update, null === newFirstUpdate && (newBaseState = resultState)), newExpirationTime < _updateExpirationTime && (newExpirationTime = _updateExpirationTime)) : (resultState = getStateFromUpdate(workInProgress, queue, update, resultState, props, instance), null !== update.callback && (workInProgress.effectTag |= 32, update.nextEffect = null, null === queue.lastCapturedEffect ? queue.firstCapturedEffect = queue.lastCapturedEffect = update : (queue.lastCapturedEffect.nextEffect = update, queue.lastCapturedEffect = update)));
      update = update.next;
    }

    null === newFirstUpdate && (queue.lastUpdate = null);
    null === updateExpirationTime ? queue.lastCapturedUpdate = null : workInProgress.effectTag |= 32;
    null === newFirstUpdate && null === updateExpirationTime && (newBaseState = resultState);
    queue.baseState = newBaseState;
    queue.firstUpdate = newFirstUpdate;
    queue.firstCapturedUpdate = updateExpirationTime;
    workInProgress.expirationTime = newExpirationTime;
    workInProgress.memoizedState = resultState;
  }

  function commitUpdateQueue(finishedWork, finishedQueue, instance) {
    null !== finishedQueue.firstCapturedUpdate && (null !== finishedQueue.lastUpdate && (finishedQueue.lastUpdate.next = finishedQueue.firstCapturedUpdate, finishedQueue.lastUpdate = finishedQueue.lastCapturedUpdate), finishedQueue.firstCapturedUpdate = finishedQueue.lastCapturedUpdate = null);
    commitUpdateEffects(finishedQueue.firstEffect, instance);
    finishedQueue.firstEffect = finishedQueue.lastEffect = null;
    commitUpdateEffects(finishedQueue.firstCapturedEffect, instance);
    finishedQueue.firstCapturedEffect = finishedQueue.lastCapturedEffect = null;
  }

  function commitUpdateEffects(effect, instance) {
    for (; null !== effect;) {
      var _callback3 = effect.callback;

      if (null !== _callback3) {
        effect.callback = null;
        var context = instance;
        if ("function" !== typeof _callback3) throw ReactError(Error("Invalid argument passed as callback. Expected a function. Instead received: " + _callback3));

        _callback3.call(context);
      }

      effect = effect.nextEffect;
    }
  }

  var ReactCurrentBatchConfig = ReactSharedInternals.ReactCurrentBatchConfig,
      emptyRefsObject = new React.Component().refs;

  function applyDerivedStateFromProps(workInProgress, ctor, getDerivedStateFromProps, nextProps) {
    ctor = workInProgress.memoizedState;
    getDerivedStateFromProps = getDerivedStateFromProps(nextProps, ctor);
    getDerivedStateFromProps = null === getDerivedStateFromProps || void 0 === getDerivedStateFromProps ? ctor : _extends({}, ctor, getDerivedStateFromProps);
    workInProgress.memoizedState = getDerivedStateFromProps;
    nextProps = workInProgress.updateQueue;
    null !== nextProps && 0 === workInProgress.expirationTime && (nextProps.baseState = getDerivedStateFromProps);
  }

  var classComponentUpdater = {
    isMounted: function isMounted(component) {
      return (component = component._reactInternalFiber) ? 2 === isFiberMountedImpl(component) : !1;
    },
    enqueueSetState: function enqueueSetState(inst, payload, callback) {
      inst = inst._reactInternalFiber;
      var currentTime = requestCurrentTime(),
          suspenseConfig = ReactCurrentBatchConfig.suspense;
      currentTime = computeExpirationForFiber(currentTime, inst, suspenseConfig);
      suspenseConfig = createUpdate(currentTime, suspenseConfig);
      suspenseConfig.payload = payload;
      void 0 !== callback && null !== callback && (suspenseConfig.callback = callback);
      enqueueUpdate(inst, suspenseConfig);
      scheduleUpdateOnFiber(inst, currentTime);
    },
    enqueueReplaceState: function enqueueReplaceState(inst, payload, callback) {
      inst = inst._reactInternalFiber;
      var currentTime = requestCurrentTime(),
          suspenseConfig = ReactCurrentBatchConfig.suspense;
      currentTime = computeExpirationForFiber(currentTime, inst, suspenseConfig);
      suspenseConfig = createUpdate(currentTime, suspenseConfig);
      suspenseConfig.tag = 1;
      suspenseConfig.payload = payload;
      void 0 !== callback && null !== callback && (suspenseConfig.callback = callback);
      enqueueUpdate(inst, suspenseConfig);
      scheduleUpdateOnFiber(inst, currentTime);
    },
    enqueueForceUpdate: function enqueueForceUpdate(inst, callback) {
      inst = inst._reactInternalFiber;
      var currentTime = requestCurrentTime(),
          suspenseConfig = ReactCurrentBatchConfig.suspense;
      currentTime = computeExpirationForFiber(currentTime, inst, suspenseConfig);
      suspenseConfig = createUpdate(currentTime, suspenseConfig);
      suspenseConfig.tag = 2;
      void 0 !== callback && null !== callback && (suspenseConfig.callback = callback);
      enqueueUpdate(inst, suspenseConfig);
      scheduleUpdateOnFiber(inst, currentTime);
    }
  };

  function checkShouldComponentUpdate(workInProgress, ctor, oldProps, newProps, oldState, newState, nextContext) {
    workInProgress = workInProgress.stateNode;
    return "function" === typeof workInProgress.shouldComponentUpdate ? workInProgress.shouldComponentUpdate(newProps, newState, nextContext) : ctor.prototype && ctor.prototype.isPureReactComponent ? !shallowEqual(oldProps, newProps) || !shallowEqual(oldState, newState) : !0;
  }

  function constructClassInstance(workInProgress, ctor, props) {
    var isLegacyContextConsumer = !1,
        unmaskedContext = emptyContextObject;
    var context = ctor.contextType;
    "object" === typeof context && null !== context ? context = readContext(context) : (unmaskedContext = isContextProvider(ctor) ? previousContext : contextStackCursor.current, isLegacyContextConsumer = ctor.contextTypes, context = (isLegacyContextConsumer = null !== isLegacyContextConsumer && void 0 !== isLegacyContextConsumer) ? getMaskedContext(workInProgress, unmaskedContext) : emptyContextObject);
    ctor = new ctor(props, context);
    workInProgress.memoizedState = null !== ctor.state && void 0 !== ctor.state ? ctor.state : null;
    ctor.updater = classComponentUpdater;
    workInProgress.stateNode = ctor;
    ctor._reactInternalFiber = workInProgress;
    isLegacyContextConsumer && (workInProgress = workInProgress.stateNode, workInProgress.__reactInternalMemoizedUnmaskedChildContext = unmaskedContext, workInProgress.__reactInternalMemoizedMaskedChildContext = context);
    return ctor;
  }

  function callComponentWillReceiveProps(workInProgress, instance, newProps, nextContext) {
    workInProgress = instance.state;
    "function" === typeof instance.componentWillReceiveProps && instance.componentWillReceiveProps(newProps, nextContext);
    "function" === typeof instance.UNSAFE_componentWillReceiveProps && instance.UNSAFE_componentWillReceiveProps(newProps, nextContext);
    instance.state !== workInProgress && classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
  }

  function mountClassInstance(workInProgress, ctor, newProps, renderExpirationTime) {
    var instance = workInProgress.stateNode;
    instance.props = newProps;
    instance.state = workInProgress.memoizedState;
    instance.refs = emptyRefsObject;
    var contextType = ctor.contextType;
    "object" === typeof contextType && null !== contextType ? instance.context = readContext(contextType) : (contextType = isContextProvider(ctor) ? previousContext : contextStackCursor.current, instance.context = getMaskedContext(workInProgress, contextType));
    contextType = workInProgress.updateQueue;
    null !== contextType && (processUpdateQueue(workInProgress, contextType, newProps, instance, renderExpirationTime), instance.state = workInProgress.memoizedState);
    contextType = ctor.getDerivedStateFromProps;
    "function" === typeof contextType && (applyDerivedStateFromProps(workInProgress, ctor, contextType, newProps), instance.state = workInProgress.memoizedState);
    "function" === typeof ctor.getDerivedStateFromProps || "function" === typeof instance.getSnapshotBeforeUpdate || "function" !== typeof instance.UNSAFE_componentWillMount && "function" !== typeof instance.componentWillMount || (ctor = instance.state, "function" === typeof instance.componentWillMount && instance.componentWillMount(), "function" === typeof instance.UNSAFE_componentWillMount && instance.UNSAFE_componentWillMount(), ctor !== instance.state && classComponentUpdater.enqueueReplaceState(instance, instance.state, null), contextType = workInProgress.updateQueue, null !== contextType && (processUpdateQueue(workInProgress, contextType, newProps, instance, renderExpirationTime), instance.state = workInProgress.memoizedState));
    "function" === typeof instance.componentDidMount && (workInProgress.effectTag |= 4);
  }

  var isArray = Array.isArray;

  function coerceRef(returnFiber, current$$1, element) {
    returnFiber = element.ref;

    if (null !== returnFiber && "function" !== typeof returnFiber && "object" !== typeof returnFiber) {
      if (element._owner) {
        element = element._owner;
        var inst = void 0;

        if (element) {
          if (1 !== element.tag) throw ReactError(Error("Function components cannot have refs. Did you mean to use React.forwardRef()?"));
          inst = element.stateNode;
        }

        if (!inst) throw ReactError(Error("Missing owner for string ref " + returnFiber + ". This error is likely caused by a bug in React. Please file an issue."));
        var stringRef = "" + returnFiber;
        if (null !== current$$1 && null !== current$$1.ref && "function" === typeof current$$1.ref && current$$1.ref._stringRef === stringRef) return current$$1.ref;

        current$$1 = function current$$1(value) {
          var refs = inst.refs;
          refs === emptyRefsObject && (refs = inst.refs = {});
          null === value ? delete refs[stringRef] : refs[stringRef] = value;
        };

        current$$1._stringRef = stringRef;
        return current$$1;
      }

      if ("string" !== typeof returnFiber) throw ReactError(Error("Expected ref to be a function, a string, an object returned by React.createRef(), or null."));
      if (!element._owner) throw ReactError(Error("Element ref was specified as a string (" + returnFiber + ") but no owner was set. This could happen for one of the following reasons:\n1. You may be adding a ref to a function component\n2. You may be adding a ref to a component that was not created inside a component's render method\n3. You have multiple copies of React loaded\nSee https://fb.me/react-refs-must-have-owner for more information."));
    }

    return returnFiber;
  }

  function throwOnInvalidObjectType(returnFiber, newChild) {
    if ("textarea" !== returnFiber.type) throw ReactError(Error("Objects are not valid as a React child (found: " + ("[object Object]" === Object.prototype.toString.call(newChild) ? "object with keys {" + Object.keys(newChild).join(", ") + "}" : newChild) + ")."));
  }

  function ChildReconciler(shouldTrackSideEffects) {
    function deleteChild(returnFiber, childToDelete) {
      if (shouldTrackSideEffects) {
        var last = returnFiber.lastEffect;
        null !== last ? (last.nextEffect = childToDelete, returnFiber.lastEffect = childToDelete) : returnFiber.firstEffect = returnFiber.lastEffect = childToDelete;
        childToDelete.nextEffect = null;
        childToDelete.effectTag = 8;
      }
    }

    function deleteRemainingChildren(returnFiber, currentFirstChild) {
      if (!shouldTrackSideEffects) return null;

      for (; null !== currentFirstChild;) {
        deleteChild(returnFiber, currentFirstChild), currentFirstChild = currentFirstChild.sibling;
      }

      return null;
    }

    function mapRemainingChildren(returnFiber, currentFirstChild) {
      for (returnFiber = new Map(); null !== currentFirstChild;) {
        null !== currentFirstChild.key ? returnFiber.set(currentFirstChild.key, currentFirstChild) : returnFiber.set(currentFirstChild.index, currentFirstChild), currentFirstChild = currentFirstChild.sibling;
      }

      return returnFiber;
    }

    function useFiber(fiber, pendingProps, expirationTime) {
      fiber = createWorkInProgress(fiber, pendingProps, expirationTime);
      fiber.index = 0;
      fiber.sibling = null;
      return fiber;
    }

    function placeChild(newFiber, lastPlacedIndex, newIndex) {
      newFiber.index = newIndex;
      if (!shouldTrackSideEffects) return lastPlacedIndex;
      newIndex = newFiber.alternate;
      if (null !== newIndex) return newIndex = newIndex.index, newIndex < lastPlacedIndex ? (newFiber.effectTag = 2, lastPlacedIndex) : newIndex;
      newFiber.effectTag = 2;
      return lastPlacedIndex;
    }

    function placeSingleChild(newFiber) {
      shouldTrackSideEffects && null === newFiber.alternate && (newFiber.effectTag = 2);
      return newFiber;
    }

    function updateTextNode(returnFiber, current$$1, textContent, expirationTime) {
      if (null === current$$1 || 6 !== current$$1.tag) return current$$1 = createFiberFromText(textContent, returnFiber.mode, expirationTime), current$$1.return = returnFiber, current$$1;
      current$$1 = useFiber(current$$1, textContent, expirationTime);
      current$$1.return = returnFiber;
      return current$$1;
    }

    function updateElement(returnFiber, current$$1, element, expirationTime) {
      if (null !== current$$1 && current$$1.elementType === element.type) return expirationTime = useFiber(current$$1, element.props, expirationTime), expirationTime.ref = coerceRef(returnFiber, current$$1, element), expirationTime.return = returnFiber, expirationTime;
      expirationTime = createFiberFromTypeAndProps(element.type, element.key, element.props, null, returnFiber.mode, expirationTime);
      expirationTime.ref = coerceRef(returnFiber, current$$1, element);
      expirationTime.return = returnFiber;
      return expirationTime;
    }

    function updatePortal(returnFiber, current$$1, portal, expirationTime) {
      if (null === current$$1 || 4 !== current$$1.tag || current$$1.stateNode.containerInfo !== portal.containerInfo || current$$1.stateNode.implementation !== portal.implementation) return current$$1 = createFiberFromPortal(portal, returnFiber.mode, expirationTime), current$$1.return = returnFiber, current$$1;
      current$$1 = useFiber(current$$1, portal.children || [], expirationTime);
      current$$1.return = returnFiber;
      return current$$1;
    }

    function updateFragment(returnFiber, current$$1, fragment, expirationTime, key) {
      if (null === current$$1 || 7 !== current$$1.tag) return current$$1 = createFiberFromFragment(fragment, returnFiber.mode, expirationTime, key), current$$1.return = returnFiber, current$$1;
      current$$1 = useFiber(current$$1, fragment, expirationTime);
      current$$1.return = returnFiber;
      return current$$1;
    }

    function createChild(returnFiber, newChild, expirationTime) {
      if ("string" === typeof newChild || "number" === typeof newChild) return newChild = createFiberFromText("" + newChild, returnFiber.mode, expirationTime), newChild.return = returnFiber, newChild;

      if ("object" === typeof newChild && null !== newChild) {
        switch (newChild.$$typeof) {
          case REACT_ELEMENT_TYPE:
            return expirationTime = createFiberFromTypeAndProps(newChild.type, newChild.key, newChild.props, null, returnFiber.mode, expirationTime), expirationTime.ref = coerceRef(returnFiber, null, newChild), expirationTime.return = returnFiber, expirationTime;

          case REACT_PORTAL_TYPE:
            return newChild = createFiberFromPortal(newChild, returnFiber.mode, expirationTime), newChild.return = returnFiber, newChild;
        }

        if (isArray(newChild) || getIteratorFn(newChild)) return newChild = createFiberFromFragment(newChild, returnFiber.mode, expirationTime, null), newChild.return = returnFiber, newChild;
        throwOnInvalidObjectType(returnFiber, newChild);
      }

      return null;
    }

    function updateSlot(returnFiber, oldFiber, newChild, expirationTime) {
      var key = null !== oldFiber ? oldFiber.key : null;
      if ("string" === typeof newChild || "number" === typeof newChild) return null !== key ? null : updateTextNode(returnFiber, oldFiber, "" + newChild, expirationTime);

      if ("object" === typeof newChild && null !== newChild) {
        switch (newChild.$$typeof) {
          case REACT_ELEMENT_TYPE:
            return newChild.key === key ? newChild.type === REACT_FRAGMENT_TYPE ? updateFragment(returnFiber, oldFiber, newChild.props.children, expirationTime, key) : updateElement(returnFiber, oldFiber, newChild, expirationTime) : null;

          case REACT_PORTAL_TYPE:
            return newChild.key === key ? updatePortal(returnFiber, oldFiber, newChild, expirationTime) : null;
        }

        if (isArray(newChild) || getIteratorFn(newChild)) return null !== key ? null : updateFragment(returnFiber, oldFiber, newChild, expirationTime, null);
        throwOnInvalidObjectType(returnFiber, newChild);
      }

      return null;
    }

    function updateFromMap(existingChildren, returnFiber, newIdx, newChild, expirationTime) {
      if ("string" === typeof newChild || "number" === typeof newChild) return existingChildren = existingChildren.get(newIdx) || null, updateTextNode(returnFiber, existingChildren, "" + newChild, expirationTime);

      if ("object" === typeof newChild && null !== newChild) {
        switch (newChild.$$typeof) {
          case REACT_ELEMENT_TYPE:
            return existingChildren = existingChildren.get(null === newChild.key ? newIdx : newChild.key) || null, newChild.type === REACT_FRAGMENT_TYPE ? updateFragment(returnFiber, existingChildren, newChild.props.children, expirationTime, newChild.key) : updateElement(returnFiber, existingChildren, newChild, expirationTime);

          case REACT_PORTAL_TYPE:
            return existingChildren = existingChildren.get(null === newChild.key ? newIdx : newChild.key) || null, updatePortal(returnFiber, existingChildren, newChild, expirationTime);
        }

        if (isArray(newChild) || getIteratorFn(newChild)) return existingChildren = existingChildren.get(newIdx) || null, updateFragment(returnFiber, existingChildren, newChild, expirationTime, null);
        throwOnInvalidObjectType(returnFiber, newChild);
      }

      return null;
    }

    function reconcileChildrenArray(returnFiber, currentFirstChild, newChildren, expirationTime) {
      for (var resultingFirstChild = null, previousNewFiber = null, oldFiber = currentFirstChild, newIdx = currentFirstChild = 0, nextOldFiber = null; null !== oldFiber && newIdx < newChildren.length; newIdx++) {
        oldFiber.index > newIdx ? (nextOldFiber = oldFiber, oldFiber = null) : nextOldFiber = oldFiber.sibling;
        var newFiber = updateSlot(returnFiber, oldFiber, newChildren[newIdx], expirationTime);

        if (null === newFiber) {
          null === oldFiber && (oldFiber = nextOldFiber);
          break;
        }

        shouldTrackSideEffects && oldFiber && null === newFiber.alternate && deleteChild(returnFiber, oldFiber);
        currentFirstChild = placeChild(newFiber, currentFirstChild, newIdx);
        null === previousNewFiber ? resultingFirstChild = newFiber : previousNewFiber.sibling = newFiber;
        previousNewFiber = newFiber;
        oldFiber = nextOldFiber;
      }

      if (newIdx === newChildren.length) return deleteRemainingChildren(returnFiber, oldFiber), resultingFirstChild;

      if (null === oldFiber) {
        for (; newIdx < newChildren.length; newIdx++) {
          oldFiber = createChild(returnFiber, newChildren[newIdx], expirationTime), null !== oldFiber && (currentFirstChild = placeChild(oldFiber, currentFirstChild, newIdx), null === previousNewFiber ? resultingFirstChild = oldFiber : previousNewFiber.sibling = oldFiber, previousNewFiber = oldFiber);
        }

        return resultingFirstChild;
      }

      for (oldFiber = mapRemainingChildren(returnFiber, oldFiber); newIdx < newChildren.length; newIdx++) {
        nextOldFiber = updateFromMap(oldFiber, returnFiber, newIdx, newChildren[newIdx], expirationTime), null !== nextOldFiber && (shouldTrackSideEffects && null !== nextOldFiber.alternate && oldFiber.delete(null === nextOldFiber.key ? newIdx : nextOldFiber.key), currentFirstChild = placeChild(nextOldFiber, currentFirstChild, newIdx), null === previousNewFiber ? resultingFirstChild = nextOldFiber : previousNewFiber.sibling = nextOldFiber, previousNewFiber = nextOldFiber);
      }

      shouldTrackSideEffects && oldFiber.forEach(function (child) {
        return deleteChild(returnFiber, child);
      });
      return resultingFirstChild;
    }

    function reconcileChildrenIterator(returnFiber, currentFirstChild, newChildrenIterable, expirationTime) {
      var iteratorFn = getIteratorFn(newChildrenIterable);
      if ("function" !== typeof iteratorFn) throw ReactError(Error("An object is not an iterable. This error is likely caused by a bug in React. Please file an issue."));
      newChildrenIterable = iteratorFn.call(newChildrenIterable);
      if (null == newChildrenIterable) throw ReactError(Error("An iterable object provided no iterator."));

      for (var previousNewFiber = iteratorFn = null, oldFiber = currentFirstChild, newIdx = currentFirstChild = 0, nextOldFiber = null, step = newChildrenIterable.next(); null !== oldFiber && !step.done; newIdx++, step = newChildrenIterable.next()) {
        oldFiber.index > newIdx ? (nextOldFiber = oldFiber, oldFiber = null) : nextOldFiber = oldFiber.sibling;
        var newFiber = updateSlot(returnFiber, oldFiber, step.value, expirationTime);

        if (null === newFiber) {
          null === oldFiber && (oldFiber = nextOldFiber);
          break;
        }

        shouldTrackSideEffects && oldFiber && null === newFiber.alternate && deleteChild(returnFiber, oldFiber);
        currentFirstChild = placeChild(newFiber, currentFirstChild, newIdx);
        null === previousNewFiber ? iteratorFn = newFiber : previousNewFiber.sibling = newFiber;
        previousNewFiber = newFiber;
        oldFiber = nextOldFiber;
      }

      if (step.done) return deleteRemainingChildren(returnFiber, oldFiber), iteratorFn;

      if (null === oldFiber) {
        for (; !step.done; newIdx++, step = newChildrenIterable.next()) {
          step = createChild(returnFiber, step.value, expirationTime), null !== step && (currentFirstChild = placeChild(step, currentFirstChild, newIdx), null === previousNewFiber ? iteratorFn = step : previousNewFiber.sibling = step, previousNewFiber = step);
        }

        return iteratorFn;
      }

      for (oldFiber = mapRemainingChildren(returnFiber, oldFiber); !step.done; newIdx++, step = newChildrenIterable.next()) {
        step = updateFromMap(oldFiber, returnFiber, newIdx, step.value, expirationTime), null !== step && (shouldTrackSideEffects && null !== step.alternate && oldFiber.delete(null === step.key ? newIdx : step.key), currentFirstChild = placeChild(step, currentFirstChild, newIdx), null === previousNewFiber ? iteratorFn = step : previousNewFiber.sibling = step, previousNewFiber = step);
      }

      shouldTrackSideEffects && oldFiber.forEach(function (child) {
        return deleteChild(returnFiber, child);
      });
      return iteratorFn;
    }

    return function (returnFiber, currentFirstChild, newChild, expirationTime) {
      var isUnkeyedTopLevelFragment = "object" === typeof newChild && null !== newChild && newChild.type === REACT_FRAGMENT_TYPE && null === newChild.key;
      isUnkeyedTopLevelFragment && (newChild = newChild.props.children);
      var isObject = "object" === typeof newChild && null !== newChild;
      if (isObject) switch (newChild.$$typeof) {
        case REACT_ELEMENT_TYPE:
          a: {
            isObject = newChild.key;

            for (isUnkeyedTopLevelFragment = currentFirstChild; null !== isUnkeyedTopLevelFragment;) {
              if (isUnkeyedTopLevelFragment.key === isObject) {
                if (7 === isUnkeyedTopLevelFragment.tag ? newChild.type === REACT_FRAGMENT_TYPE : isUnkeyedTopLevelFragment.elementType === newChild.type) {
                  deleteRemainingChildren(returnFiber, isUnkeyedTopLevelFragment.sibling);
                  currentFirstChild = useFiber(isUnkeyedTopLevelFragment, newChild.type === REACT_FRAGMENT_TYPE ? newChild.props.children : newChild.props, expirationTime);
                  currentFirstChild.ref = coerceRef(returnFiber, isUnkeyedTopLevelFragment, newChild);
                  currentFirstChild.return = returnFiber;
                  returnFiber = currentFirstChild;
                  break a;
                }

                deleteRemainingChildren(returnFiber, isUnkeyedTopLevelFragment);
                break;
              } else deleteChild(returnFiber, isUnkeyedTopLevelFragment);

              isUnkeyedTopLevelFragment = isUnkeyedTopLevelFragment.sibling;
            }

            newChild.type === REACT_FRAGMENT_TYPE ? (currentFirstChild = createFiberFromFragment(newChild.props.children, returnFiber.mode, expirationTime, newChild.key), currentFirstChild.return = returnFiber, returnFiber = currentFirstChild) : (expirationTime = createFiberFromTypeAndProps(newChild.type, newChild.key, newChild.props, null, returnFiber.mode, expirationTime), expirationTime.ref = coerceRef(returnFiber, currentFirstChild, newChild), expirationTime.return = returnFiber, returnFiber = expirationTime);
          }

          return placeSingleChild(returnFiber);

        case REACT_PORTAL_TYPE:
          a: {
            for (isUnkeyedTopLevelFragment = newChild.key; null !== currentFirstChild;) {
              if (currentFirstChild.key === isUnkeyedTopLevelFragment) {
                if (4 === currentFirstChild.tag && currentFirstChild.stateNode.containerInfo === newChild.containerInfo && currentFirstChild.stateNode.implementation === newChild.implementation) {
                  deleteRemainingChildren(returnFiber, currentFirstChild.sibling);
                  currentFirstChild = useFiber(currentFirstChild, newChild.children || [], expirationTime);
                  currentFirstChild.return = returnFiber;
                  returnFiber = currentFirstChild;
                  break a;
                }

                deleteRemainingChildren(returnFiber, currentFirstChild);
                break;
              } else deleteChild(returnFiber, currentFirstChild);

              currentFirstChild = currentFirstChild.sibling;
            }

            currentFirstChild = createFiberFromPortal(newChild, returnFiber.mode, expirationTime);
            currentFirstChild.return = returnFiber;
            returnFiber = currentFirstChild;
          }

          return placeSingleChild(returnFiber);
      }
      if ("string" === typeof newChild || "number" === typeof newChild) return newChild = "" + newChild, null !== currentFirstChild && 6 === currentFirstChild.tag ? (deleteRemainingChildren(returnFiber, currentFirstChild.sibling), currentFirstChild = useFiber(currentFirstChild, newChild, expirationTime), currentFirstChild.return = returnFiber, returnFiber = currentFirstChild) : (deleteRemainingChildren(returnFiber, currentFirstChild), currentFirstChild = createFiberFromText(newChild, returnFiber.mode, expirationTime), currentFirstChild.return = returnFiber, returnFiber = currentFirstChild), placeSingleChild(returnFiber);
      if (isArray(newChild)) return reconcileChildrenArray(returnFiber, currentFirstChild, newChild, expirationTime);
      if (getIteratorFn(newChild)) return reconcileChildrenIterator(returnFiber, currentFirstChild, newChild, expirationTime);
      isObject && throwOnInvalidObjectType(returnFiber, newChild);
      if ("undefined" === typeof newChild && !isUnkeyedTopLevelFragment) switch (returnFiber.tag) {
        case 1:
        case 0:
          throw returnFiber = returnFiber.type, ReactError(Error((returnFiber.displayName || returnFiber.name || "Component") + "(...): Nothing was returned from render. This usually means a return statement is missing. Or, to render nothing, return null."));
      }
      return deleteRemainingChildren(returnFiber, currentFirstChild);
    };
  }

  var reconcileChildFibers = ChildReconciler(!0),
      mountChildFibers = ChildReconciler(!1),
      NO_CONTEXT = {},
      contextStackCursor$1 = {
    current: NO_CONTEXT
  },
      contextFiberStackCursor = {
    current: NO_CONTEXT
  },
      rootInstanceStackCursor = {
    current: NO_CONTEXT
  };

  function requiredContext(c) {
    if (c === NO_CONTEXT) throw ReactError(Error("Expected host context to exist. This error is likely caused by a bug in React. Please file an issue."));
    return c;
  }

  function pushHostContainer(fiber, nextRootInstance) {
    push(rootInstanceStackCursor, nextRootInstance, fiber);
    push(contextFiberStackCursor, fiber, fiber);
    push(contextStackCursor$1, NO_CONTEXT, fiber);
    pop(contextStackCursor$1, fiber);
    push(contextStackCursor$1, {
      isInAParentText: !1
    }, fiber);
  }

  function popHostContainer(fiber) {
    pop(contextStackCursor$1, fiber);
    pop(contextFiberStackCursor, fiber);
    pop(rootInstanceStackCursor, fiber);
  }

  function pushHostContext(fiber) {
    requiredContext(rootInstanceStackCursor.current);
    var context = requiredContext(contextStackCursor$1.current);
    var nextContext = fiber.type;
    nextContext = "AndroidTextInput" === nextContext || "RCTMultilineTextInputView" === nextContext || "RCTSinglelineTextInputView" === nextContext || "RCTText" === nextContext || "RCTVirtualText" === nextContext;
    nextContext = context.isInAParentText !== nextContext ? {
      isInAParentText: nextContext
    } : context;
    context !== nextContext && (push(contextFiberStackCursor, fiber, fiber), push(contextStackCursor$1, nextContext, fiber));
  }

  function popHostContext(fiber) {
    contextFiberStackCursor.current === fiber && (pop(contextStackCursor$1, fiber), pop(contextFiberStackCursor, fiber));
  }

  var SubtreeSuspenseContextMask = 1,
      InvisibleParentSuspenseContext = 1,
      ForceSuspenseFallback = 2,
      suspenseStackCursor = {
    current: 0
  };

  function findFirstSuspended(row) {
    for (var node = row; null !== node;) {
      if (13 === node.tag) {
        if (null !== node.memoizedState) return node;
      } else if (19 === node.tag && void 0 !== node.memoizedProps.revealOrder) {
        if (0 !== (node.effectTag & 64)) return node;
      } else if (null !== node.child) {
        node.child.return = node;
        node = node.child;
        continue;
      }

      if (node === row) break;

      for (; null === node.sibling;) {
        if (null === node.return || node.return === row) return null;
        node = node.return;
      }

      node.sibling.return = node.return;
      node = node.sibling;
    }

    return null;
  }

  function createResponderListener(responder, props) {
    return {
      responder: responder,
      props: props
    };
  }

  var NoEffect$1 = 0,
      UnmountSnapshot = 2,
      UnmountMutation = 4,
      MountMutation = 8,
      UnmountLayout = 16,
      MountLayout = 32,
      MountPassive = 64,
      UnmountPassive = 128,
      ReactCurrentDispatcher$1 = ReactSharedInternals.ReactCurrentDispatcher,
      renderExpirationTime$1 = 0,
      currentlyRenderingFiber$1 = null,
      currentHook = null,
      nextCurrentHook = null,
      firstWorkInProgressHook = null,
      workInProgressHook = null,
      nextWorkInProgressHook = null,
      remainingExpirationTime = 0,
      componentUpdateQueue = null,
      sideEffectTag = 0,
      didScheduleRenderPhaseUpdate = !1,
      renderPhaseUpdates = null,
      numberOfReRenders = 0;

  function throwInvalidHookError() {
    throw ReactError(Error("Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of the following reasons:\n1. You might have mismatching versions of React and the renderer (such as React DOM)\n2. You might be breaking the Rules of Hooks\n3. You might have more than one copy of React in the same app\nSee https://fb.me/react-invalid-hook-call for tips about how to debug and fix this problem."));
  }

  function areHookInputsEqual(nextDeps, prevDeps) {
    if (null === prevDeps) return !1;

    for (var i = 0; i < prevDeps.length && i < nextDeps.length; i++) {
      if (!is(nextDeps[i], prevDeps[i])) return !1;
    }

    return !0;
  }

  function renderWithHooks(current, workInProgress, Component, props, refOrContext, nextRenderExpirationTime) {
    renderExpirationTime$1 = nextRenderExpirationTime;
    currentlyRenderingFiber$1 = workInProgress;
    nextCurrentHook = null !== current ? current.memoizedState : null;
    ReactCurrentDispatcher$1.current = null === nextCurrentHook ? HooksDispatcherOnMount : HooksDispatcherOnUpdate;
    workInProgress = Component(props, refOrContext);

    if (didScheduleRenderPhaseUpdate) {
      do {
        didScheduleRenderPhaseUpdate = !1, numberOfReRenders += 1, nextCurrentHook = null !== current ? current.memoizedState : null, nextWorkInProgressHook = firstWorkInProgressHook, componentUpdateQueue = workInProgressHook = currentHook = null, ReactCurrentDispatcher$1.current = HooksDispatcherOnUpdate, workInProgress = Component(props, refOrContext);
      } while (didScheduleRenderPhaseUpdate);

      renderPhaseUpdates = null;
      numberOfReRenders = 0;
    }

    ReactCurrentDispatcher$1.current = ContextOnlyDispatcher;
    current = currentlyRenderingFiber$1;
    current.memoizedState = firstWorkInProgressHook;
    current.expirationTime = remainingExpirationTime;
    current.updateQueue = componentUpdateQueue;
    current.effectTag |= sideEffectTag;
    current = null !== currentHook && null !== currentHook.next;
    renderExpirationTime$1 = 0;
    nextWorkInProgressHook = workInProgressHook = firstWorkInProgressHook = nextCurrentHook = currentHook = currentlyRenderingFiber$1 = null;
    remainingExpirationTime = 0;
    componentUpdateQueue = null;
    sideEffectTag = 0;
    if (current) throw ReactError(Error("Rendered fewer hooks than expected. This may be caused by an accidental early return statement."));
    return workInProgress;
  }

  function resetHooks() {
    ReactCurrentDispatcher$1.current = ContextOnlyDispatcher;
    renderExpirationTime$1 = 0;
    nextWorkInProgressHook = workInProgressHook = firstWorkInProgressHook = nextCurrentHook = currentHook = currentlyRenderingFiber$1 = null;
    remainingExpirationTime = 0;
    componentUpdateQueue = null;
    sideEffectTag = 0;
    didScheduleRenderPhaseUpdate = !1;
    renderPhaseUpdates = null;
    numberOfReRenders = 0;
  }

  function mountWorkInProgressHook() {
    var hook = {
      memoizedState: null,
      baseState: null,
      queue: null,
      baseUpdate: null,
      next: null
    };
    null === workInProgressHook ? firstWorkInProgressHook = workInProgressHook = hook : workInProgressHook = workInProgressHook.next = hook;
    return workInProgressHook;
  }

  function updateWorkInProgressHook() {
    if (null !== nextWorkInProgressHook) workInProgressHook = nextWorkInProgressHook, nextWorkInProgressHook = workInProgressHook.next, currentHook = nextCurrentHook, nextCurrentHook = null !== currentHook ? currentHook.next : null;else {
      if (null === nextCurrentHook) throw ReactError(Error("Rendered more hooks than during the previous render."));
      currentHook = nextCurrentHook;
      var newHook = {
        memoizedState: currentHook.memoizedState,
        baseState: currentHook.baseState,
        queue: currentHook.queue,
        baseUpdate: currentHook.baseUpdate,
        next: null
      };
      workInProgressHook = null === workInProgressHook ? firstWorkInProgressHook = newHook : workInProgressHook.next = newHook;
      nextCurrentHook = currentHook.next;
    }
    return workInProgressHook;
  }

  function basicStateReducer(state, action) {
    return "function" === typeof action ? action(state) : action;
  }

  function updateReducer(reducer) {
    var hook = updateWorkInProgressHook(),
        queue = hook.queue;
    if (null === queue) throw ReactError(Error("Should have a queue. This is likely a bug in React. Please file an issue."));
    queue.lastRenderedReducer = reducer;

    if (0 < numberOfReRenders) {
      var _dispatch = queue.dispatch;

      if (null !== renderPhaseUpdates) {
        var firstRenderPhaseUpdate = renderPhaseUpdates.get(queue);

        if (void 0 !== firstRenderPhaseUpdate) {
          renderPhaseUpdates.delete(queue);
          var newState = hook.memoizedState;

          do {
            newState = reducer(newState, firstRenderPhaseUpdate.action), firstRenderPhaseUpdate = firstRenderPhaseUpdate.next;
          } while (null !== firstRenderPhaseUpdate);

          is(newState, hook.memoizedState) || (didReceiveUpdate = !0);
          hook.memoizedState = newState;
          hook.baseUpdate === queue.last && (hook.baseState = newState);
          queue.lastRenderedState = newState;
          return [newState, _dispatch];
        }
      }

      return [hook.memoizedState, _dispatch];
    }

    _dispatch = queue.last;
    var baseUpdate = hook.baseUpdate;
    newState = hook.baseState;
    null !== baseUpdate ? (null !== _dispatch && (_dispatch.next = null), _dispatch = baseUpdate.next) : _dispatch = null !== _dispatch ? _dispatch.next : null;

    if (null !== _dispatch) {
      var newBaseUpdate = firstRenderPhaseUpdate = null,
          _update = _dispatch,
          didSkip = !1;

      do {
        var updateExpirationTime = _update.expirationTime;
        updateExpirationTime < renderExpirationTime$1 ? (didSkip || (didSkip = !0, newBaseUpdate = baseUpdate, firstRenderPhaseUpdate = newState), updateExpirationTime > remainingExpirationTime && (remainingExpirationTime = updateExpirationTime)) : (markRenderEventTimeAndConfig(updateExpirationTime, _update.suspenseConfig), newState = _update.eagerReducer === reducer ? _update.eagerState : reducer(newState, _update.action));
        baseUpdate = _update;
        _update = _update.next;
      } while (null !== _update && _update !== _dispatch);

      didSkip || (newBaseUpdate = baseUpdate, firstRenderPhaseUpdate = newState);
      is(newState, hook.memoizedState) || (didReceiveUpdate = !0);
      hook.memoizedState = newState;
      hook.baseUpdate = newBaseUpdate;
      hook.baseState = firstRenderPhaseUpdate;
      queue.lastRenderedState = newState;
    }

    return [hook.memoizedState, queue.dispatch];
  }

  function pushEffect(tag, create, destroy, deps) {
    tag = {
      tag: tag,
      create: create,
      destroy: destroy,
      deps: deps,
      next: null
    };
    null === componentUpdateQueue ? (componentUpdateQueue = {
      lastEffect: null
    }, componentUpdateQueue.lastEffect = tag.next = tag) : (create = componentUpdateQueue.lastEffect, null === create ? componentUpdateQueue.lastEffect = tag.next = tag : (destroy = create.next, create.next = tag, tag.next = destroy, componentUpdateQueue.lastEffect = tag));
    return tag;
  }

  function mountEffectImpl(fiberEffectTag, hookEffectTag, create, deps) {
    var hook = mountWorkInProgressHook();
    sideEffectTag |= fiberEffectTag;
    hook.memoizedState = pushEffect(hookEffectTag, create, void 0, void 0 === deps ? null : deps);
  }

  function updateEffectImpl(fiberEffectTag, hookEffectTag, create, deps) {
    var hook = updateWorkInProgressHook();
    deps = void 0 === deps ? null : deps;
    var destroy = void 0;

    if (null !== currentHook) {
      var prevEffect = currentHook.memoizedState;
      destroy = prevEffect.destroy;

      if (null !== deps && areHookInputsEqual(deps, prevEffect.deps)) {
        pushEffect(NoEffect$1, create, destroy, deps);
        return;
      }
    }

    sideEffectTag |= fiberEffectTag;
    hook.memoizedState = pushEffect(hookEffectTag, create, destroy, deps);
  }

  function imperativeHandleEffect(create, ref) {
    if ("function" === typeof ref) return create = create(), ref(create), function () {
      ref(null);
    };
    if (null !== ref && void 0 !== ref) return create = create(), ref.current = create, function () {
      ref.current = null;
    };
  }

  function mountDebugValue() {}

  function dispatchAction(fiber, queue, action) {
    if (!(25 > numberOfReRenders)) throw ReactError(Error("Too many re-renders. React limits the number of renders to prevent an infinite loop."));
    var alternate = fiber.alternate;
    if (fiber === currentlyRenderingFiber$1 || null !== alternate && alternate === currentlyRenderingFiber$1) {
      if (didScheduleRenderPhaseUpdate = !0, fiber = {
        expirationTime: renderExpirationTime$1,
        suspenseConfig: null,
        action: action,
        eagerReducer: null,
        eagerState: null,
        next: null
      }, null === renderPhaseUpdates && (renderPhaseUpdates = new Map()), action = renderPhaseUpdates.get(queue), void 0 === action) renderPhaseUpdates.set(queue, fiber);else {
        for (queue = action; null !== queue.next;) {
          queue = queue.next;
        }

        queue.next = fiber;
      }
    } else {
      var currentTime = requestCurrentTime(),
          _suspenseConfig = ReactCurrentBatchConfig.suspense;
      currentTime = computeExpirationForFiber(currentTime, fiber, _suspenseConfig);
      _suspenseConfig = {
        expirationTime: currentTime,
        suspenseConfig: _suspenseConfig,
        action: action,
        eagerReducer: null,
        eagerState: null,
        next: null
      };
      var _last = queue.last;
      if (null === _last) _suspenseConfig.next = _suspenseConfig;else {
        var first = _last.next;
        null !== first && (_suspenseConfig.next = first);
        _last.next = _suspenseConfig;
      }
      queue.last = _suspenseConfig;
      if (0 === fiber.expirationTime && (null === alternate || 0 === alternate.expirationTime) && (alternate = queue.lastRenderedReducer, null !== alternate)) try {
        var currentState = queue.lastRenderedState,
            _eagerState = alternate(currentState, action);

        _suspenseConfig.eagerReducer = alternate;
        _suspenseConfig.eagerState = _eagerState;
        if (is(_eagerState, currentState)) return;
      } catch (error) {} finally {}
      scheduleUpdateOnFiber(fiber, currentTime);
    }
  }

  var ContextOnlyDispatcher = {
    readContext: readContext,
    useCallback: throwInvalidHookError,
    useContext: throwInvalidHookError,
    useEffect: throwInvalidHookError,
    useImperativeHandle: throwInvalidHookError,
    useLayoutEffect: throwInvalidHookError,
    useMemo: throwInvalidHookError,
    useReducer: throwInvalidHookError,
    useRef: throwInvalidHookError,
    useState: throwInvalidHookError,
    useDebugValue: throwInvalidHookError,
    useResponder: throwInvalidHookError
  },
      HooksDispatcherOnMount = {
    readContext: readContext,
    useCallback: function useCallback(callback, deps) {
      mountWorkInProgressHook().memoizedState = [callback, void 0 === deps ? null : deps];
      return callback;
    },
    useContext: readContext,
    useEffect: function useEffect(create, deps) {
      return mountEffectImpl(516, UnmountPassive | MountPassive, create, deps);
    },
    useImperativeHandle: function useImperativeHandle(ref, create, deps) {
      deps = null !== deps && void 0 !== deps ? deps.concat([ref]) : null;
      return mountEffectImpl(4, UnmountMutation | MountLayout, imperativeHandleEffect.bind(null, create, ref), deps);
    },
    useLayoutEffect: function useLayoutEffect(create, deps) {
      return mountEffectImpl(4, UnmountMutation | MountLayout, create, deps);
    },
    useMemo: function useMemo(nextCreate, deps) {
      var hook = mountWorkInProgressHook();
      deps = void 0 === deps ? null : deps;
      nextCreate = nextCreate();
      hook.memoizedState = [nextCreate, deps];
      return nextCreate;
    },
    useReducer: function useReducer(reducer, initialArg, init) {
      var hook = mountWorkInProgressHook();
      initialArg = void 0 !== init ? init(initialArg) : initialArg;
      hook.memoizedState = hook.baseState = initialArg;
      reducer = hook.queue = {
        last: null,
        dispatch: null,
        lastRenderedReducer: reducer,
        lastRenderedState: initialArg
      };
      reducer = reducer.dispatch = dispatchAction.bind(null, currentlyRenderingFiber$1, reducer);
      return [hook.memoizedState, reducer];
    },
    useRef: function useRef(initialValue) {
      var hook = mountWorkInProgressHook();
      initialValue = {
        current: initialValue
      };
      return hook.memoizedState = initialValue;
    },
    useState: function useState(initialState) {
      var hook = mountWorkInProgressHook();
      "function" === typeof initialState && (initialState = initialState());
      hook.memoizedState = hook.baseState = initialState;
      initialState = hook.queue = {
        last: null,
        dispatch: null,
        lastRenderedReducer: basicStateReducer,
        lastRenderedState: initialState
      };
      initialState = initialState.dispatch = dispatchAction.bind(null, currentlyRenderingFiber$1, initialState);
      return [hook.memoizedState, initialState];
    },
    useDebugValue: mountDebugValue,
    useResponder: createResponderListener
  },
      HooksDispatcherOnUpdate = {
    readContext: readContext,
    useCallback: function useCallback(callback, deps) {
      var hook = updateWorkInProgressHook();
      deps = void 0 === deps ? null : deps;
      var prevState = hook.memoizedState;
      if (null !== prevState && null !== deps && areHookInputsEqual(deps, prevState[1])) return prevState[0];
      hook.memoizedState = [callback, deps];
      return callback;
    },
    useContext: readContext,
    useEffect: function useEffect(create, deps) {
      return updateEffectImpl(516, UnmountPassive | MountPassive, create, deps);
    },
    useImperativeHandle: function useImperativeHandle(ref, create, deps) {
      deps = null !== deps && void 0 !== deps ? deps.concat([ref]) : null;
      return updateEffectImpl(4, UnmountMutation | MountLayout, imperativeHandleEffect.bind(null, create, ref), deps);
    },
    useLayoutEffect: function useLayoutEffect(create, deps) {
      return updateEffectImpl(4, UnmountMutation | MountLayout, create, deps);
    },
    useMemo: function useMemo(nextCreate, deps) {
      var hook = updateWorkInProgressHook();
      deps = void 0 === deps ? null : deps;
      var prevState = hook.memoizedState;
      if (null !== prevState && null !== deps && areHookInputsEqual(deps, prevState[1])) return prevState[0];
      nextCreate = nextCreate();
      hook.memoizedState = [nextCreate, deps];
      return nextCreate;
    },
    useReducer: updateReducer,
    useRef: function useRef() {
      return updateWorkInProgressHook().memoizedState;
    },
    useState: function useState(initialState) {
      return updateReducer(basicStateReducer, initialState);
    },
    useDebugValue: mountDebugValue,
    useResponder: createResponderListener
  },
      hydrationParentFiber = null,
      nextHydratableInstance = null,
      isHydrating = !1;

  function tryHydrate(fiber, nextInstance) {
    switch (fiber.tag) {
      case 5:
        return nextInstance = shim$1(nextInstance, fiber.type, fiber.pendingProps), null !== nextInstance ? (fiber.stateNode = nextInstance, !0) : !1;

      case 6:
        return nextInstance = shim$1(nextInstance, fiber.pendingProps), null !== nextInstance ? (fiber.stateNode = nextInstance, !0) : !1;

      case 13:
        return !1;

      default:
        return !1;
    }
  }

  function tryToClaimNextHydratableInstance(fiber$jscomp$0) {
    if (isHydrating) {
      var nextInstance = nextHydratableInstance;

      if (nextInstance) {
        var firstAttemptedInstance = nextInstance;

        if (!tryHydrate(fiber$jscomp$0, nextInstance)) {
          nextInstance = shim$1(firstAttemptedInstance);

          if (!nextInstance || !tryHydrate(fiber$jscomp$0, nextInstance)) {
            fiber$jscomp$0.effectTag |= 2;
            isHydrating = !1;
            hydrationParentFiber = fiber$jscomp$0;
            return;
          }

          var returnFiber = hydrationParentFiber,
              fiber = createFiber(5, null, null, 0);
          fiber.elementType = "DELETED";
          fiber.type = "DELETED";
          fiber.stateNode = firstAttemptedInstance;
          fiber.return = returnFiber;
          fiber.effectTag = 8;
          null !== returnFiber.lastEffect ? (returnFiber.lastEffect.nextEffect = fiber, returnFiber.lastEffect = fiber) : returnFiber.firstEffect = returnFiber.lastEffect = fiber;
        }

        hydrationParentFiber = fiber$jscomp$0;
        nextHydratableInstance = shim$1(nextInstance);
      } else fiber$jscomp$0.effectTag |= 2, isHydrating = !1, hydrationParentFiber = fiber$jscomp$0;
    }
  }

  var ReactCurrentOwner$3 = ReactSharedInternals.ReactCurrentOwner,
      didReceiveUpdate = !1;

  function reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime) {
    workInProgress.child = null === current$$1 ? mountChildFibers(workInProgress, null, nextChildren, renderExpirationTime) : reconcileChildFibers(workInProgress, current$$1.child, nextChildren, renderExpirationTime);
  }

  function updateForwardRef(current$$1, workInProgress, Component, nextProps, renderExpirationTime) {
    Component = Component.render;
    var ref = workInProgress.ref;
    prepareToReadContext(workInProgress, renderExpirationTime);
    nextProps = renderWithHooks(current$$1, workInProgress, Component, nextProps, ref, renderExpirationTime);
    if (null !== current$$1 && !didReceiveUpdate) return workInProgress.updateQueue = current$$1.updateQueue, workInProgress.effectTag &= -517, current$$1.expirationTime <= renderExpirationTime && (current$$1.expirationTime = 0), bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
    workInProgress.effectTag |= 1;
    reconcileChildren(current$$1, workInProgress, nextProps, renderExpirationTime);
    return workInProgress.child;
  }

  function updateMemoComponent(current$$1, workInProgress, Component, nextProps, updateExpirationTime, renderExpirationTime) {
    if (null === current$$1) {
      var type = Component.type;
      if ("function" === typeof type && !shouldConstruct(type) && void 0 === type.defaultProps && null === Component.compare && void 0 === Component.defaultProps) return workInProgress.tag = 15, workInProgress.type = type, updateSimpleMemoComponent(current$$1, workInProgress, type, nextProps, updateExpirationTime, renderExpirationTime);
      current$$1 = createFiberFromTypeAndProps(Component.type, null, nextProps, null, workInProgress.mode, renderExpirationTime);
      current$$1.ref = workInProgress.ref;
      current$$1.return = workInProgress;
      return workInProgress.child = current$$1;
    }

    type = current$$1.child;
    if (updateExpirationTime < renderExpirationTime && (updateExpirationTime = type.memoizedProps, Component = Component.compare, Component = null !== Component ? Component : shallowEqual, Component(updateExpirationTime, nextProps) && current$$1.ref === workInProgress.ref)) return bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
    workInProgress.effectTag |= 1;
    current$$1 = createWorkInProgress(type, nextProps, renderExpirationTime);
    current$$1.ref = workInProgress.ref;
    current$$1.return = workInProgress;
    return workInProgress.child = current$$1;
  }

  function updateSimpleMemoComponent(current$$1, workInProgress, Component, nextProps, updateExpirationTime, renderExpirationTime) {
    return null !== current$$1 && shallowEqual(current$$1.memoizedProps, nextProps) && current$$1.ref === workInProgress.ref && (didReceiveUpdate = !1, updateExpirationTime < renderExpirationTime) ? bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime) : updateFunctionComponent(current$$1, workInProgress, Component, nextProps, renderExpirationTime);
  }

  function markRef(current$$1, workInProgress) {
    var ref = workInProgress.ref;
    if (null === current$$1 && null !== ref || null !== current$$1 && current$$1.ref !== ref) workInProgress.effectTag |= 128;
  }

  function updateFunctionComponent(current$$1, workInProgress, Component, nextProps, renderExpirationTime) {
    var context = isContextProvider(Component) ? previousContext : contextStackCursor.current;
    context = getMaskedContext(workInProgress, context);
    prepareToReadContext(workInProgress, renderExpirationTime);
    Component = renderWithHooks(current$$1, workInProgress, Component, nextProps, context, renderExpirationTime);
    if (null !== current$$1 && !didReceiveUpdate) return workInProgress.updateQueue = current$$1.updateQueue, workInProgress.effectTag &= -517, current$$1.expirationTime <= renderExpirationTime && (current$$1.expirationTime = 0), bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
    workInProgress.effectTag |= 1;
    reconcileChildren(current$$1, workInProgress, Component, renderExpirationTime);
    return workInProgress.child;
  }

  function updateClassComponent(current$$1, workInProgress, Component, nextProps, renderExpirationTime) {
    if (isContextProvider(Component)) {
      var hasContext = !0;
      pushContextProvider(workInProgress);
    } else hasContext = !1;

    prepareToReadContext(workInProgress, renderExpirationTime);
    if (null === workInProgress.stateNode) null !== current$$1 && (current$$1.alternate = null, workInProgress.alternate = null, workInProgress.effectTag |= 2), constructClassInstance(workInProgress, Component, nextProps, renderExpirationTime), mountClassInstance(workInProgress, Component, nextProps, renderExpirationTime), nextProps = !0;else if (null === current$$1) {
      var instance = workInProgress.stateNode,
          oldProps = workInProgress.memoizedProps;
      instance.props = oldProps;
      var oldContext = instance.context,
          contextType = Component.contextType;
      "object" === typeof contextType && null !== contextType ? contextType = readContext(contextType) : (contextType = isContextProvider(Component) ? previousContext : contextStackCursor.current, contextType = getMaskedContext(workInProgress, contextType));
      var getDerivedStateFromProps = Component.getDerivedStateFromProps,
          hasNewLifecycles = "function" === typeof getDerivedStateFromProps || "function" === typeof instance.getSnapshotBeforeUpdate;
      hasNewLifecycles || "function" !== typeof instance.UNSAFE_componentWillReceiveProps && "function" !== typeof instance.componentWillReceiveProps || (oldProps !== nextProps || oldContext !== contextType) && callComponentWillReceiveProps(workInProgress, instance, nextProps, contextType);
      hasForceUpdate = !1;
      var oldState = workInProgress.memoizedState;
      oldContext = instance.state = oldState;
      var updateQueue = workInProgress.updateQueue;
      null !== updateQueue && (processUpdateQueue(workInProgress, updateQueue, nextProps, instance, renderExpirationTime), oldContext = workInProgress.memoizedState);
      oldProps !== nextProps || oldState !== oldContext || didPerformWorkStackCursor.current || hasForceUpdate ? ("function" === typeof getDerivedStateFromProps && (applyDerivedStateFromProps(workInProgress, Component, getDerivedStateFromProps, nextProps), oldContext = workInProgress.memoizedState), (oldProps = hasForceUpdate || checkShouldComponentUpdate(workInProgress, Component, oldProps, nextProps, oldState, oldContext, contextType)) ? (hasNewLifecycles || "function" !== typeof instance.UNSAFE_componentWillMount && "function" !== typeof instance.componentWillMount || ("function" === typeof instance.componentWillMount && instance.componentWillMount(), "function" === typeof instance.UNSAFE_componentWillMount && instance.UNSAFE_componentWillMount()), "function" === typeof instance.componentDidMount && (workInProgress.effectTag |= 4)) : ("function" === typeof instance.componentDidMount && (workInProgress.effectTag |= 4), workInProgress.memoizedProps = nextProps, workInProgress.memoizedState = oldContext), instance.props = nextProps, instance.state = oldContext, instance.context = contextType, nextProps = oldProps) : ("function" === typeof instance.componentDidMount && (workInProgress.effectTag |= 4), nextProps = !1);
    } else instance = workInProgress.stateNode, oldProps = workInProgress.memoizedProps, instance.props = workInProgress.type === workInProgress.elementType ? oldProps : resolveDefaultProps(workInProgress.type, oldProps), oldContext = instance.context, contextType = Component.contextType, "object" === typeof contextType && null !== contextType ? contextType = readContext(contextType) : (contextType = isContextProvider(Component) ? previousContext : contextStackCursor.current, contextType = getMaskedContext(workInProgress, contextType)), getDerivedStateFromProps = Component.getDerivedStateFromProps, (hasNewLifecycles = "function" === typeof getDerivedStateFromProps || "function" === typeof instance.getSnapshotBeforeUpdate) || "function" !== typeof instance.UNSAFE_componentWillReceiveProps && "function" !== typeof instance.componentWillReceiveProps || (oldProps !== nextProps || oldContext !== contextType) && callComponentWillReceiveProps(workInProgress, instance, nextProps, contextType), hasForceUpdate = !1, oldContext = workInProgress.memoizedState, oldState = instance.state = oldContext, updateQueue = workInProgress.updateQueue, null !== updateQueue && (processUpdateQueue(workInProgress, updateQueue, nextProps, instance, renderExpirationTime), oldState = workInProgress.memoizedState), oldProps !== nextProps || oldContext !== oldState || didPerformWorkStackCursor.current || hasForceUpdate ? ("function" === typeof getDerivedStateFromProps && (applyDerivedStateFromProps(workInProgress, Component, getDerivedStateFromProps, nextProps), oldState = workInProgress.memoizedState), (getDerivedStateFromProps = hasForceUpdate || checkShouldComponentUpdate(workInProgress, Component, oldProps, nextProps, oldContext, oldState, contextType)) ? (hasNewLifecycles || "function" !== typeof instance.UNSAFE_componentWillUpdate && "function" !== typeof instance.componentWillUpdate || ("function" === typeof instance.componentWillUpdate && instance.componentWillUpdate(nextProps, oldState, contextType), "function" === typeof instance.UNSAFE_componentWillUpdate && instance.UNSAFE_componentWillUpdate(nextProps, oldState, contextType)), "function" === typeof instance.componentDidUpdate && (workInProgress.effectTag |= 4), "function" === typeof instance.getSnapshotBeforeUpdate && (workInProgress.effectTag |= 256)) : ("function" !== typeof instance.componentDidUpdate || oldProps === current$$1.memoizedProps && oldContext === current$$1.memoizedState || (workInProgress.effectTag |= 4), "function" !== typeof instance.getSnapshotBeforeUpdate || oldProps === current$$1.memoizedProps && oldContext === current$$1.memoizedState || (workInProgress.effectTag |= 256), workInProgress.memoizedProps = nextProps, workInProgress.memoizedState = oldState), instance.props = nextProps, instance.state = oldState, instance.context = contextType, nextProps = getDerivedStateFromProps) : ("function" !== typeof instance.componentDidUpdate || oldProps === current$$1.memoizedProps && oldContext === current$$1.memoizedState || (workInProgress.effectTag |= 4), "function" !== typeof instance.getSnapshotBeforeUpdate || oldProps === current$$1.memoizedProps && oldContext === current$$1.memoizedState || (workInProgress.effectTag |= 256), nextProps = !1);
    return finishClassComponent(current$$1, workInProgress, Component, nextProps, hasContext, renderExpirationTime);
  }

  function finishClassComponent(current$$1, workInProgress, Component, shouldUpdate, hasContext, renderExpirationTime) {
    markRef(current$$1, workInProgress);
    var didCaptureError = 0 !== (workInProgress.effectTag & 64);
    if (!shouldUpdate && !didCaptureError) return hasContext && invalidateContextProvider(workInProgress, Component, !1), bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
    shouldUpdate = workInProgress.stateNode;
    ReactCurrentOwner$3.current = workInProgress;
    var nextChildren = didCaptureError && "function" !== typeof Component.getDerivedStateFromError ? null : shouldUpdate.render();
    workInProgress.effectTag |= 1;
    null !== current$$1 && didCaptureError ? (workInProgress.child = reconcileChildFibers(workInProgress, current$$1.child, null, renderExpirationTime), workInProgress.child = reconcileChildFibers(workInProgress, null, nextChildren, renderExpirationTime)) : reconcileChildren(current$$1, workInProgress, nextChildren, renderExpirationTime);
    workInProgress.memoizedState = shouldUpdate.state;
    hasContext && invalidateContextProvider(workInProgress, Component, !0);
    return workInProgress.child;
  }

  function pushHostRootContext(workInProgress) {
    var root = workInProgress.stateNode;
    root.pendingContext ? pushTopLevelContextObject(workInProgress, root.pendingContext, root.pendingContext !== root.context) : root.context && pushTopLevelContextObject(workInProgress, root.context, !1);
    pushHostContainer(workInProgress, root.containerInfo);
  }

  var SUSPENDED_MARKER = {};

  function updateSuspenseComponent(current$$1, workInProgress, renderExpirationTime) {
    var mode = workInProgress.mode,
        nextProps = workInProgress.pendingProps,
        suspenseContext = suspenseStackCursor.current,
        nextState = null,
        nextDidTimeout = !1,
        JSCompiler_temp;
    (JSCompiler_temp = 0 !== (workInProgress.effectTag & 64)) || (JSCompiler_temp = 0 !== (suspenseContext & ForceSuspenseFallback) && (null === current$$1 || null !== current$$1.memoizedState));
    JSCompiler_temp ? (nextState = SUSPENDED_MARKER, nextDidTimeout = !0, workInProgress.effectTag &= -65) : null !== current$$1 && null === current$$1.memoizedState || void 0 === nextProps.fallback || !0 === nextProps.unstable_avoidThisFallback || (suspenseContext |= InvisibleParentSuspenseContext);
    suspenseContext &= SubtreeSuspenseContextMask;
    push(suspenseStackCursor, suspenseContext, workInProgress);
    if (null === current$$1) {
      if (nextDidTimeout) {
        nextProps = nextProps.fallback;
        current$$1 = createFiberFromFragment(null, mode, 0, null);
        current$$1.return = workInProgress;
        if (0 === (workInProgress.mode & 2)) for (nextDidTimeout = null !== workInProgress.memoizedState ? workInProgress.child.child : workInProgress.child, current$$1.child = nextDidTimeout; null !== nextDidTimeout;) {
          nextDidTimeout.return = current$$1, nextDidTimeout = nextDidTimeout.sibling;
        }
        renderExpirationTime = createFiberFromFragment(nextProps, mode, renderExpirationTime, null);
        renderExpirationTime.return = workInProgress;
        current$$1.sibling = renderExpirationTime;
        mode = current$$1;
      } else mode = renderExpirationTime = mountChildFibers(workInProgress, null, nextProps.children, renderExpirationTime);
    } else {
      if (null !== current$$1.memoizedState) {
        if (suspenseContext = current$$1.child, mode = suspenseContext.sibling, nextDidTimeout) {
          nextProps = nextProps.fallback;
          renderExpirationTime = createWorkInProgress(suspenseContext, suspenseContext.pendingProps, 0);
          renderExpirationTime.return = workInProgress;
          if (0 === (workInProgress.mode & 2) && (nextDidTimeout = null !== workInProgress.memoizedState ? workInProgress.child.child : workInProgress.child, nextDidTimeout !== suspenseContext.child)) for (renderExpirationTime.child = nextDidTimeout; null !== nextDidTimeout;) {
            nextDidTimeout.return = renderExpirationTime, nextDidTimeout = nextDidTimeout.sibling;
          }
          nextProps = createWorkInProgress(mode, nextProps, mode.expirationTime);
          nextProps.return = workInProgress;
          renderExpirationTime.sibling = nextProps;
          mode = renderExpirationTime;
          renderExpirationTime.childExpirationTime = 0;
          renderExpirationTime = nextProps;
        } else mode = renderExpirationTime = reconcileChildFibers(workInProgress, suspenseContext.child, nextProps.children, renderExpirationTime);
      } else if (suspenseContext = current$$1.child, nextDidTimeout) {
        nextDidTimeout = nextProps.fallback;
        nextProps = createFiberFromFragment(null, mode, 0, null);
        nextProps.return = workInProgress;
        nextProps.child = suspenseContext;
        null !== suspenseContext && (suspenseContext.return = nextProps);
        if (0 === (workInProgress.mode & 2)) for (suspenseContext = null !== workInProgress.memoizedState ? workInProgress.child.child : workInProgress.child, nextProps.child = suspenseContext; null !== suspenseContext;) {
          suspenseContext.return = nextProps, suspenseContext = suspenseContext.sibling;
        }
        renderExpirationTime = createFiberFromFragment(nextDidTimeout, mode, renderExpirationTime, null);
        renderExpirationTime.return = workInProgress;
        nextProps.sibling = renderExpirationTime;
        renderExpirationTime.effectTag |= 2;
        mode = nextProps;
        nextProps.childExpirationTime = 0;
      } else renderExpirationTime = mode = reconcileChildFibers(workInProgress, suspenseContext, nextProps.children, renderExpirationTime);
      workInProgress.stateNode = current$$1.stateNode;
    }
    workInProgress.memoizedState = nextState;
    workInProgress.child = mode;
    return renderExpirationTime;
  }

  function initSuspenseListRenderState(workInProgress, isBackwards, tail, lastContentRow, tailMode) {
    var renderState = workInProgress.memoizedState;
    null === renderState ? workInProgress.memoizedState = {
      isBackwards: isBackwards,
      rendering: null,
      last: lastContentRow,
      tail: tail,
      tailExpiration: 0,
      tailMode: tailMode
    } : (renderState.isBackwards = isBackwards, renderState.rendering = null, renderState.last = lastContentRow, renderState.tail = tail, renderState.tailExpiration = 0, renderState.tailMode = tailMode);
  }

  function updateSuspenseListComponent(current$$1, workInProgress, renderExpirationTime) {
    var nextProps = workInProgress.pendingProps,
        revealOrder = nextProps.revealOrder,
        tailMode = nextProps.tail;
    reconcileChildren(current$$1, workInProgress, nextProps.children, renderExpirationTime);
    nextProps = suspenseStackCursor.current;
    if (0 !== (nextProps & ForceSuspenseFallback)) nextProps = nextProps & SubtreeSuspenseContextMask | ForceSuspenseFallback, workInProgress.effectTag |= 64;else {
      if (null !== current$$1 && 0 !== (current$$1.effectTag & 64)) a: for (current$$1 = workInProgress.child; null !== current$$1;) {
        if (13 === current$$1.tag) {
          if (null !== current$$1.memoizedState) {
            current$$1.expirationTime < renderExpirationTime && (current$$1.expirationTime = renderExpirationTime);
            var alternate = current$$1.alternate;
            null !== alternate && alternate.expirationTime < renderExpirationTime && (alternate.expirationTime = renderExpirationTime);
            scheduleWorkOnParentPath(current$$1.return, renderExpirationTime);
          }
        } else if (null !== current$$1.child) {
          current$$1.child.return = current$$1;
          current$$1 = current$$1.child;
          continue;
        }

        if (current$$1 === workInProgress) break a;

        for (; null === current$$1.sibling;) {
          if (null === current$$1.return || current$$1.return === workInProgress) break a;
          current$$1 = current$$1.return;
        }

        current$$1.sibling.return = current$$1.return;
        current$$1 = current$$1.sibling;
      }
      nextProps &= SubtreeSuspenseContextMask;
    }
    push(suspenseStackCursor, nextProps, workInProgress);
    if (0 === (workInProgress.mode & 2)) workInProgress.memoizedState = null;else switch (revealOrder) {
      case "forwards":
        renderExpirationTime = workInProgress.child;

        for (revealOrder = null; null !== renderExpirationTime;) {
          nextProps = renderExpirationTime.alternate, null !== nextProps && null === findFirstSuspended(nextProps) && (revealOrder = renderExpirationTime), renderExpirationTime = renderExpirationTime.sibling;
        }

        renderExpirationTime = revealOrder;
        null === renderExpirationTime ? (revealOrder = workInProgress.child, workInProgress.child = null) : (revealOrder = renderExpirationTime.sibling, renderExpirationTime.sibling = null);
        initSuspenseListRenderState(workInProgress, !1, revealOrder, renderExpirationTime, tailMode);
        break;

      case "backwards":
        renderExpirationTime = null;
        revealOrder = workInProgress.child;

        for (workInProgress.child = null; null !== revealOrder;) {
          nextProps = revealOrder.alternate;

          if (null !== nextProps && null === findFirstSuspended(nextProps)) {
            workInProgress.child = revealOrder;
            break;
          }

          nextProps = revealOrder.sibling;
          revealOrder.sibling = renderExpirationTime;
          renderExpirationTime = revealOrder;
          revealOrder = nextProps;
        }

        initSuspenseListRenderState(workInProgress, !0, renderExpirationTime, null, tailMode);
        break;

      case "together":
        initSuspenseListRenderState(workInProgress, !1, null, null, void 0);
        break;

      default:
        workInProgress.memoizedState = null;
    }
    return workInProgress.child;
  }

  function bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime) {
    null !== current$$1 && (workInProgress.dependencies = current$$1.dependencies);
    if (workInProgress.childExpirationTime < renderExpirationTime) return null;
    if (null !== current$$1 && workInProgress.child !== current$$1.child) throw ReactError(Error("Resuming work not yet implemented."));

    if (null !== workInProgress.child) {
      current$$1 = workInProgress.child;
      renderExpirationTime = createWorkInProgress(current$$1, current$$1.pendingProps, current$$1.expirationTime);
      workInProgress.child = renderExpirationTime;

      for (renderExpirationTime.return = workInProgress; null !== current$$1.sibling;) {
        current$$1 = current$$1.sibling, renderExpirationTime = renderExpirationTime.sibling = createWorkInProgress(current$$1, current$$1.pendingProps, current$$1.expirationTime), renderExpirationTime.return = workInProgress;
      }

      renderExpirationTime.sibling = null;
    }

    return workInProgress.child;
  }

  var _appendAllChildren = void 0,
      updateHostContainer = void 0,
      updateHostComponent$1 = void 0,
      updateHostText$1 = void 0;

  _appendAllChildren = function appendAllChildren(parent, workInProgress, needsVisibilityToggle, isHidden) {
    for (var node = workInProgress.child; null !== node;) {
      if (5 === node.tag) {
        var instance = node.stateNode;
        needsVisibilityToggle && isHidden && (instance = cloneHiddenInstance(instance, node.type, node.memoizedProps, node));
        appendChildNode(parent.node, instance.node);
      } else if (6 === node.tag) {
        instance = node.stateNode;
        if (needsVisibilityToggle && isHidden) throw Error("Not yet implemented.");
        appendChildNode(parent.node, instance.node);
      } else if (4 !== node.tag) {
        if (13 === node.tag && 0 !== (node.effectTag & 4) && (instance = null !== node.memoizedState)) {
          var primaryChildParent = node.child;

          if (null !== primaryChildParent && (null !== primaryChildParent.child && (primaryChildParent.child.return = primaryChildParent, _appendAllChildren(parent, primaryChildParent, !0, instance)), instance = primaryChildParent.sibling, null !== instance)) {
            instance.return = node;
            node = instance;
            continue;
          }
        }

        if (null !== node.child) {
          node.child.return = node;
          node = node.child;
          continue;
        }
      }

      if (node === workInProgress) break;

      for (; null === node.sibling;) {
        if (null === node.return || node.return === workInProgress) return;
        node = node.return;
      }

      node.sibling.return = node.return;
      node = node.sibling;
    }
  };

  function appendAllChildrenToContainer(containerChildSet, workInProgress, needsVisibilityToggle, isHidden) {
    for (var node = workInProgress.child; null !== node;) {
      if (5 === node.tag) {
        var instance = node.stateNode;
        needsVisibilityToggle && isHidden && (instance = cloneHiddenInstance(instance, node.type, node.memoizedProps, node));
        appendChildNodeToSet(containerChildSet, instance.node);
      } else if (6 === node.tag) {
        instance = node.stateNode;
        if (needsVisibilityToggle && isHidden) throw Error("Not yet implemented.");
        appendChildNodeToSet(containerChildSet, instance.node);
      } else if (4 !== node.tag) {
        if (13 === node.tag && 0 !== (node.effectTag & 4) && (instance = null !== node.memoizedState)) {
          var primaryChildParent = node.child;

          if (null !== primaryChildParent && (null !== primaryChildParent.child && (primaryChildParent.child.return = primaryChildParent, appendAllChildrenToContainer(containerChildSet, primaryChildParent, !0, instance)), instance = primaryChildParent.sibling, null !== instance)) {
            instance.return = node;
            node = instance;
            continue;
          }
        }

        if (null !== node.child) {
          node.child.return = node;
          node = node.child;
          continue;
        }
      }

      if (node === workInProgress) break;

      for (; null === node.sibling;) {
        if (null === node.return || node.return === workInProgress) return;
        node = node.return;
      }

      node.sibling.return = node.return;
      node = node.sibling;
    }
  }

  updateHostContainer = function updateHostContainer(workInProgress) {
    var portalOrRoot = workInProgress.stateNode;

    if (null !== workInProgress.firstEffect) {
      var container = portalOrRoot.containerInfo,
          newChildSet = createChildNodeSet(container);
      appendAllChildrenToContainer(newChildSet, workInProgress, !1, !1);
      portalOrRoot.pendingChildren = newChildSet;
      workInProgress.effectTag |= 4;
      completeRoot(container, newChildSet);
    }
  };

  updateHostComponent$1 = function updateHostComponent$1(current, workInProgress, type, newProps) {
    type = current.stateNode;
    var oldProps = current.memoizedProps;
    if ((current = null === workInProgress.firstEffect) && oldProps === newProps) workInProgress.stateNode = type;else {
      var recyclableInstance = workInProgress.stateNode;
      requiredContext(contextStackCursor$1.current);
      var updatePayload = null;
      oldProps !== newProps && (oldProps = diffProperties(null, oldProps, newProps, recyclableInstance.canonical.viewConfig.validAttributes), recyclableInstance.canonical.currentProps = newProps, updatePayload = oldProps);
      current && null === updatePayload ? workInProgress.stateNode = type : (newProps = updatePayload, recyclableInstance = type.node, type = {
        node: current ? null !== newProps ? cloneNodeWithNewProps(recyclableInstance, newProps) : cloneNode(recyclableInstance) : null !== newProps ? cloneNodeWithNewChildrenAndProps(recyclableInstance, newProps) : cloneNodeWithNewChildren(recyclableInstance),
        canonical: type.canonical
      }, workInProgress.stateNode = type, current ? workInProgress.effectTag |= 4 : _appendAllChildren(type, workInProgress, !1, !1));
    }
  };

  updateHostText$1 = function updateHostText$1(current, workInProgress, oldText, newText) {
    oldText !== newText && (current = requiredContext(rootInstanceStackCursor.current), oldText = requiredContext(contextStackCursor$1.current), workInProgress.stateNode = createTextInstance(newText, current, oldText, workInProgress), workInProgress.effectTag |= 4);
  };

  function cutOffTailIfNeeded(renderState, hasRenderedATailFallback) {
    switch (renderState.tailMode) {
      case "hidden":
        hasRenderedATailFallback = renderState.tail;

        for (var lastTailNode = null; null !== hasRenderedATailFallback;) {
          null !== hasRenderedATailFallback.alternate && (lastTailNode = hasRenderedATailFallback), hasRenderedATailFallback = hasRenderedATailFallback.sibling;
        }

        null === lastTailNode ? renderState.tail = null : lastTailNode.sibling = null;
        break;

      case "collapsed":
        lastTailNode = renderState.tail;

        for (var _lastTailNode = null; null !== lastTailNode;) {
          null !== lastTailNode.alternate && (_lastTailNode = lastTailNode), lastTailNode = lastTailNode.sibling;
        }

        null === _lastTailNode ? hasRenderedATailFallback || null === renderState.tail ? renderState.tail = null : renderState.tail.sibling = null : _lastTailNode.sibling = null;
    }
  }

  function unwindWork(workInProgress) {
    switch (workInProgress.tag) {
      case 1:
        isContextProvider(workInProgress.type) && popContext(workInProgress);
        var effectTag = workInProgress.effectTag;
        return effectTag & 2048 ? (workInProgress.effectTag = effectTag & -2049 | 64, workInProgress) : null;

      case 3:
        popHostContainer(workInProgress);
        popTopLevelContextObject(workInProgress);
        effectTag = workInProgress.effectTag;
        if (0 !== (effectTag & 64)) throw ReactError(Error("The root failed to unmount after an error. This is likely a bug in React. Please file an issue."));
        workInProgress.effectTag = effectTag & -2049 | 64;
        return workInProgress;

      case 5:
        return popHostContext(workInProgress), null;

      case 13:
        return pop(suspenseStackCursor, workInProgress), effectTag = workInProgress.effectTag, effectTag & 2048 ? (workInProgress.effectTag = effectTag & -2049 | 64, workInProgress) : null;

      case 18:
        return null;

      case 19:
        return pop(suspenseStackCursor, workInProgress), null;

      case 4:
        return popHostContainer(workInProgress), null;

      case 10:
        return popProvider(workInProgress), null;

      default:
        return null;
    }
  }

  function createCapturedValue(value, source) {
    return {
      value: value,
      source: source,
      stack: getStackByFiberInDevAndProd(source)
    };
  }

  if ("function" !== typeof ReactNativePrivateInterface.ReactFiberErrorDialog.showErrorDialog) throw ReactError(Error("Expected ReactFiberErrorDialog.showErrorDialog to be a function."));

  function logCapturedError(capturedError) {
    !1 !== ReactNativePrivateInterface.ReactFiberErrorDialog.showErrorDialog(capturedError) && console.error(capturedError.error);
  }

  var PossiblyWeakSet$1 = "function" === typeof WeakSet ? WeakSet : Set;

  function logError(boundary, errorInfo) {
    var source = errorInfo.source,
        stack = errorInfo.stack;
    null === stack && null !== source && (stack = getStackByFiberInDevAndProd(source));
    errorInfo = {
      componentName: null !== source ? getComponentName(source.type) : null,
      componentStack: null !== stack ? stack : "",
      error: errorInfo.value,
      errorBoundary: null,
      errorBoundaryName: null,
      errorBoundaryFound: !1,
      willRetry: !1
    };
    null !== boundary && 1 === boundary.tag && (errorInfo.errorBoundary = boundary.stateNode, errorInfo.errorBoundaryName = getComponentName(boundary.type), errorInfo.errorBoundaryFound = !0, errorInfo.willRetry = !0);

    try {
      logCapturedError(errorInfo);
    } catch (e) {
      setTimeout(function () {
        throw e;
      });
    }
  }

  function safelyCallComponentWillUnmount(current$$1, instance) {
    try {
      instance.props = current$$1.memoizedProps, instance.state = current$$1.memoizedState, instance.componentWillUnmount();
    } catch (unmountError) {
      captureCommitPhaseError(current$$1, unmountError);
    }
  }

  function safelyDetachRef(current$$1) {
    var ref = current$$1.ref;
    if (null !== ref) if ("function" === typeof ref) try {
      ref(null);
    } catch (refError) {
      captureCommitPhaseError(current$$1, refError);
    } else ref.current = null;
  }

  function commitHookEffectList(unmountTag, mountTag, finishedWork) {
    finishedWork = finishedWork.updateQueue;
    finishedWork = null !== finishedWork ? finishedWork.lastEffect : null;

    if (null !== finishedWork) {
      var effect = finishedWork = finishedWork.next;

      do {
        if ((effect.tag & unmountTag) !== NoEffect$1) {
          var destroy = effect.destroy;
          effect.destroy = void 0;
          void 0 !== destroy && destroy();
        }

        (effect.tag & mountTag) !== NoEffect$1 && (destroy = effect.create, effect.destroy = destroy());
        effect = effect.next;
      } while (effect !== finishedWork);
    }
  }

  function commitUnmount(current$$1$jscomp$0, renderPriorityLevel) {
    "function" === typeof onCommitFiberUnmount && onCommitFiberUnmount(current$$1$jscomp$0);

    switch (current$$1$jscomp$0.tag) {
      case 0:
      case 11:
      case 14:
      case 15:
        var updateQueue = current$$1$jscomp$0.updateQueue;

        if (null !== updateQueue && (updateQueue = updateQueue.lastEffect, null !== updateQueue)) {
          var firstEffect = updateQueue.next;
          runWithPriority$1(97 < renderPriorityLevel ? 97 : renderPriorityLevel, function () {
            var effect = firstEffect;

            do {
              var destroy = effect.destroy;

              if (void 0 !== destroy) {
                var current$$1 = current$$1$jscomp$0;

                try {
                  destroy();
                } catch (error) {
                  captureCommitPhaseError(current$$1, error);
                }
              }

              effect = effect.next;
            } while (effect !== firstEffect);
          });
        }

        break;

      case 1:
        safelyDetachRef(current$$1$jscomp$0);
        renderPriorityLevel = current$$1$jscomp$0.stateNode;
        "function" === typeof renderPriorityLevel.componentWillUnmount && safelyCallComponentWillUnmount(current$$1$jscomp$0, renderPriorityLevel);
        break;

      case 5:
        safelyDetachRef(current$$1$jscomp$0);
        break;

      case 4:
        createChildNodeSet(current$$1$jscomp$0.stateNode.containerInfo);
    }
  }

  function detachFiber(current$$1) {
    var alternate = current$$1.alternate;
    current$$1.return = null;
    current$$1.child = null;
    current$$1.memoizedState = null;
    current$$1.updateQueue = null;
    current$$1.dependencies = null;
    current$$1.alternate = null;
    current$$1.firstEffect = null;
    current$$1.lastEffect = null;
    current$$1.pendingProps = null;
    current$$1.memoizedProps = null;
    null !== alternate && detachFiber(alternate);
  }

  function commitWork(current$$1, finishedWork) {
    switch (finishedWork.tag) {
      case 0:
      case 11:
      case 14:
      case 15:
        commitHookEffectList(UnmountMutation, MountMutation, finishedWork);
        return;

      case 12:
        return;

      case 13:
        null !== finishedWork.memoizedState && (globalMostRecentFallbackTime = now());
        attachSuspenseRetryListeners(finishedWork);
        return;

      case 19:
        attachSuspenseRetryListeners(finishedWork);
        return;
    }

    switch (finishedWork.tag) {
      case 1:
      case 5:
      case 6:
      case 20:
        break;

      case 3:
      case 4:
        break;

      default:
        throw ReactError(Error("This unit of work tag should not have side-effects. This error is likely caused by a bug in React. Please file an issue."));
    }
  }

  function attachSuspenseRetryListeners(finishedWork) {
    var thenables = finishedWork.updateQueue;

    if (null !== thenables) {
      finishedWork.updateQueue = null;
      var retryCache = finishedWork.stateNode;
      null === retryCache && (retryCache = finishedWork.stateNode = new PossiblyWeakSet$1());
      thenables.forEach(function (thenable) {
        var retry = resolveRetryThenable.bind(null, finishedWork, thenable);
        retryCache.has(thenable) || (retryCache.add(thenable), thenable.then(retry, retry));
      });
    }
  }

  var PossiblyWeakMap = "function" === typeof WeakMap ? WeakMap : Map;

  function createRootErrorUpdate(fiber, errorInfo, expirationTime) {
    expirationTime = createUpdate(expirationTime, null);
    expirationTime.tag = 3;
    expirationTime.payload = {
      element: null
    };
    var error = errorInfo.value;

    expirationTime.callback = function () {
      hasUncaughtError || (hasUncaughtError = !0, firstUncaughtError = error);
      logError(fiber, errorInfo);
    };

    return expirationTime;
  }

  function createClassErrorUpdate(fiber, errorInfo, expirationTime) {
    expirationTime = createUpdate(expirationTime, null);
    expirationTime.tag = 3;
    var getDerivedStateFromError = fiber.type.getDerivedStateFromError;

    if ("function" === typeof getDerivedStateFromError) {
      var error = errorInfo.value;

      expirationTime.payload = function () {
        logError(fiber, errorInfo);
        return getDerivedStateFromError(error);
      };
    }

    var inst = fiber.stateNode;
    null !== inst && "function" === typeof inst.componentDidCatch && (expirationTime.callback = function () {
      "function" !== typeof getDerivedStateFromError && (null === legacyErrorBoundariesThatAlreadyFailed ? legacyErrorBoundariesThatAlreadyFailed = new Set([this]) : legacyErrorBoundariesThatAlreadyFailed.add(this), logError(fiber, errorInfo));
      var stack = errorInfo.stack;
      this.componentDidCatch(errorInfo.value, {
        componentStack: null !== stack ? stack : ""
      });
    });
    return expirationTime;
  }

  var ceil = Math.ceil,
      ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher,
      ReactCurrentOwner$2 = ReactSharedInternals.ReactCurrentOwner,
      NoContext = 0,
      LegacyUnbatchedContext = 8,
      RenderContext = 16,
      CommitContext = 32,
      RootIncomplete = 0,
      RootErrored = 1,
      RootSuspended = 2,
      RootSuspendedWithDelay = 3,
      RootCompleted = 4,
      executionContext = NoContext,
      workInProgressRoot = null,
      workInProgress = null,
      renderExpirationTime = 0,
      workInProgressRootExitStatus = RootIncomplete,
      workInProgressRootLatestProcessedExpirationTime = 1073741823,
      workInProgressRootLatestSuspenseTimeout = 1073741823,
      workInProgressRootCanSuspendUsingConfig = null,
      workInProgressRootHasPendingPing = !1,
      globalMostRecentFallbackTime = 0,
      FALLBACK_THROTTLE_MS = 500,
      nextEffect = null,
      hasUncaughtError = !1,
      firstUncaughtError = null,
      legacyErrorBoundariesThatAlreadyFailed = null,
      rootDoesHavePassiveEffects = !1,
      rootWithPendingPassiveEffects = null,
      pendingPassiveEffectsRenderPriority = 90,
      pendingPassiveEffectsExpirationTime = 0,
      rootsWithPendingDiscreteUpdates = null,
      nestedUpdateCount = 0,
      rootWithNestedUpdates = null,
      currentEventTime = 0;

  function requestCurrentTime() {
    return (executionContext & (RenderContext | CommitContext)) !== NoContext ? 1073741821 - (now() / 10 | 0) : 0 !== currentEventTime ? currentEventTime : currentEventTime = 1073741821 - (now() / 10 | 0);
  }

  function computeExpirationForFiber(currentTime, fiber, suspenseConfig) {
    fiber = fiber.mode;
    if (0 === (fiber & 2)) return 1073741823;
    var priorityLevel = getCurrentPriorityLevel();
    if (0 === (fiber & 4)) return 99 === priorityLevel ? 1073741823 : 1073741822;
    if ((executionContext & RenderContext) !== NoContext) return renderExpirationTime;
    if (null !== suspenseConfig) currentTime = 1073741821 - 25 * (((1073741821 - currentTime + (suspenseConfig.timeoutMs | 0 || 5e3) / 10) / 25 | 0) + 1);else switch (priorityLevel) {
      case 99:
        currentTime = 1073741823;
        break;

      case 98:
        currentTime = 1073741821 - 10 * (((1073741821 - currentTime + 15) / 10 | 0) + 1);
        break;

      case 97:
      case 96:
        currentTime = 1073741821 - 25 * (((1073741821 - currentTime + 500) / 25 | 0) + 1);
        break;

      case 95:
        currentTime = 1;
        break;

      default:
        throw ReactError(Error("Expected a valid priority level"));
    }
    null !== workInProgressRoot && currentTime === renderExpirationTime && --currentTime;
    return currentTime;
  }

  function scheduleUpdateOnFiber(fiber, expirationTime) {
    if (50 < nestedUpdateCount) throw nestedUpdateCount = 0, rootWithNestedUpdates = null, ReactError(Error("Maximum update depth exceeded. This can happen when a component repeatedly calls setState inside componentWillUpdate or componentDidUpdate. React limits the number of nested updates to prevent infinite loops."));
    fiber = markUpdateTimeFromFiberToRoot(fiber, expirationTime);

    if (null !== fiber) {
      fiber.pingTime = 0;
      var priorityLevel = getCurrentPriorityLevel();
      if (1073741823 === expirationTime) {
        if ((executionContext & LegacyUnbatchedContext) !== NoContext && (executionContext & (RenderContext | CommitContext)) === NoContext) for (var callback = renderRoot(fiber, 1073741823, !0); null !== callback;) {
          callback = callback(!0);
        } else scheduleCallbackForRoot(fiber, 99, 1073741823), executionContext === NoContext && flushSyncCallbackQueue();
      } else scheduleCallbackForRoot(fiber, priorityLevel, expirationTime);
      (executionContext & 4) === NoContext || 98 !== priorityLevel && 99 !== priorityLevel || (null === rootsWithPendingDiscreteUpdates ? rootsWithPendingDiscreteUpdates = new Map([[fiber, expirationTime]]) : (priorityLevel = rootsWithPendingDiscreteUpdates.get(fiber), (void 0 === priorityLevel || priorityLevel > expirationTime) && rootsWithPendingDiscreteUpdates.set(fiber, expirationTime)));
    }
  }

  function markUpdateTimeFromFiberToRoot(fiber, expirationTime) {
    fiber.expirationTime < expirationTime && (fiber.expirationTime = expirationTime);
    var alternate = fiber.alternate;
    null !== alternate && alternate.expirationTime < expirationTime && (alternate.expirationTime = expirationTime);
    var node = fiber.return,
        root = null;
    if (null === node && 3 === fiber.tag) root = fiber.stateNode;else for (; null !== node;) {
      alternate = node.alternate;
      node.childExpirationTime < expirationTime && (node.childExpirationTime = expirationTime);
      null !== alternate && alternate.childExpirationTime < expirationTime && (alternate.childExpirationTime = expirationTime);

      if (null === node.return && 3 === node.tag) {
        root = node.stateNode;
        break;
      }

      node = node.return;
    }
    null !== root && (expirationTime > root.firstPendingTime && (root.firstPendingTime = expirationTime), fiber = root.lastPendingTime, 0 === fiber || expirationTime < fiber) && (root.lastPendingTime = expirationTime);
    return root;
  }

  function scheduleCallbackForRoot(root, priorityLevel, expirationTime) {
    if (root.callbackExpirationTime < expirationTime) {
      var existingCallbackNode = root.callbackNode;
      null !== existingCallbackNode && existingCallbackNode !== fakeCallbackNode && Scheduler_cancelCallback(existingCallbackNode);
      root.callbackExpirationTime = expirationTime;
      1073741823 === expirationTime ? root.callbackNode = scheduleSyncCallback(runRootCallback.bind(null, root, renderRoot.bind(null, root, expirationTime))) : (existingCallbackNode = null, 1 !== expirationTime && (existingCallbackNode = {
        timeout: 10 * (1073741821 - expirationTime) - now()
      }), root.callbackNode = scheduleCallback(priorityLevel, runRootCallback.bind(null, root, renderRoot.bind(null, root, expirationTime)), existingCallbackNode));
    }
  }

  function runRootCallback(root, callback, isSync) {
    var prevCallbackNode = root.callbackNode,
        continuation = null;

    try {
      return continuation = callback(isSync), null !== continuation ? runRootCallback.bind(null, root, continuation) : null;
    } finally {
      null === continuation && prevCallbackNode === root.callbackNode && (root.callbackNode = null, root.callbackExpirationTime = 0);
    }
  }

  function resolveLocksOnRoot(root, expirationTime) {
    var firstBatch = root.firstBatch;
    return null !== firstBatch && firstBatch._defer && firstBatch._expirationTime >= expirationTime ? (scheduleCallback(97, function () {
      firstBatch._onComplete();

      return null;
    }), !0) : !1;
  }

  function flushPendingDiscreteUpdates() {
    if (null !== rootsWithPendingDiscreteUpdates) {
      var roots = rootsWithPendingDiscreteUpdates;
      rootsWithPendingDiscreteUpdates = null;
      roots.forEach(function (expirationTime, root) {
        scheduleSyncCallback(renderRoot.bind(null, root, expirationTime));
      });
      flushSyncCallbackQueue();
    }
  }

  function prepareFreshStack(root, expirationTime) {
    root.finishedWork = null;
    root.finishedExpirationTime = 0;
    var timeoutHandle = root.timeoutHandle;
    -1 !== timeoutHandle && (root.timeoutHandle = -1, cancelTimeout(timeoutHandle));
    if (null !== workInProgress) for (timeoutHandle = workInProgress.return; null !== timeoutHandle;) {
      var interruptedWork = timeoutHandle;

      switch (interruptedWork.tag) {
        case 1:
          var childContextTypes = interruptedWork.type.childContextTypes;
          null !== childContextTypes && void 0 !== childContextTypes && popContext(interruptedWork);
          break;

        case 3:
          popHostContainer(interruptedWork);
          popTopLevelContextObject(interruptedWork);
          break;

        case 5:
          popHostContext(interruptedWork);
          break;

        case 4:
          popHostContainer(interruptedWork);
          break;

        case 13:
          pop(suspenseStackCursor, interruptedWork);
          break;

        case 19:
          pop(suspenseStackCursor, interruptedWork);
          break;

        case 10:
          popProvider(interruptedWork);
      }

      timeoutHandle = timeoutHandle.return;
    }
    workInProgressRoot = root;
    workInProgress = createWorkInProgress(root.current, null, expirationTime);
    renderExpirationTime = expirationTime;
    workInProgressRootExitStatus = RootIncomplete;
    workInProgressRootLatestSuspenseTimeout = workInProgressRootLatestProcessedExpirationTime = 1073741823;
    workInProgressRootCanSuspendUsingConfig = null;
    workInProgressRootHasPendingPing = !1;
  }

  function renderRoot(root$jscomp$0, expirationTime, isSync) {
    if ((executionContext & (RenderContext | CommitContext)) !== NoContext) throw ReactError(Error("Should not already be working."));
    if (root$jscomp$0.firstPendingTime < expirationTime) return null;
    if (isSync && root$jscomp$0.finishedExpirationTime === expirationTime) return commitRoot.bind(null, root$jscomp$0);
    flushPassiveEffects();
    if (root$jscomp$0 !== workInProgressRoot || expirationTime !== renderExpirationTime) prepareFreshStack(root$jscomp$0, expirationTime);else if (workInProgressRootExitStatus === RootSuspendedWithDelay) if (workInProgressRootHasPendingPing) prepareFreshStack(root$jscomp$0, expirationTime);else {
      var lastPendingTime = root$jscomp$0.lastPendingTime;
      if (lastPendingTime < expirationTime) return renderRoot.bind(null, root$jscomp$0, lastPendingTime);
    }

    if (null !== workInProgress) {
      lastPendingTime = executionContext;
      executionContext |= RenderContext;
      var prevDispatcher = ReactCurrentDispatcher.current;
      null === prevDispatcher && (prevDispatcher = ContextOnlyDispatcher);
      ReactCurrentDispatcher.current = ContextOnlyDispatcher;

      if (isSync) {
        if (1073741823 !== expirationTime) {
          var currentTime = requestCurrentTime();
          if (currentTime < expirationTime) return executionContext = lastPendingTime, resetContextDependencies(), ReactCurrentDispatcher.current = prevDispatcher, renderRoot.bind(null, root$jscomp$0, currentTime);
        }
      } else currentEventTime = 0;

      do {
        try {
          if (isSync) for (; null !== workInProgress;) {
            workInProgress = performUnitOfWork(workInProgress);
          } else for (; null !== workInProgress && !Scheduler_shouldYield();) {
            workInProgress = performUnitOfWork(workInProgress);
          }
          break;
        } catch (thrownValue) {
          resetContextDependencies();
          resetHooks();
          currentTime = workInProgress;
          if (null === currentTime || null === currentTime.return) throw prepareFreshStack(root$jscomp$0, expirationTime), executionContext = lastPendingTime, thrownValue;

          a: {
            var root = root$jscomp$0,
                returnFiber = currentTime.return,
                sourceFiber = currentTime,
                value = thrownValue,
                renderExpirationTime$jscomp$0 = renderExpirationTime;
            sourceFiber.effectTag |= 1024;
            sourceFiber.firstEffect = sourceFiber.lastEffect = null;

            if (null !== value && "object" === typeof value && "function" === typeof value.then) {
              var thenable = value,
                  hasInvisibleParentBoundary = 0 !== (suspenseStackCursor.current & InvisibleParentSuspenseContext);
              value = returnFiber;

              do {
                var JSCompiler_temp;
                if (JSCompiler_temp = 13 === value.tag) null !== value.memoizedState ? JSCompiler_temp = !1 : (JSCompiler_temp = value.memoizedProps, JSCompiler_temp = void 0 === JSCompiler_temp.fallback ? !1 : !0 !== JSCompiler_temp.unstable_avoidThisFallback ? !0 : hasInvisibleParentBoundary ? !1 : !0);

                if (JSCompiler_temp) {
                  returnFiber = value.updateQueue;
                  null === returnFiber ? (returnFiber = new Set(), returnFiber.add(thenable), value.updateQueue = returnFiber) : returnFiber.add(thenable);

                  if (0 === (value.mode & 2)) {
                    value.effectTag |= 64;
                    sourceFiber.effectTag &= -1957;
                    1 === sourceFiber.tag && (null === sourceFiber.alternate ? sourceFiber.tag = 17 : (renderExpirationTime$jscomp$0 = createUpdate(1073741823, null), renderExpirationTime$jscomp$0.tag = 2, enqueueUpdate(sourceFiber, renderExpirationTime$jscomp$0)));
                    sourceFiber.expirationTime = 1073741823;
                    break a;
                  }

                  sourceFiber = root;
                  root = renderExpirationTime$jscomp$0;
                  hasInvisibleParentBoundary = sourceFiber.pingCache;
                  null === hasInvisibleParentBoundary ? (hasInvisibleParentBoundary = sourceFiber.pingCache = new PossiblyWeakMap(), returnFiber = new Set(), hasInvisibleParentBoundary.set(thenable, returnFiber)) : (returnFiber = hasInvisibleParentBoundary.get(thenable), void 0 === returnFiber && (returnFiber = new Set(), hasInvisibleParentBoundary.set(thenable, returnFiber)));
                  returnFiber.has(root) || (returnFiber.add(root), sourceFiber = pingSuspendedRoot.bind(null, sourceFiber, thenable, root), thenable.then(sourceFiber, sourceFiber));
                  value.effectTag |= 2048;
                  value.expirationTime = renderExpirationTime$jscomp$0;
                  break a;
                }

                value = value.return;
              } while (null !== value);

              value = Error((getComponentName(sourceFiber.type) || "A React component") + " suspended while rendering, but no fallback UI was specified.\n\nAdd a <Suspense fallback=...> component higher in the tree to provide a loading indicator or placeholder to display." + getStackByFiberInDevAndProd(sourceFiber));
            }

            workInProgressRootExitStatus !== RootCompleted && (workInProgressRootExitStatus = RootErrored);
            value = createCapturedValue(value, sourceFiber);
            sourceFiber = returnFiber;

            do {
              switch (sourceFiber.tag) {
                case 3:
                  sourceFiber.effectTag |= 2048;
                  sourceFiber.expirationTime = renderExpirationTime$jscomp$0;
                  renderExpirationTime$jscomp$0 = createRootErrorUpdate(sourceFiber, value, renderExpirationTime$jscomp$0);
                  enqueueCapturedUpdate(sourceFiber, renderExpirationTime$jscomp$0);
                  break a;

                case 1:
                  if (thenable = value, root = sourceFiber.type, returnFiber = sourceFiber.stateNode, 0 === (sourceFiber.effectTag & 64) && ("function" === typeof root.getDerivedStateFromError || null !== returnFiber && "function" === typeof returnFiber.componentDidCatch && (null === legacyErrorBoundariesThatAlreadyFailed || !legacyErrorBoundariesThatAlreadyFailed.has(returnFiber)))) {
                    sourceFiber.effectTag |= 2048;
                    sourceFiber.expirationTime = renderExpirationTime$jscomp$0;
                    renderExpirationTime$jscomp$0 = createClassErrorUpdate(sourceFiber, thenable, renderExpirationTime$jscomp$0);
                    enqueueCapturedUpdate(sourceFiber, renderExpirationTime$jscomp$0);
                    break a;
                  }

              }

              sourceFiber = sourceFiber.return;
            } while (null !== sourceFiber);
          }

          workInProgress = completeUnitOfWork(currentTime);
        }
      } while (1);

      executionContext = lastPendingTime;
      resetContextDependencies();
      ReactCurrentDispatcher.current = prevDispatcher;
      if (null !== workInProgress) return renderRoot.bind(null, root$jscomp$0, expirationTime);
    }

    root$jscomp$0.finishedWork = root$jscomp$0.current.alternate;
    root$jscomp$0.finishedExpirationTime = expirationTime;
    if (resolveLocksOnRoot(root$jscomp$0, expirationTime)) return null;
    workInProgressRoot = null;

    switch (workInProgressRootExitStatus) {
      case RootIncomplete:
        throw ReactError(Error("Should have a work-in-progress."));

      case RootErrored:
        return lastPendingTime = root$jscomp$0.lastPendingTime, lastPendingTime < expirationTime ? renderRoot.bind(null, root$jscomp$0, lastPendingTime) : isSync ? commitRoot.bind(null, root$jscomp$0) : (prepareFreshStack(root$jscomp$0, expirationTime), scheduleSyncCallback(renderRoot.bind(null, root$jscomp$0, expirationTime)), null);

      case RootSuspended:
        if (1073741823 === workInProgressRootLatestProcessedExpirationTime && !isSync && (isSync = globalMostRecentFallbackTime + FALLBACK_THROTTLE_MS - now(), 10 < isSync)) {
          if (workInProgressRootHasPendingPing) return prepareFreshStack(root$jscomp$0, expirationTime), renderRoot.bind(null, root$jscomp$0, expirationTime);
          lastPendingTime = root$jscomp$0.lastPendingTime;
          if (lastPendingTime < expirationTime) return renderRoot.bind(null, root$jscomp$0, lastPendingTime);
          root$jscomp$0.timeoutHandle = scheduleTimeout(commitRoot.bind(null, root$jscomp$0), isSync);
          return null;
        }

        return commitRoot.bind(null, root$jscomp$0);

      case RootSuspendedWithDelay:
        if (!isSync) {
          if (workInProgressRootHasPendingPing) return prepareFreshStack(root$jscomp$0, expirationTime), renderRoot.bind(null, root$jscomp$0, expirationTime);
          isSync = root$jscomp$0.lastPendingTime;
          if (isSync < expirationTime) return renderRoot.bind(null, root$jscomp$0, isSync);
          1073741823 !== workInProgressRootLatestSuspenseTimeout ? isSync = 10 * (1073741821 - workInProgressRootLatestSuspenseTimeout) - now() : 1073741823 === workInProgressRootLatestProcessedExpirationTime ? isSync = 0 : (isSync = 10 * (1073741821 - workInProgressRootLatestProcessedExpirationTime) - 5e3, lastPendingTime = now(), expirationTime = 10 * (1073741821 - expirationTime) - lastPendingTime, isSync = lastPendingTime - isSync, 0 > isSync && (isSync = 0), isSync = (120 > isSync ? 120 : 480 > isSync ? 480 : 1080 > isSync ? 1080 : 1920 > isSync ? 1920 : 3e3 > isSync ? 3e3 : 4320 > isSync ? 4320 : 1960 * ceil(isSync / 1960)) - isSync, expirationTime < isSync && (isSync = expirationTime));
          if (10 < isSync) return root$jscomp$0.timeoutHandle = scheduleTimeout(commitRoot.bind(null, root$jscomp$0), isSync), null;
        }

        return commitRoot.bind(null, root$jscomp$0);

      case RootCompleted:
        return !isSync && 1073741823 !== workInProgressRootLatestProcessedExpirationTime && null !== workInProgressRootCanSuspendUsingConfig && (lastPendingTime = workInProgressRootLatestProcessedExpirationTime, prevDispatcher = workInProgressRootCanSuspendUsingConfig, expirationTime = prevDispatcher.busyMinDurationMs | 0, 0 >= expirationTime ? expirationTime = 0 : (isSync = prevDispatcher.busyDelayMs | 0, lastPendingTime = now() - (10 * (1073741821 - lastPendingTime) - (prevDispatcher.timeoutMs | 0 || 5e3)), expirationTime = lastPendingTime <= isSync ? 0 : isSync + expirationTime - lastPendingTime), 10 < expirationTime) ? (root$jscomp$0.timeoutHandle = scheduleTimeout(commitRoot.bind(null, root$jscomp$0), expirationTime), null) : commitRoot.bind(null, root$jscomp$0);

      default:
        throw ReactError(Error("Unknown root exit status."));
    }
  }

  function markRenderEventTimeAndConfig(expirationTime, suspenseConfig) {
    expirationTime < workInProgressRootLatestProcessedExpirationTime && 1 < expirationTime && (workInProgressRootLatestProcessedExpirationTime = expirationTime);
    null !== suspenseConfig && expirationTime < workInProgressRootLatestSuspenseTimeout && 1 < expirationTime && (workInProgressRootLatestSuspenseTimeout = expirationTime, workInProgressRootCanSuspendUsingConfig = suspenseConfig);
  }

  function performUnitOfWork(unitOfWork) {
    var next = beginWork$$1(unitOfWork.alternate, unitOfWork, renderExpirationTime);
    unitOfWork.memoizedProps = unitOfWork.pendingProps;
    null === next && (next = completeUnitOfWork(unitOfWork));
    ReactCurrentOwner$2.current = null;
    return next;
  }

  function completeUnitOfWork(unitOfWork) {
    workInProgress = unitOfWork;

    do {
      var current$$1 = workInProgress.alternate;
      unitOfWork = workInProgress.return;

      if (0 === (workInProgress.effectTag & 1024)) {
        a: {
          var current = current$$1;
          current$$1 = workInProgress;
          var renderExpirationTime$jscomp$0 = renderExpirationTime,
              newProps = current$$1.pendingProps;

          switch (current$$1.tag) {
            case 2:
              break;

            case 16:
              break;

            case 15:
            case 0:
              break;

            case 1:
              isContextProvider(current$$1.type) && popContext(current$$1);
              break;

            case 3:
              popHostContainer(current$$1);
              popTopLevelContextObject(current$$1);
              renderExpirationTime$jscomp$0 = current$$1.stateNode;
              renderExpirationTime$jscomp$0.pendingContext && (renderExpirationTime$jscomp$0.context = renderExpirationTime$jscomp$0.pendingContext, renderExpirationTime$jscomp$0.pendingContext = null);
              if (null === current || null === current.child) current$$1.effectTag &= -3;
              updateHostContainer(current$$1);
              break;

            case 5:
              popHostContext(current$$1);
              renderExpirationTime$jscomp$0 = requiredContext(rootInstanceStackCursor.current);
              var type = current$$1.type;
              if (null !== current && null != current$$1.stateNode) updateHostComponent$1(current, current$$1, type, newProps, renderExpirationTime$jscomp$0), current.ref !== current$$1.ref && (current$$1.effectTag |= 128);else if (newProps) {
                requiredContext(contextStackCursor$1.current);
                current = newProps;
                var rootContainerInstance = renderExpirationTime$jscomp$0;
                renderExpirationTime$jscomp$0 = current$$1;
                newProps = nextReactTag;
                nextReactTag += 2;
                type = getViewConfigForType(type);
                var updatePayload = diffProperties(null, emptyObject, current, type.validAttributes);
                rootContainerInstance = createNode(newProps, type.uiViewClassName, rootContainerInstance, updatePayload, renderExpirationTime$jscomp$0);
                current = new ReactFabricHostComponent(newProps, type, current, renderExpirationTime$jscomp$0);
                current = {
                  node: rootContainerInstance,
                  canonical: current
                };

                _appendAllChildren(current, current$$1, !1, !1);

                current$$1.stateNode = current;
                null !== current$$1.ref && (current$$1.effectTag |= 128);
              } else if (null === current$$1.stateNode) throw ReactError(Error("We must have new props for new mounts. This error is likely caused by a bug in React. Please file an issue."));
              break;

            case 6:
              if (current && null != current$$1.stateNode) updateHostText$1(current, current$$1, current.memoizedProps, newProps);else {
                if ("string" !== typeof newProps && null === current$$1.stateNode) throw ReactError(Error("We must have new props for new mounts. This error is likely caused by a bug in React. Please file an issue."));
                current = requiredContext(rootInstanceStackCursor.current);
                renderExpirationTime$jscomp$0 = requiredContext(contextStackCursor$1.current);
                current$$1.stateNode = createTextInstance(newProps, current, renderExpirationTime$jscomp$0, current$$1);
              }
              break;

            case 11:
              break;

            case 13:
              pop(suspenseStackCursor, current$$1);
              newProps = current$$1.memoizedState;

              if (0 !== (current$$1.effectTag & 64)) {
                current$$1.expirationTime = renderExpirationTime$jscomp$0;
                break a;
              }

              renderExpirationTime$jscomp$0 = null !== newProps;
              newProps = !1;
              null !== current && (type = current.memoizedState, newProps = null !== type, renderExpirationTime$jscomp$0 || null === type || (type = current.child.sibling, null !== type && (rootContainerInstance = current$$1.firstEffect, null !== rootContainerInstance ? (current$$1.firstEffect = type, type.nextEffect = rootContainerInstance) : (current$$1.firstEffect = current$$1.lastEffect = type, type.nextEffect = null), type.effectTag = 8)));
              if (renderExpirationTime$jscomp$0 && !newProps && 0 !== (current$$1.mode & 2)) if (null === current && !0 !== current$$1.memoizedProps.unstable_avoidThisFallback || 0 !== (suspenseStackCursor.current & InvisibleParentSuspenseContext)) workInProgressRootExitStatus === RootIncomplete && (workInProgressRootExitStatus = RootSuspended);else if (workInProgressRootExitStatus === RootIncomplete || workInProgressRootExitStatus === RootSuspended) workInProgressRootExitStatus = RootSuspendedWithDelay;
              renderExpirationTime$jscomp$0 && (current$$1.effectTag |= 4);
              break;

            case 7:
              break;

            case 8:
              break;

            case 12:
              break;

            case 4:
              popHostContainer(current$$1);
              updateHostContainer(current$$1);
              break;

            case 10:
              popProvider(current$$1);
              break;

            case 9:
              break;

            case 14:
              break;

            case 17:
              isContextProvider(current$$1.type) && popContext(current$$1);
              break;

            case 18:
              break;

            case 19:
              pop(suspenseStackCursor, current$$1);
              newProps = current$$1.memoizedState;
              if (null === newProps) break;
              type = 0 !== (current$$1.effectTag & 64);
              rootContainerInstance = newProps.rendering;
              if (null === rootContainerInstance) {
                if (type) cutOffTailIfNeeded(newProps, !1);else {
                  if (workInProgressRootExitStatus !== RootIncomplete || null !== current && 0 !== (current.effectTag & 64)) for (current = current$$1.child; null !== current;) {
                    rootContainerInstance = findFirstSuspended(current);

                    if (null !== rootContainerInstance) {
                      current$$1.effectTag |= 64;
                      cutOffTailIfNeeded(newProps, !1);
                      current = rootContainerInstance.updateQueue;
                      null !== current && (current$$1.updateQueue = current, current$$1.effectTag |= 4);
                      current$$1.firstEffect = current$$1.lastEffect = null;
                      current = renderExpirationTime$jscomp$0;

                      for (renderExpirationTime$jscomp$0 = current$$1.child; null !== renderExpirationTime$jscomp$0;) {
                        newProps = renderExpirationTime$jscomp$0, type = current, newProps.effectTag &= 2, newProps.nextEffect = null, newProps.firstEffect = null, newProps.lastEffect = null, rootContainerInstance = newProps.alternate, null === rootContainerInstance ? (newProps.childExpirationTime = 0, newProps.expirationTime = type, newProps.child = null, newProps.memoizedProps = null, newProps.memoizedState = null, newProps.updateQueue = null, newProps.dependencies = null) : (newProps.childExpirationTime = rootContainerInstance.childExpirationTime, newProps.expirationTime = rootContainerInstance.expirationTime, newProps.child = rootContainerInstance.child, newProps.memoizedProps = rootContainerInstance.memoizedProps, newProps.memoizedState = rootContainerInstance.memoizedState, newProps.updateQueue = rootContainerInstance.updateQueue, type = rootContainerInstance.dependencies, newProps.dependencies = null === type ? null : {
                          expirationTime: type.expirationTime,
                          firstContext: type.firstContext,
                          responders: type.responders
                        }), renderExpirationTime$jscomp$0 = renderExpirationTime$jscomp$0.sibling;
                      }

                      push(suspenseStackCursor, suspenseStackCursor.current & SubtreeSuspenseContextMask | ForceSuspenseFallback, current$$1);
                      current$$1 = current$$1.child;
                      break a;
                    }

                    current = current.sibling;
                  }
                }
              } else {
                if (!type) if (current = findFirstSuspended(rootContainerInstance), null !== current) {
                  if (current$$1.effectTag |= 64, type = !0, cutOffTailIfNeeded(newProps, !0), null === newProps.tail && "hidden" === newProps.tailMode) {
                    current = current.updateQueue;
                    null !== current && (current$$1.updateQueue = current, current$$1.effectTag |= 4);
                    current$$1 = current$$1.lastEffect = newProps.lastEffect;
                    null !== current$$1 && (current$$1.nextEffect = null);
                    break;
                  }
                } else now() > newProps.tailExpiration && 1 < renderExpirationTime$jscomp$0 && (current$$1.effectTag |= 64, type = !0, cutOffTailIfNeeded(newProps, !1), current$$1.expirationTime = current$$1.childExpirationTime = renderExpirationTime$jscomp$0 - 1);
                newProps.isBackwards ? (rootContainerInstance.sibling = current$$1.child, current$$1.child = rootContainerInstance) : (current = newProps.last, null !== current ? current.sibling = rootContainerInstance : current$$1.child = rootContainerInstance, newProps.last = rootContainerInstance);
              }

              if (null !== newProps.tail) {
                0 === newProps.tailExpiration && (newProps.tailExpiration = now() + 500);
                current = newProps.tail;
                newProps.rendering = current;
                newProps.tail = current.sibling;
                newProps.lastEffect = current$$1.lastEffect;
                current.sibling = null;
                renderExpirationTime$jscomp$0 = suspenseStackCursor.current;
                renderExpirationTime$jscomp$0 = type ? renderExpirationTime$jscomp$0 & SubtreeSuspenseContextMask | ForceSuspenseFallback : renderExpirationTime$jscomp$0 & SubtreeSuspenseContextMask;
                push(suspenseStackCursor, renderExpirationTime$jscomp$0, current$$1);
                current$$1 = current;
                break a;
              }

              break;

            case 20:
              break;

            default:
              throw ReactError(Error("Unknown unit of work tag. This error is likely caused by a bug in React. Please file an issue."));
          }

          current$$1 = null;
        }

        current = workInProgress;

        if (1 === renderExpirationTime || 1 !== current.childExpirationTime) {
          renderExpirationTime$jscomp$0 = 0;

          for (newProps = current.child; null !== newProps;) {
            type = newProps.expirationTime, rootContainerInstance = newProps.childExpirationTime, type > renderExpirationTime$jscomp$0 && (renderExpirationTime$jscomp$0 = type), rootContainerInstance > renderExpirationTime$jscomp$0 && (renderExpirationTime$jscomp$0 = rootContainerInstance), newProps = newProps.sibling;
          }

          current.childExpirationTime = renderExpirationTime$jscomp$0;
        }

        if (null !== current$$1) return current$$1;
        null !== unitOfWork && 0 === (unitOfWork.effectTag & 1024) && (null === unitOfWork.firstEffect && (unitOfWork.firstEffect = workInProgress.firstEffect), null !== workInProgress.lastEffect && (null !== unitOfWork.lastEffect && (unitOfWork.lastEffect.nextEffect = workInProgress.firstEffect), unitOfWork.lastEffect = workInProgress.lastEffect), 1 < workInProgress.effectTag && (null !== unitOfWork.lastEffect ? unitOfWork.lastEffect.nextEffect = workInProgress : unitOfWork.firstEffect = workInProgress, unitOfWork.lastEffect = workInProgress));
      } else {
        current$$1 = unwindWork(workInProgress, renderExpirationTime);
        if (null !== current$$1) return current$$1.effectTag &= 1023, current$$1;
        null !== unitOfWork && (unitOfWork.firstEffect = unitOfWork.lastEffect = null, unitOfWork.effectTag |= 1024);
      }

      current$$1 = workInProgress.sibling;
      if (null !== current$$1) return current$$1;
      workInProgress = unitOfWork;
    } while (null !== workInProgress);

    workInProgressRootExitStatus === RootIncomplete && (workInProgressRootExitStatus = RootCompleted);
    return null;
  }

  function commitRoot(root) {
    var renderPriorityLevel = getCurrentPriorityLevel();
    runWithPriority$1(99, commitRootImpl.bind(null, root, renderPriorityLevel));
    null !== rootWithPendingPassiveEffects && scheduleCallback(97, function () {
      flushPassiveEffects();
      return null;
    });
    return null;
  }

  function commitRootImpl(root, renderPriorityLevel) {
    flushPassiveEffects();
    if ((executionContext & (RenderContext | CommitContext)) !== NoContext) throw ReactError(Error("Should not already be working."));
    var finishedWork = root.finishedWork,
        expirationTime = root.finishedExpirationTime;
    if (null === finishedWork) return null;
    root.finishedWork = null;
    root.finishedExpirationTime = 0;
    if (finishedWork === root.current) throw ReactError(Error("Cannot commit the same tree as before. This error is likely caused by a bug in React. Please file an issue."));
    root.callbackNode = null;
    root.callbackExpirationTime = 0;
    var updateExpirationTimeBeforeCommit = finishedWork.expirationTime,
        childExpirationTimeBeforeCommit = finishedWork.childExpirationTime;
    updateExpirationTimeBeforeCommit = childExpirationTimeBeforeCommit > updateExpirationTimeBeforeCommit ? childExpirationTimeBeforeCommit : updateExpirationTimeBeforeCommit;
    root.firstPendingTime = updateExpirationTimeBeforeCommit;
    updateExpirationTimeBeforeCommit < root.lastPendingTime && (root.lastPendingTime = updateExpirationTimeBeforeCommit);
    root === workInProgressRoot && (workInProgress = workInProgressRoot = null, renderExpirationTime = 0);
    1 < finishedWork.effectTag ? null !== finishedWork.lastEffect ? (finishedWork.lastEffect.nextEffect = finishedWork, updateExpirationTimeBeforeCommit = finishedWork.firstEffect) : updateExpirationTimeBeforeCommit = finishedWork : updateExpirationTimeBeforeCommit = finishedWork.firstEffect;

    if (null !== updateExpirationTimeBeforeCommit) {
      childExpirationTimeBeforeCommit = executionContext;
      executionContext |= CommitContext;
      ReactCurrentOwner$2.current = null;
      nextEffect = updateExpirationTimeBeforeCommit;

      do {
        try {
          for (; null !== nextEffect;) {
            if (0 !== (nextEffect.effectTag & 256)) {
              var current$$1 = nextEffect.alternate,
                  finishedWork$jscomp$0 = nextEffect;

              switch (finishedWork$jscomp$0.tag) {
                case 0:
                case 11:
                case 15:
                  commitHookEffectList(UnmountSnapshot, NoEffect$1, finishedWork$jscomp$0);
                  break;

                case 1:
                  if (finishedWork$jscomp$0.effectTag & 256 && null !== current$$1) {
                    var prevProps = current$$1.memoizedProps,
                        prevState = current$$1.memoizedState,
                        instance = finishedWork$jscomp$0.stateNode,
                        snapshot = instance.getSnapshotBeforeUpdate(finishedWork$jscomp$0.elementType === finishedWork$jscomp$0.type ? prevProps : resolveDefaultProps(finishedWork$jscomp$0.type, prevProps), prevState);
                    instance.__reactInternalSnapshotBeforeUpdate = snapshot;
                  }

                  break;

                case 3:
                case 5:
                case 6:
                case 4:
                case 17:
                  break;

                default:
                  throw ReactError(Error("This unit of work tag should not have side-effects. This error is likely caused by a bug in React. Please file an issue."));
              }
            }

            nextEffect = nextEffect.nextEffect;
          }
        } catch (error) {
          if (null === nextEffect) throw ReactError(Error("Should be working on an effect."));
          captureCommitPhaseError(nextEffect, error);
          nextEffect = nextEffect.nextEffect;
        }
      } while (null !== nextEffect);

      nextEffect = updateExpirationTimeBeforeCommit;

      do {
        try {
          for (current$$1 = renderPriorityLevel; null !== nextEffect;) {
            var effectTag = nextEffect.effectTag;

            if (effectTag & 128) {
              var current$$1$jscomp$0 = nextEffect.alternate;

              if (null !== current$$1$jscomp$0) {
                var currentRef = current$$1$jscomp$0.ref;
                null !== currentRef && ("function" === typeof currentRef ? currentRef(null) : currentRef.current = null);
              }
            }

            switch (effectTag & 14) {
              case 2:
                nextEffect.effectTag &= -3;
                break;

              case 6:
                nextEffect.effectTag &= -3;
                commitWork(nextEffect.alternate, nextEffect);
                break;

              case 4:
                commitWork(nextEffect.alternate, nextEffect);
                break;

              case 8:
                prevProps = nextEffect;

                a: for (prevState = prevProps, instance = current$$1, snapshot = prevState;;) {
                  if (commitUnmount(snapshot, instance), null !== snapshot.child) snapshot.child.return = snapshot, snapshot = snapshot.child;else {
                    if (snapshot === prevState) break;

                    for (; null === snapshot.sibling;) {
                      if (null === snapshot.return || snapshot.return === prevState) break a;
                      snapshot = snapshot.return;
                    }

                    snapshot.sibling.return = snapshot.return;
                    snapshot = snapshot.sibling;
                  }
                }

                detachFiber(prevProps);
            }

            nextEffect = nextEffect.nextEffect;
          }
        } catch (error) {
          if (null === nextEffect) throw ReactError(Error("Should be working on an effect."));
          captureCommitPhaseError(nextEffect, error);
          nextEffect = nextEffect.nextEffect;
        }
      } while (null !== nextEffect);

      root.current = finishedWork;
      nextEffect = updateExpirationTimeBeforeCommit;

      do {
        try {
          for (effectTag = expirationTime; null !== nextEffect;) {
            var effectTag$jscomp$0 = nextEffect.effectTag;

            if (effectTag$jscomp$0 & 36) {
              var current$$1$jscomp$1 = nextEffect.alternate;
              current$$1$jscomp$0 = nextEffect;
              currentRef = effectTag;

              switch (current$$1$jscomp$0.tag) {
                case 0:
                case 11:
                case 15:
                  commitHookEffectList(UnmountLayout, MountLayout, current$$1$jscomp$0);
                  break;

                case 1:
                  var instance$jscomp$0 = current$$1$jscomp$0.stateNode;
                  if (current$$1$jscomp$0.effectTag & 4) if (null === current$$1$jscomp$1) instance$jscomp$0.componentDidMount();else {
                    var prevProps$jscomp$0 = current$$1$jscomp$0.elementType === current$$1$jscomp$0.type ? current$$1$jscomp$1.memoizedProps : resolveDefaultProps(current$$1$jscomp$0.type, current$$1$jscomp$1.memoizedProps);
                    instance$jscomp$0.componentDidUpdate(prevProps$jscomp$0, current$$1$jscomp$1.memoizedState, instance$jscomp$0.__reactInternalSnapshotBeforeUpdate);
                  }
                  var updateQueue = current$$1$jscomp$0.updateQueue;
                  null !== updateQueue && commitUpdateQueue(current$$1$jscomp$0, updateQueue, instance$jscomp$0, currentRef);
                  break;

                case 3:
                  var _updateQueue = current$$1$jscomp$0.updateQueue;

                  if (null !== _updateQueue) {
                    current$$1 = null;
                    if (null !== current$$1$jscomp$0.child) switch (current$$1$jscomp$0.child.tag) {
                      case 5:
                        current$$1 = current$$1$jscomp$0.child.stateNode.canonical;
                        break;

                      case 1:
                        current$$1 = current$$1$jscomp$0.child.stateNode;
                    }
                    commitUpdateQueue(current$$1$jscomp$0, _updateQueue, current$$1, currentRef);
                  }

                  break;

                case 5:
                  if (null === current$$1$jscomp$1 && current$$1$jscomp$0.effectTag & 4) throw ReactError(Error("The current renderer does not support mutation. This error is likely caused by a bug in React. Please file an issue."));
                  break;

                case 6:
                  break;

                case 4:
                  break;

                case 12:
                  break;

                case 13:
                case 19:
                case 17:
                case 20:
                  break;

                default:
                  throw ReactError(Error("This unit of work tag should not have side-effects. This error is likely caused by a bug in React. Please file an issue."));
              }
            }

            if (effectTag$jscomp$0 & 128) {
              var ref = nextEffect.ref;

              if (null !== ref) {
                var instance$jscomp$1 = nextEffect.stateNode;

                switch (nextEffect.tag) {
                  case 5:
                    var instanceToUse = instance$jscomp$1.canonical;
                    break;

                  default:
                    instanceToUse = instance$jscomp$1;
                }

                "function" === typeof ref ? ref(instanceToUse) : ref.current = instanceToUse;
              }
            }

            effectTag$jscomp$0 & 512 && (rootDoesHavePassiveEffects = !0);
            nextEffect = nextEffect.nextEffect;
          }
        } catch (error) {
          if (null === nextEffect) throw ReactError(Error("Should be working on an effect."));
          captureCommitPhaseError(nextEffect, error);
          nextEffect = nextEffect.nextEffect;
        }
      } while (null !== nextEffect);

      nextEffect = null;
      requestPaint();
      executionContext = childExpirationTimeBeforeCommit;
    } else root.current = finishedWork;

    if (rootDoesHavePassiveEffects) rootDoesHavePassiveEffects = !1, rootWithPendingPassiveEffects = root, pendingPassiveEffectsExpirationTime = expirationTime, pendingPassiveEffectsRenderPriority = renderPriorityLevel;else for (nextEffect = updateExpirationTimeBeforeCommit; null !== nextEffect;) {
      renderPriorityLevel = nextEffect.nextEffect, nextEffect.nextEffect = null, nextEffect = renderPriorityLevel;
    }
    renderPriorityLevel = root.firstPendingTime;
    0 !== renderPriorityLevel ? (effectTag$jscomp$0 = requestCurrentTime(), effectTag$jscomp$0 = inferPriorityFromExpirationTime(effectTag$jscomp$0, renderPriorityLevel), scheduleCallbackForRoot(root, effectTag$jscomp$0, renderPriorityLevel)) : legacyErrorBoundariesThatAlreadyFailed = null;
    "function" === typeof onCommitFiberRoot && onCommitFiberRoot(finishedWork.stateNode, expirationTime);
    1073741823 === renderPriorityLevel ? root === rootWithNestedUpdates ? nestedUpdateCount++ : (nestedUpdateCount = 0, rootWithNestedUpdates = root) : nestedUpdateCount = 0;
    if (hasUncaughtError) throw hasUncaughtError = !1, root = firstUncaughtError, firstUncaughtError = null, root;
    if ((executionContext & LegacyUnbatchedContext) !== NoContext) return null;
    flushSyncCallbackQueue();
    return null;
  }

  function flushPassiveEffects() {
    if (null === rootWithPendingPassiveEffects) return !1;
    var root = rootWithPendingPassiveEffects,
        expirationTime = pendingPassiveEffectsExpirationTime,
        renderPriorityLevel = pendingPassiveEffectsRenderPriority;
    rootWithPendingPassiveEffects = null;
    pendingPassiveEffectsExpirationTime = 0;
    pendingPassiveEffectsRenderPriority = 90;
    return runWithPriority$1(97 < renderPriorityLevel ? 97 : renderPriorityLevel, flushPassiveEffectsImpl.bind(null, root, expirationTime));
  }

  function flushPassiveEffectsImpl(root) {
    if ((executionContext & (RenderContext | CommitContext)) !== NoContext) throw ReactError(Error("Cannot flush passive effects while already rendering."));
    var prevExecutionContext = executionContext;
    executionContext |= CommitContext;

    for (root = root.current.firstEffect; null !== root;) {
      try {
        var finishedWork = root;
        if (0 !== (finishedWork.effectTag & 512)) switch (finishedWork.tag) {
          case 0:
          case 11:
          case 15:
            commitHookEffectList(UnmountPassive, NoEffect$1, finishedWork), commitHookEffectList(NoEffect$1, MountPassive, finishedWork);
        }
      } catch (error) {
        if (null === root) throw ReactError(Error("Should be working on an effect."));
        captureCommitPhaseError(root, error);
      }

      finishedWork = root.nextEffect;
      root.nextEffect = null;
      root = finishedWork;
    }

    executionContext = prevExecutionContext;
    flushSyncCallbackQueue();
    return !0;
  }

  function captureCommitPhaseErrorOnRoot(rootFiber, sourceFiber, error) {
    sourceFiber = createCapturedValue(error, sourceFiber);
    sourceFiber = createRootErrorUpdate(rootFiber, sourceFiber, 1073741823);
    enqueueUpdate(rootFiber, sourceFiber);
    rootFiber = markUpdateTimeFromFiberToRoot(rootFiber, 1073741823);
    null !== rootFiber && scheduleCallbackForRoot(rootFiber, 99, 1073741823);
  }

  function captureCommitPhaseError(sourceFiber, error) {
    if (3 === sourceFiber.tag) captureCommitPhaseErrorOnRoot(sourceFiber, sourceFiber, error);else for (var fiber = sourceFiber.return; null !== fiber;) {
      if (3 === fiber.tag) {
        captureCommitPhaseErrorOnRoot(fiber, sourceFiber, error);
        break;
      } else if (1 === fiber.tag) {
        var instance = fiber.stateNode;

        if ("function" === typeof fiber.type.getDerivedStateFromError || "function" === typeof instance.componentDidCatch && (null === legacyErrorBoundariesThatAlreadyFailed || !legacyErrorBoundariesThatAlreadyFailed.has(instance))) {
          sourceFiber = createCapturedValue(error, sourceFiber);
          sourceFiber = createClassErrorUpdate(fiber, sourceFiber, 1073741823);
          enqueueUpdate(fiber, sourceFiber);
          fiber = markUpdateTimeFromFiberToRoot(fiber, 1073741823);
          null !== fiber && scheduleCallbackForRoot(fiber, 99, 1073741823);
          break;
        }
      }

      fiber = fiber.return;
    }
  }

  function pingSuspendedRoot(root, thenable, suspendedTime) {
    var pingCache = root.pingCache;
    null !== pingCache && pingCache.delete(thenable);
    workInProgressRoot === root && renderExpirationTime === suspendedTime ? workInProgressRootExitStatus === RootSuspendedWithDelay || workInProgressRootExitStatus === RootSuspended && 1073741823 === workInProgressRootLatestProcessedExpirationTime && now() - globalMostRecentFallbackTime < FALLBACK_THROTTLE_MS ? prepareFreshStack(root, renderExpirationTime) : workInProgressRootHasPendingPing = !0 : root.lastPendingTime < suspendedTime || (thenable = root.pingTime, 0 !== thenable && thenable < suspendedTime || (root.pingTime = suspendedTime, root.finishedExpirationTime === suspendedTime && (root.finishedExpirationTime = 0, root.finishedWork = null), thenable = requestCurrentTime(), thenable = inferPriorityFromExpirationTime(thenable, suspendedTime), scheduleCallbackForRoot(root, thenable, suspendedTime)));
  }

  function resolveRetryThenable(boundaryFiber, thenable) {
    var retryCache = boundaryFiber.stateNode;
    null !== retryCache && retryCache.delete(thenable);
    retryCache = requestCurrentTime();
    thenable = computeExpirationForFiber(retryCache, boundaryFiber, null);
    retryCache = inferPriorityFromExpirationTime(retryCache, thenable);
    boundaryFiber = markUpdateTimeFromFiberToRoot(boundaryFiber, thenable);
    null !== boundaryFiber && scheduleCallbackForRoot(boundaryFiber, retryCache, thenable);
  }

  var beginWork$$1 = void 0;

  beginWork$$1 = function beginWork$$1(current$$1, workInProgress, renderExpirationTime) {
    var updateExpirationTime = workInProgress.expirationTime;
    if (null !== current$$1) {
      if (current$$1.memoizedProps !== workInProgress.pendingProps || didPerformWorkStackCursor.current) didReceiveUpdate = !0;else {
        if (updateExpirationTime < renderExpirationTime) {
          didReceiveUpdate = !1;

          switch (workInProgress.tag) {
            case 3:
              pushHostRootContext(workInProgress);
              break;

            case 5:
              pushHostContext(workInProgress);
              break;

            case 1:
              isContextProvider(workInProgress.type) && pushContextProvider(workInProgress);
              break;

            case 4:
              pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
              break;

            case 10:
              pushProvider(workInProgress, workInProgress.memoizedProps.value);
              break;

            case 13:
              if (null !== workInProgress.memoizedState) {
                updateExpirationTime = workInProgress.child.childExpirationTime;
                if (0 !== updateExpirationTime && updateExpirationTime >= renderExpirationTime) return updateSuspenseComponent(current$$1, workInProgress, renderExpirationTime);
                push(suspenseStackCursor, suspenseStackCursor.current & SubtreeSuspenseContextMask, workInProgress);
                workInProgress = bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
                return null !== workInProgress ? workInProgress.sibling : null;
              }

              push(suspenseStackCursor, suspenseStackCursor.current & SubtreeSuspenseContextMask, workInProgress);
              break;

            case 19:
              updateExpirationTime = workInProgress.childExpirationTime >= renderExpirationTime;

              if (0 !== (current$$1.effectTag & 64)) {
                if (updateExpirationTime) return updateSuspenseListComponent(current$$1, workInProgress, renderExpirationTime);
                workInProgress.effectTag |= 64;
              }

              var renderState = workInProgress.memoizedState;
              null !== renderState && (renderState.rendering = null, renderState.tail = null);
              push(suspenseStackCursor, suspenseStackCursor.current, workInProgress);
              if (!updateExpirationTime) return null;
          }

          return bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
        }
      }
    } else didReceiveUpdate = !1;
    workInProgress.expirationTime = 0;

    switch (workInProgress.tag) {
      case 2:
        updateExpirationTime = workInProgress.type;
        null !== current$$1 && (current$$1.alternate = null, workInProgress.alternate = null, workInProgress.effectTag |= 2);
        current$$1 = workInProgress.pendingProps;
        renderState = getMaskedContext(workInProgress, contextStackCursor.current);
        prepareToReadContext(workInProgress, renderExpirationTime);
        renderState = renderWithHooks(null, workInProgress, updateExpirationTime, current$$1, renderState, renderExpirationTime);
        workInProgress.effectTag |= 1;

        if ("object" === typeof renderState && null !== renderState && "function" === typeof renderState.render && void 0 === renderState.$$typeof) {
          workInProgress.tag = 1;
          resetHooks();

          if (isContextProvider(updateExpirationTime)) {
            var hasContext = !0;
            pushContextProvider(workInProgress);
          } else hasContext = !1;

          workInProgress.memoizedState = null !== renderState.state && void 0 !== renderState.state ? renderState.state : null;
          var getDerivedStateFromProps = updateExpirationTime.getDerivedStateFromProps;
          "function" === typeof getDerivedStateFromProps && applyDerivedStateFromProps(workInProgress, updateExpirationTime, getDerivedStateFromProps, current$$1);
          renderState.updater = classComponentUpdater;
          workInProgress.stateNode = renderState;
          renderState._reactInternalFiber = workInProgress;
          mountClassInstance(workInProgress, updateExpirationTime, current$$1, renderExpirationTime);
          workInProgress = finishClassComponent(null, workInProgress, updateExpirationTime, !0, hasContext, renderExpirationTime);
        } else workInProgress.tag = 0, reconcileChildren(null, workInProgress, renderState, renderExpirationTime), workInProgress = workInProgress.child;

        return workInProgress;

      case 16:
        renderState = workInProgress.elementType;
        null !== current$$1 && (current$$1.alternate = null, workInProgress.alternate = null, workInProgress.effectTag |= 2);
        current$$1 = workInProgress.pendingProps;
        renderState = readLazyComponentType(renderState);
        workInProgress.type = renderState;
        hasContext = workInProgress.tag = resolveLazyComponentTag(renderState);
        current$$1 = resolveDefaultProps(renderState, current$$1);

        switch (hasContext) {
          case 0:
            workInProgress = updateFunctionComponent(null, workInProgress, renderState, current$$1, renderExpirationTime);
            break;

          case 1:
            workInProgress = updateClassComponent(null, workInProgress, renderState, current$$1, renderExpirationTime);
            break;

          case 11:
            workInProgress = updateForwardRef(null, workInProgress, renderState, current$$1, renderExpirationTime);
            break;

          case 14:
            workInProgress = updateMemoComponent(null, workInProgress, renderState, resolveDefaultProps(renderState.type, current$$1), updateExpirationTime, renderExpirationTime);
            break;

          default:
            throw ReactError(Error("Element type is invalid. Received a promise that resolves to: " + renderState + ". Lazy element type must resolve to a class or function."));
        }

        return workInProgress;

      case 0:
        return updateExpirationTime = workInProgress.type, renderState = workInProgress.pendingProps, renderState = workInProgress.elementType === updateExpirationTime ? renderState : resolveDefaultProps(updateExpirationTime, renderState), updateFunctionComponent(current$$1, workInProgress, updateExpirationTime, renderState, renderExpirationTime);

      case 1:
        return updateExpirationTime = workInProgress.type, renderState = workInProgress.pendingProps, renderState = workInProgress.elementType === updateExpirationTime ? renderState : resolveDefaultProps(updateExpirationTime, renderState), updateClassComponent(current$$1, workInProgress, updateExpirationTime, renderState, renderExpirationTime);

      case 3:
        pushHostRootContext(workInProgress);
        updateExpirationTime = workInProgress.updateQueue;
        if (null === updateExpirationTime) throw ReactError(Error("If the root does not have an updateQueue, we should have already bailed out. This error is likely caused by a bug in React. Please file an issue."));
        renderState = workInProgress.memoizedState;
        renderState = null !== renderState ? renderState.element : null;
        processUpdateQueue(workInProgress, updateExpirationTime, workInProgress.pendingProps, null, renderExpirationTime);
        updateExpirationTime = workInProgress.memoizedState.element;
        updateExpirationTime === renderState ? workInProgress = bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime) : (reconcileChildren(current$$1, workInProgress, updateExpirationTime, renderExpirationTime), workInProgress = workInProgress.child);
        return workInProgress;

      case 5:
        return pushHostContext(workInProgress), null === current$$1 && tryToClaimNextHydratableInstance(workInProgress), updateExpirationTime = workInProgress.pendingProps.children, markRef(current$$1, workInProgress), reconcileChildren(current$$1, workInProgress, updateExpirationTime, renderExpirationTime), workInProgress.child;

      case 6:
        return null === current$$1 && tryToClaimNextHydratableInstance(workInProgress), null;

      case 13:
        return updateSuspenseComponent(current$$1, workInProgress, renderExpirationTime);

      case 4:
        return pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo), updateExpirationTime = workInProgress.pendingProps, null === current$$1 ? workInProgress.child = reconcileChildFibers(workInProgress, null, updateExpirationTime, renderExpirationTime) : reconcileChildren(current$$1, workInProgress, updateExpirationTime, renderExpirationTime), workInProgress.child;

      case 11:
        return updateExpirationTime = workInProgress.type, renderState = workInProgress.pendingProps, renderState = workInProgress.elementType === updateExpirationTime ? renderState : resolveDefaultProps(updateExpirationTime, renderState), updateForwardRef(current$$1, workInProgress, updateExpirationTime, renderState, renderExpirationTime);

      case 7:
        return reconcileChildren(current$$1, workInProgress, workInProgress.pendingProps, renderExpirationTime), workInProgress.child;

      case 8:
        return reconcileChildren(current$$1, workInProgress, workInProgress.pendingProps.children, renderExpirationTime), workInProgress.child;

      case 12:
        return reconcileChildren(current$$1, workInProgress, workInProgress.pendingProps.children, renderExpirationTime), workInProgress.child;

      case 10:
        a: {
          updateExpirationTime = workInProgress.type._context;
          renderState = workInProgress.pendingProps;
          getDerivedStateFromProps = workInProgress.memoizedProps;
          hasContext = renderState.value;
          pushProvider(workInProgress, hasContext);

          if (null !== getDerivedStateFromProps) {
            var oldValue = getDerivedStateFromProps.value;
            hasContext = is(oldValue, hasContext) ? 0 : ("function" === typeof updateExpirationTime._calculateChangedBits ? updateExpirationTime._calculateChangedBits(oldValue, hasContext) : 1073741823) | 0;

            if (0 === hasContext) {
              if (getDerivedStateFromProps.children === renderState.children && !didPerformWorkStackCursor.current) {
                workInProgress = bailoutOnAlreadyFinishedWork(current$$1, workInProgress, renderExpirationTime);
                break a;
              }
            } else for (oldValue = workInProgress.child, null !== oldValue && (oldValue.return = workInProgress); null !== oldValue;) {
              var list = oldValue.dependencies;

              if (null !== list) {
                getDerivedStateFromProps = oldValue.child;

                for (var dependency = list.firstContext; null !== dependency;) {
                  if (dependency.context === updateExpirationTime && 0 !== (dependency.observedBits & hasContext)) {
                    1 === oldValue.tag && (dependency = createUpdate(renderExpirationTime, null), dependency.tag = 2, enqueueUpdate(oldValue, dependency));
                    oldValue.expirationTime < renderExpirationTime && (oldValue.expirationTime = renderExpirationTime);
                    dependency = oldValue.alternate;
                    null !== dependency && dependency.expirationTime < renderExpirationTime && (dependency.expirationTime = renderExpirationTime);
                    scheduleWorkOnParentPath(oldValue.return, renderExpirationTime);
                    list.expirationTime < renderExpirationTime && (list.expirationTime = renderExpirationTime);
                    break;
                  }

                  dependency = dependency.next;
                }
              } else getDerivedStateFromProps = 10 === oldValue.tag ? oldValue.type === workInProgress.type ? null : oldValue.child : oldValue.child;

              if (null !== getDerivedStateFromProps) getDerivedStateFromProps.return = oldValue;else for (getDerivedStateFromProps = oldValue; null !== getDerivedStateFromProps;) {
                if (getDerivedStateFromProps === workInProgress) {
                  getDerivedStateFromProps = null;
                  break;
                }

                oldValue = getDerivedStateFromProps.sibling;

                if (null !== oldValue) {
                  oldValue.return = getDerivedStateFromProps.return;
                  getDerivedStateFromProps = oldValue;
                  break;
                }

                getDerivedStateFromProps = getDerivedStateFromProps.return;
              }
              oldValue = getDerivedStateFromProps;
            }
          }

          reconcileChildren(current$$1, workInProgress, renderState.children, renderExpirationTime);
          workInProgress = workInProgress.child;
        }

        return workInProgress;

      case 9:
        return renderState = workInProgress.type, hasContext = workInProgress.pendingProps, updateExpirationTime = hasContext.children, prepareToReadContext(workInProgress, renderExpirationTime), renderState = readContext(renderState, hasContext.unstable_observedBits), updateExpirationTime = updateExpirationTime(renderState), workInProgress.effectTag |= 1, reconcileChildren(current$$1, workInProgress, updateExpirationTime, renderExpirationTime), workInProgress.child;

      case 14:
        return renderState = workInProgress.type, hasContext = resolveDefaultProps(renderState, workInProgress.pendingProps), hasContext = resolveDefaultProps(renderState.type, hasContext), updateMemoComponent(current$$1, workInProgress, renderState, hasContext, updateExpirationTime, renderExpirationTime);

      case 15:
        return updateSimpleMemoComponent(current$$1, workInProgress, workInProgress.type, workInProgress.pendingProps, updateExpirationTime, renderExpirationTime);

      case 17:
        return updateExpirationTime = workInProgress.type, renderState = workInProgress.pendingProps, renderState = workInProgress.elementType === updateExpirationTime ? renderState : resolveDefaultProps(updateExpirationTime, renderState), null !== current$$1 && (current$$1.alternate = null, workInProgress.alternate = null, workInProgress.effectTag |= 2), workInProgress.tag = 1, isContextProvider(updateExpirationTime) ? (current$$1 = !0, pushContextProvider(workInProgress)) : current$$1 = !1, prepareToReadContext(workInProgress, renderExpirationTime), constructClassInstance(workInProgress, updateExpirationTime, renderState, renderExpirationTime), mountClassInstance(workInProgress, updateExpirationTime, renderState, renderExpirationTime), finishClassComponent(null, workInProgress, updateExpirationTime, !0, current$$1, renderExpirationTime);

      case 19:
        return updateSuspenseListComponent(current$$1, workInProgress, renderExpirationTime);
    }

    throw ReactError(Error("Unknown unit of work tag. This error is likely caused by a bug in React. Please file an issue."));
  };

  var onCommitFiberRoot = null,
      onCommitFiberUnmount = null;

  function injectInternals(internals) {
    if ("undefined" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__) return !1;
    var hook = __REACT_DEVTOOLS_GLOBAL_HOOK__;
    if (hook.isDisabled || !hook.supportsFiber) return !0;

    try {
      var rendererID = hook.inject(internals);

      onCommitFiberRoot = function onCommitFiberRoot(root) {
        try {
          hook.onCommitFiberRoot(rendererID, root, void 0, 64 === (root.current.effectTag & 64));
        } catch (err) {}
      };

      onCommitFiberUnmount = function onCommitFiberUnmount(fiber) {
        try {
          hook.onCommitFiberUnmount(rendererID, fiber);
        } catch (err) {}
      };
    } catch (err) {}

    return !0;
  }

  function FiberNode(tag, pendingProps, key, mode) {
    this.tag = tag;
    this.key = key;
    this.sibling = this.child = this.return = this.stateNode = this.type = this.elementType = null;
    this.index = 0;
    this.ref = null;
    this.pendingProps = pendingProps;
    this.dependencies = this.memoizedState = this.updateQueue = this.memoizedProps = null;
    this.mode = mode;
    this.effectTag = 0;
    this.lastEffect = this.firstEffect = this.nextEffect = null;
    this.childExpirationTime = this.expirationTime = 0;
    this.alternate = null;
  }

  function createFiber(tag, pendingProps, key, mode) {
    return new FiberNode(tag, pendingProps, key, mode);
  }

  function shouldConstruct(Component) {
    Component = Component.prototype;
    return !(!Component || !Component.isReactComponent);
  }

  function resolveLazyComponentTag(Component) {
    if ("function" === typeof Component) return shouldConstruct(Component) ? 1 : 0;

    if (void 0 !== Component && null !== Component) {
      Component = Component.$$typeof;
      if (Component === REACT_FORWARD_REF_TYPE) return 11;
      if (Component === REACT_MEMO_TYPE) return 14;
    }

    return 2;
  }

  function createWorkInProgress(current, pendingProps) {
    var workInProgress = current.alternate;
    null === workInProgress ? (workInProgress = createFiber(current.tag, pendingProps, current.key, current.mode), workInProgress.elementType = current.elementType, workInProgress.type = current.type, workInProgress.stateNode = current.stateNode, workInProgress.alternate = current, current.alternate = workInProgress) : (workInProgress.pendingProps = pendingProps, workInProgress.effectTag = 0, workInProgress.nextEffect = null, workInProgress.firstEffect = null, workInProgress.lastEffect = null);
    workInProgress.childExpirationTime = current.childExpirationTime;
    workInProgress.expirationTime = current.expirationTime;
    workInProgress.child = current.child;
    workInProgress.memoizedProps = current.memoizedProps;
    workInProgress.memoizedState = current.memoizedState;
    workInProgress.updateQueue = current.updateQueue;
    pendingProps = current.dependencies;
    workInProgress.dependencies = null === pendingProps ? null : {
      expirationTime: pendingProps.expirationTime,
      firstContext: pendingProps.firstContext,
      responders: pendingProps.responders
    };
    workInProgress.sibling = current.sibling;
    workInProgress.index = current.index;
    workInProgress.ref = current.ref;
    return workInProgress;
  }

  function createFiberFromTypeAndProps(type, key, pendingProps, owner, mode, expirationTime) {
    var fiberTag = 2;
    owner = type;
    if ("function" === typeof type) shouldConstruct(type) && (fiberTag = 1);else if ("string" === typeof type) fiberTag = 5;else a: switch (type) {
      case REACT_FRAGMENT_TYPE:
        return createFiberFromFragment(pendingProps.children, mode, expirationTime, key);

      case REACT_CONCURRENT_MODE_TYPE:
        fiberTag = 8;
        mode |= 7;
        break;

      case REACT_STRICT_MODE_TYPE:
        fiberTag = 8;
        mode |= 1;
        break;

      case REACT_PROFILER_TYPE:
        return type = createFiber(12, pendingProps, key, mode | 8), type.elementType = REACT_PROFILER_TYPE, type.type = REACT_PROFILER_TYPE, type.expirationTime = expirationTime, type;

      case REACT_SUSPENSE_TYPE:
        return type = createFiber(13, pendingProps, key, mode), type.type = REACT_SUSPENSE_TYPE, type.elementType = REACT_SUSPENSE_TYPE, type.expirationTime = expirationTime, type;

      case REACT_SUSPENSE_LIST_TYPE:
        return type = createFiber(19, pendingProps, key, mode), type.elementType = REACT_SUSPENSE_LIST_TYPE, type.expirationTime = expirationTime, type;

      default:
        if ("object" === typeof type && null !== type) switch (type.$$typeof) {
          case REACT_PROVIDER_TYPE:
            fiberTag = 10;
            break a;

          case REACT_CONTEXT_TYPE:
            fiberTag = 9;
            break a;

          case REACT_FORWARD_REF_TYPE:
            fiberTag = 11;
            break a;

          case REACT_MEMO_TYPE:
            fiberTag = 14;
            break a;

          case REACT_LAZY_TYPE:
            fiberTag = 16;
            owner = null;
            break a;
        }
        throw ReactError(Error("Element type is invalid: expected a string (for built-in components) or a class/function (for composite components) but got: " + (null == type ? type : typeof type) + "."));
    }
    key = createFiber(fiberTag, pendingProps, key, mode);
    key.elementType = type;
    key.type = owner;
    key.expirationTime = expirationTime;
    return key;
  }

  function createFiberFromFragment(elements, mode, expirationTime, key) {
    elements = createFiber(7, elements, key, mode);
    elements.expirationTime = expirationTime;
    return elements;
  }

  function createFiberFromText(content, mode, expirationTime) {
    content = createFiber(6, content, null, mode);
    content.expirationTime = expirationTime;
    return content;
  }

  function createFiberFromPortal(portal, mode, expirationTime) {
    mode = createFiber(4, null !== portal.children ? portal.children : [], portal.key, mode);
    mode.expirationTime = expirationTime;
    mode.stateNode = {
      containerInfo: portal.containerInfo,
      pendingChildren: null,
      implementation: portal.implementation
    };
    return mode;
  }

  function FiberRootNode(containerInfo, tag, hydrate) {
    this.tag = tag;
    this.current = null;
    this.containerInfo = containerInfo;
    this.pingCache = this.pendingChildren = null;
    this.finishedExpirationTime = 0;
    this.finishedWork = null;
    this.timeoutHandle = -1;
    this.pendingContext = this.context = null;
    this.hydrate = hydrate;
    this.callbackNode = this.firstBatch = null;
    this.pingTime = this.lastPendingTime = this.firstPendingTime = this.callbackExpirationTime = 0;
  }

  function findHostInstance(component) {
    var fiber = component._reactInternalFiber;

    if (void 0 === fiber) {
      if ("function" === typeof component.render) throw ReactError(Error("Unable to find node on an unmounted component."));
      throw ReactError(Error("Argument appears to not be a ReactComponent. Keys: " + Object.keys(component)));
    }

    component = findCurrentHostFiber(fiber);
    return null === component ? null : component.stateNode;
  }

  function updateContainer(element, container, parentComponent, callback) {
    var current$$1 = container.current,
        currentTime = requestCurrentTime(),
        suspenseConfig = ReactCurrentBatchConfig.suspense;
    current$$1 = computeExpirationForFiber(currentTime, current$$1, suspenseConfig);
    currentTime = container.current;

    a: if (parentComponent) {
      parentComponent = parentComponent._reactInternalFiber;

      b: {
        if (2 !== isFiberMountedImpl(parentComponent) || 1 !== parentComponent.tag) throw ReactError(Error("Expected subtree parent to be a mounted class component. This error is likely caused by a bug in React. Please file an issue."));
        var parentContext = parentComponent;

        do {
          switch (parentContext.tag) {
            case 3:
              parentContext = parentContext.stateNode.context;
              break b;

            case 1:
              if (isContextProvider(parentContext.type)) {
                parentContext = parentContext.stateNode.__reactInternalMemoizedMergedChildContext;
                break b;
              }

          }

          parentContext = parentContext.return;
        } while (null !== parentContext);

        throw ReactError(Error("Found unexpected detached subtree parent. This error is likely caused by a bug in React. Please file an issue."));
      }

      if (1 === parentComponent.tag) {
        var Component = parentComponent.type;

        if (isContextProvider(Component)) {
          parentComponent = processChildContext(parentComponent, Component, parentContext);
          break a;
        }
      }

      parentComponent = parentContext;
    } else parentComponent = emptyContextObject;

    null === container.context ? container.context = parentComponent : container.pendingContext = parentComponent;
    container = callback;
    suspenseConfig = createUpdate(current$$1, suspenseConfig);
    suspenseConfig.payload = {
      element: element
    };
    container = void 0 === container ? null : container;
    null !== container && (suspenseConfig.callback = container);
    enqueueUpdate(currentTime, suspenseConfig);
    scheduleUpdateOnFiber(currentTime, current$$1);
    return current$$1;
  }

  function _createPortal(children, containerInfo, implementation) {
    var key = 3 < arguments.length && void 0 !== arguments[3] ? arguments[3] : null;
    return {
      $$typeof: REACT_PORTAL_TYPE,
      key: null == key ? null : "" + key,
      children: children,
      containerInfo: containerInfo,
      implementation: implementation
    };
  }

  function _inherits$1(subClass, superClass) {
    if ("function" !== typeof superClass && null !== superClass) throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
    subClass.prototype = Object.create(superClass && superClass.prototype, {
      constructor: {
        value: subClass,
        enumerable: !1,
        writable: !0,
        configurable: !0
      }
    });
    superClass && (Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass);
  }

  var getInspectorDataForViewTag = void 0;

  getInspectorDataForViewTag = function getInspectorDataForViewTag() {
    throw ReactError(Error("getInspectorDataForViewTag() is not available in production"));
  };

  var fabricDispatchCommand = nativeFabricUIManager.dispatchCommand;

  function findNodeHandle(componentOrHandle) {
    if (null == componentOrHandle) return null;
    if ("number" === typeof componentOrHandle) return componentOrHandle;
    if (componentOrHandle._nativeTag) return componentOrHandle._nativeTag;
    if (componentOrHandle.canonical && componentOrHandle.canonical._nativeTag) return componentOrHandle.canonical._nativeTag;
    componentOrHandle = findHostInstance(componentOrHandle);
    return null == componentOrHandle ? componentOrHandle : componentOrHandle.canonical ? componentOrHandle.canonical._nativeTag : componentOrHandle._nativeTag;
  }

  batchedUpdatesImpl = function batchedUpdatesImpl(fn, a) {
    var prevExecutionContext = executionContext;
    executionContext |= 1;

    try {
      return fn(a);
    } finally {
      executionContext = prevExecutionContext, executionContext === NoContext && flushSyncCallbackQueue();
    }
  };

  flushDiscreteUpdatesImpl = function flushDiscreteUpdatesImpl() {
    (executionContext & (1 | RenderContext | CommitContext)) === NoContext && (flushPendingDiscreteUpdates(), flushPassiveEffects());
  };

  var roots = new Map(),
      ReactFabric = {
    NativeComponent: function (findNodeHandle, findHostInstance) {
      return function (_React$Component) {
        function ReactNativeComponent() {
          if (!(this instanceof ReactNativeComponent)) throw new TypeError("Cannot call a class as a function");

          var call = _React$Component.apply(this, arguments);

          if (!this) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
          return !call || "object" !== typeof call && "function" !== typeof call ? this : call;
        }

        _inherits$1(ReactNativeComponent, _React$Component);

        ReactNativeComponent.prototype.blur = function () {
          ReactNativePrivateInterface.TextInputState.blurTextInput(findNodeHandle(this));
        };

        ReactNativeComponent.prototype.focus = function () {
          ReactNativePrivateInterface.TextInputState.focusTextInput(findNodeHandle(this));
        };

        ReactNativeComponent.prototype.measure = function (callback) {
          var maybeInstance = void 0;

          try {
            maybeInstance = findHostInstance(this);
          } catch (error) {}

          null != maybeInstance && (maybeInstance.canonical ? nativeFabricUIManager.measure(maybeInstance.node, mountSafeCallback_NOT_REALLY_SAFE(this, callback)) : ReactNativePrivateInterface.UIManager.measure(findNodeHandle(this), mountSafeCallback_NOT_REALLY_SAFE(this, callback)));
        };

        ReactNativeComponent.prototype.measureInWindow = function (callback) {
          var maybeInstance = void 0;

          try {
            maybeInstance = findHostInstance(this);
          } catch (error) {}

          null != maybeInstance && (maybeInstance.canonical ? nativeFabricUIManager.measureInWindow(maybeInstance.node, mountSafeCallback_NOT_REALLY_SAFE(this, callback)) : ReactNativePrivateInterface.UIManager.measureInWindow(findNodeHandle(this), mountSafeCallback_NOT_REALLY_SAFE(this, callback)));
        };

        ReactNativeComponent.prototype.measureLayout = function (relativeToNativeNode, onSuccess, onFail) {
          var maybeInstance = void 0;

          try {
            maybeInstance = findHostInstance(this);
          } catch (error) {}

          null == maybeInstance || maybeInstance.canonical || (maybeInstance = void 0, "number" === typeof relativeToNativeNode ? maybeInstance = relativeToNativeNode : relativeToNativeNode._nativeTag && (maybeInstance = relativeToNativeNode._nativeTag), null != maybeInstance && ReactNativePrivateInterface.UIManager.measureLayout(findNodeHandle(this), maybeInstance, mountSafeCallback_NOT_REALLY_SAFE(this, onFail), mountSafeCallback_NOT_REALLY_SAFE(this, onSuccess)));
        };

        ReactNativeComponent.prototype.setNativeProps = function (nativeProps) {
          var maybeInstance = void 0;

          try {
            maybeInstance = findHostInstance(this);
          } catch (error) {}

          if (null != maybeInstance && !maybeInstance.canonical) {
            var nativeTag = maybeInstance._nativeTag || maybeInstance.canonical._nativeTag;
            maybeInstance = maybeInstance.viewConfig || maybeInstance.canonical.viewConfig;
            nativeProps = diffProperties(null, emptyObject, nativeProps, maybeInstance.validAttributes);
            null != nativeProps && ReactNativePrivateInterface.UIManager.updateView(nativeTag, maybeInstance.uiViewClassName, nativeProps);
          }
        };

        return ReactNativeComponent;
      }(React.Component);
    }(findNodeHandle, findHostInstance),
    findNodeHandle: findNodeHandle,
    setNativeProps: function setNativeProps() {},
    dispatchCommand: function dispatchCommand(handle, command, args) {
      null != handle._nativeTag && null != handle._internalInstanceHandle && fabricDispatchCommand(handle._internalInstanceHandle.stateNode.node, command, args);
    },
    render: function render(element, containerTag, callback) {
      var root = roots.get(containerTag);

      if (!root) {
        root = new FiberRootNode(containerTag, 0, !1);
        var uninitializedFiber = createFiber(3, null, null, 0);
        root.current = uninitializedFiber;
        uninitializedFiber.stateNode = root;
        roots.set(containerTag, root);
      }

      updateContainer(element, root, null, callback);

      a: if (element = root.current, element.child) switch (element.child.tag) {
        case 5:
          element = element.child.stateNode.canonical;
          break a;

        default:
          element = element.child.stateNode;
      } else element = null;

      return element;
    },
    unmountComponentAtNode: function unmountComponentAtNode(containerTag) {
      var root = roots.get(containerTag);
      root && updateContainer(null, root, null, function () {
        roots.delete(containerTag);
      });
    },
    createPortal: function createPortal(children, containerTag) {
      return _createPortal(children, containerTag, null, 2 < arguments.length && void 0 !== arguments[2] ? arguments[2] : null);
    },
    __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED: {
      NativeMethodsMixin: function (findNodeHandle, findHostInstance) {
        return {
          measure: function measure(callback) {
            var maybeInstance = void 0;

            try {
              maybeInstance = findHostInstance(this);
            } catch (error) {}

            null != maybeInstance && (maybeInstance.canonical ? nativeFabricUIManager.measure(maybeInstance.node, mountSafeCallback_NOT_REALLY_SAFE(this, callback)) : ReactNativePrivateInterface.UIManager.measure(findNodeHandle(this), mountSafeCallback_NOT_REALLY_SAFE(this, callback)));
          },
          measureInWindow: function measureInWindow(callback) {
            var maybeInstance = void 0;

            try {
              maybeInstance = findHostInstance(this);
            } catch (error) {}

            null != maybeInstance && (maybeInstance.canonical ? nativeFabricUIManager.measureInWindow(maybeInstance.node, mountSafeCallback_NOT_REALLY_SAFE(this, callback)) : ReactNativePrivateInterface.UIManager.measureInWindow(findNodeHandle(this), mountSafeCallback_NOT_REALLY_SAFE(this, callback)));
          },
          measureLayout: function measureLayout(relativeToNativeNode, onSuccess, onFail) {
            var maybeInstance = void 0;

            try {
              maybeInstance = findHostInstance(this);
            } catch (error) {}

            null == maybeInstance || maybeInstance.canonical || (maybeInstance = void 0, "number" === typeof relativeToNativeNode ? maybeInstance = relativeToNativeNode : relativeToNativeNode._nativeTag && (maybeInstance = relativeToNativeNode._nativeTag), null != maybeInstance && ReactNativePrivateInterface.UIManager.measureLayout(findNodeHandle(this), maybeInstance, mountSafeCallback_NOT_REALLY_SAFE(this, onFail), mountSafeCallback_NOT_REALLY_SAFE(this, onSuccess)));
          },
          setNativeProps: function setNativeProps(nativeProps) {
            var maybeInstance = void 0;

            try {
              maybeInstance = findHostInstance(this);
            } catch (error) {}

            if (null != maybeInstance && !maybeInstance.canonical) {
              var nativeTag = maybeInstance._nativeTag || maybeInstance.canonical._nativeTag;
              maybeInstance = maybeInstance.viewConfig || maybeInstance.canonical.viewConfig;
              nativeProps = diffProperties(null, emptyObject, nativeProps, maybeInstance.validAttributes);
              null != nativeProps && ReactNativePrivateInterface.UIManager.updateView(nativeTag, maybeInstance.uiViewClassName, nativeProps);
            }
          },
          focus: function focus() {
            ReactNativePrivateInterface.TextInputState.focusTextInput(findNodeHandle(this));
          },
          blur: function blur() {
            ReactNativePrivateInterface.TextInputState.blurTextInput(findNodeHandle(this));
          }
        };
      }(findNodeHandle, findHostInstance)
    }
  };

  (function (devToolsConfig) {
    var _findFiberByHostInstance = devToolsConfig.findFiberByHostInstance;
    return injectInternals(_extends({}, devToolsConfig, {
      overrideHookState: null,
      overrideProps: null,
      setSuspenseHandler: null,
      scheduleUpdate: null,
      currentDispatcherRef: ReactSharedInternals.ReactCurrentDispatcher,
      findHostInstanceByFiber: function findHostInstanceByFiber(fiber) {
        fiber = findCurrentHostFiber(fiber);
        return null === fiber ? null : fiber.stateNode;
      },
      findFiberByHostInstance: function findFiberByHostInstance(instance) {
        return _findFiberByHostInstance ? _findFiberByHostInstance(instance) : null;
      },
      findHostInstancesForRefresh: null,
      scheduleRefresh: null,
      scheduleRoot: null,
      setRefreshHandler: null,
      getCurrentFiber: null
    }));
  })({
    findFiberByHostInstance: getInstanceFromInstance,
    getInspectorDataForViewTag: getInspectorDataForViewTag,
    bundleType: 0,
    version: "16.8.6",
    rendererPackageName: "react-native-renderer"
  });

  var ReactFabric$2 = {
    default: ReactFabric
  },
      ReactFabric$3 = ReactFabric$2 && ReactFabric || ReactFabric$2;
  module.exports = ReactFabric$3.default || ReactFabric$3;
},419,[13,90,192,54,198],"node_modules/react-native/Libraries/Renderer/implementations/ReactFabric-prod.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _slicedToArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/slicedToArray"));

  var _NativeAsyncStorage = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "./NativeAsyncStorage"));

  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "invariant"));

  var RCTAsyncStorage = _NativeAsyncStorage.default;
  var AsyncStorage = {
    _getRequests: [],
    _getKeys: [],
    _immediate: null,
    getItem: function getItem(key, callback) {
      (0, _invariant.default)(RCTAsyncStorage, 'RCTAsyncStorage not available');
      return new Promise(function (resolve, reject) {
        RCTAsyncStorage.multiGet([key], function (errors, result) {
          var value = result && result[0] && result[0][1] ? result[0][1] : null;
          var errs = convertErrors(errors);
          callback && callback(errs && errs[0], value);

          if (errs) {
            reject(errs[0]);
          } else {
            resolve(value);
          }
        });
      });
    },
    setItem: function setItem(key, value, callback) {
      (0, _invariant.default)(RCTAsyncStorage, 'RCTAsyncStorage not available');
      return new Promise(function (resolve, reject) {
        RCTAsyncStorage.multiSet([[key, value]], function (errors) {
          var errs = convertErrors(errors);
          callback && callback(errs && errs[0]);

          if (errs) {
            reject(errs[0]);
          } else {
            resolve(null);
          }
        });
      });
    },
    removeItem: function removeItem(key, callback) {
      (0, _invariant.default)(RCTAsyncStorage, 'RCTAsyncStorage not available');
      return new Promise(function (resolve, reject) {
        RCTAsyncStorage.multiRemove([key], function (errors) {
          var errs = convertErrors(errors);
          callback && callback(errs && errs[0]);

          if (errs) {
            reject(errs[0]);
          } else {
            resolve(null);
          }
        });
      });
    },
    mergeItem: function mergeItem(key, value, callback) {
      (0, _invariant.default)(RCTAsyncStorage, 'RCTAsyncStorage not available');
      return new Promise(function (resolve, reject) {
        RCTAsyncStorage.multiMerge([[key, value]], function (errors) {
          var errs = convertErrors(errors);
          callback && callback(errs && errs[0]);

          if (errs) {
            reject(errs[0]);
          } else {
            resolve(null);
          }
        });
      });
    },
    clear: function clear(callback) {
      (0, _invariant.default)(RCTAsyncStorage, 'RCTAsyncStorage not available');
      return new Promise(function (resolve, reject) {
        RCTAsyncStorage.clear(function (error) {
          callback && callback(convertError(error));

          if (error && convertError(error)) {
            reject(convertError(error));
          } else {
            resolve(null);
          }
        });
      });
    },
    getAllKeys: function getAllKeys(callback) {
      (0, _invariant.default)(RCTAsyncStorage, 'RCTAsyncStorage not available');
      return new Promise(function (resolve, reject) {
        RCTAsyncStorage.getAllKeys(function (error, keys) {
          callback && callback(convertError(error), keys);

          if (error) {
            reject(convertError(error));
          } else {
            resolve(keys);
          }
        });
      });
    },
    flushGetRequests: function flushGetRequests() {
      var getRequests = this._getRequests;
      var getKeys = this._getKeys;
      this._getRequests = [];
      this._getKeys = [];
      (0, _invariant.default)(RCTAsyncStorage, 'RCTAsyncStorage not available');
      RCTAsyncStorage.multiGet(getKeys, function (errors, result) {
        var map = {};
        result && result.forEach(function (_ref) {
          var _ref2 = (0, _slicedToArray2.default)(_ref, 2),
              key = _ref2[0],
              value = _ref2[1];

          map[key] = value;
          return value;
        });
        var reqLength = getRequests.length;

        for (var i = 0; i < reqLength; i++) {
          var request = getRequests[i];
          var requestKeys = request.keys;
          var requestResult = requestKeys.map(function (key) {
            return [key, map[key]];
          });
          request.callback && request.callback(null, requestResult);
          request.resolve && request.resolve(requestResult);
        }
      });
    },
    multiGet: function multiGet(keys, callback) {
      var _this = this;

      if (!this._immediate) {
        this._immediate = setImmediate(function () {
          _this._immediate = null;

          _this.flushGetRequests();
        });
      }

      var getRequest = {
        keys: keys,
        callback: callback,
        keyIndex: this._getKeys.length,
        resolve: null,
        reject: null
      };
      var promiseResult = new Promise(function (resolve, reject) {
        getRequest.resolve = resolve;
        getRequest.reject = reject;
      });

      this._getRequests.push(getRequest);

      keys.forEach(function (key) {
        if (_this._getKeys.indexOf(key) === -1) {
          _this._getKeys.push(key);
        }
      });
      return promiseResult;
    },
    multiSet: function multiSet(keyValuePairs, callback) {
      (0, _invariant.default)(RCTAsyncStorage, 'RCTAsyncStorage not available');
      return new Promise(function (resolve, reject) {
        RCTAsyncStorage.multiSet(keyValuePairs, function (errors) {
          var error = convertErrors(errors);
          callback && callback(error);

          if (error) {
            reject(error);
          } else {
            resolve(null);
          }
        });
      });
    },
    multiRemove: function multiRemove(keys, callback) {
      (0, _invariant.default)(RCTAsyncStorage, 'RCTAsyncStorage not available');
      return new Promise(function (resolve, reject) {
        RCTAsyncStorage.multiRemove(keys, function (errors) {
          var error = convertErrors(errors);
          callback && callback(error);

          if (error) {
            reject(error);
          } else {
            resolve(null);
          }
        });
      });
    },
    multiMerge: function multiMerge(keyValuePairs, callback) {
      (0, _invariant.default)(RCTAsyncStorage, 'RCTAsyncStorage not available');
      return new Promise(function (resolve, reject) {
        RCTAsyncStorage.multiMerge(keyValuePairs, function (errors) {
          var error = convertErrors(errors);
          callback && callback(error);

          if (error) {
            reject(error);
          } else {
            resolve(null);
          }
        });
      });
    }
  };

  if (!RCTAsyncStorage.multiMerge) {
    delete AsyncStorage.mergeItem;
    delete AsyncStorage.multiMerge;
  }

  function convertErrors(errs) {
    if (!errs) {
      return null;
    }

    return (Array.isArray(errs) ? errs : [errs]).map(function (e) {
      return convertError(e);
    });
  }

  function convertError(error) {
    if (!error) {
      return null;
    }

    var out = new Error(error.message);
    out.key = error.key;
    return out;
  }

  module.exports = AsyncStorage;
},420,[1,14,421,3],"node_modules/react-native/Libraries/Storage/AsyncStorage.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireWildcard");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[1], "../TurboModule/TurboModuleRegistry"));

  var _default = TurboModuleRegistry.get('AsyncSQLiteDBStorage') || TurboModuleRegistry.get('AsyncLocalStorage');

  exports.default = _default;
},421,[9,11],"node_modules/react-native/Libraries/Storage/NativeAsyncStorage.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _NativeClipboard = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./NativeClipboard"));

  module.exports = {
    getString: function getString() {
      return _NativeClipboard.default.getString();
    },
    setString: function setString(content) {
      _NativeClipboard.default.setString(content);
    }
  };
},422,[1,423],"node_modules/react-native/Libraries/Components/Clipboard/Clipboard.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireWildcard");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[1], "../../TurboModule/TurboModuleRegistry"));

  var _default = TurboModuleRegistry.getEnforcing('Clipboard');

  exports.default = _default;
},423,[9,11],"node_modules/react-native/Libraries/Components/Clipboard/NativeClipboard.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _regenerator = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/regenerator"));

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass"));

  var _NativeDatePickerAndroid = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "./NativeDatePickerAndroid"));

  function _toMillis(options, key) {
    var dateVal = options[key];

    if (typeof dateVal === 'object' && typeof dateVal.getMonth === 'function') {
      options[key] = dateVal.getTime();
    }
  }

  var DatePickerAndroid = function () {
    function DatePickerAndroid() {
      (0, _classCallCheck2.default)(this, DatePickerAndroid);
    }

    (0, _createClass2.default)(DatePickerAndroid, null, [{
      key: "open",
      value: function open(options) {
        var optionsMs;
        return _regenerator.default.async(function open$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                optionsMs = options;

                if (optionsMs != null) {
                  _toMillis(optionsMs, 'date');

                  _toMillis(optionsMs, 'minDate');

                  _toMillis(optionsMs, 'maxDate');
                }

                return _context.abrupt("return", _NativeDatePickerAndroid.default.open(options));

              case 3:
              case "end":
                return _context.stop();
            }
          }
        });
      }
    }]);
    return DatePickerAndroid;
  }();

  DatePickerAndroid.dateSetAction = 'dateSetAction';
  DatePickerAndroid.dismissedAction = 'dismissedAction';
  module.exports = DatePickerAndroid;
},424,[1,103,24,25,425],"node_modules/react-native/Libraries/Components/DatePickerAndroid/DatePickerAndroid.android.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireWildcard");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[1], "../../TurboModule/TurboModuleRegistry"));

  var _default = TurboModuleRegistry.getEnforcing('DatePickerAndroid');

  exports.default = _default;
},425,[9,11],"node_modules/react-native/Libraries/Components/DatePickerAndroid/NativeDatePickerAndroid.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _NativeDeviceInfo = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./NativeDeviceInfo"));

  module.exports = _NativeDeviceInfo.default;
},426,[1,63],"node_modules/react-native/Libraries/Utilities/DeviceInfo.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _NativeImagePickerIOS = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./NativeImagePickerIOS"));

  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "invariant"));

  var ImagePickerIOS = {
    canRecordVideos: function canRecordVideos(callback) {
      (0, _invariant.default)(_NativeImagePickerIOS.default, 'ImagePickerIOS is not available');
      return _NativeImagePickerIOS.default.canRecordVideos(callback);
    },
    canUseCamera: function canUseCamera(callback) {
      (0, _invariant.default)(_NativeImagePickerIOS.default, 'ImagePickerIOS is not available');
      return _NativeImagePickerIOS.default.canUseCamera(callback);
    },
    openCameraDialog: function openCameraDialog(config, successCallback, cancelCallback) {
      (0, _invariant.default)(_NativeImagePickerIOS.default, 'ImagePickerIOS is not available');
      var newConfig = {
        videoMode: true,
        unmirrorFrontFacingCamera: false
      };

      if (config.videoMode != null) {
        newConfig.videoMode = config.videoMode;
      }

      if (config.unmirrorFrontFacingCamera != null) {
        newConfig.unmirrorFrontFacingCamera = config.unmirrorFrontFacingCamera;
      }

      return _NativeImagePickerIOS.default.openCameraDialog(newConfig, successCallback, cancelCallback);
    },
    openSelectDialog: function openSelectDialog(config, successCallback, cancelCallback) {
      (0, _invariant.default)(_NativeImagePickerIOS.default, 'ImagePickerIOS is not available');
      var newConfig = {
        showImages: true,
        showVideos: false
      };

      if (config.showImages != null) {
        newConfig.showImages = config.showImages;
      }

      if (config.showVideos != null) {
        newConfig.showVideos = config.showVideos;
      }

      return _NativeImagePickerIOS.default.openSelectDialog(newConfig, successCallback, cancelCallback);
    },
    removePendingVideo: function removePendingVideo(url) {
      (0, _invariant.default)(_NativeImagePickerIOS.default, 'ImagePickerIOS is not available');

      _NativeImagePickerIOS.default.removePendingVideo(url);
    },
    clearAllPendingVideos: function clearAllPendingVideos() {
      (0, _invariant.default)(_NativeImagePickerIOS.default, 'ImagePickerIOS is not available');

      _NativeImagePickerIOS.default.clearAllPendingVideos();
    }
  };
  module.exports = ImagePickerIOS;
},427,[1,428,3],"node_modules/react-native/Libraries/Image/ImagePickerIOS.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireWildcard");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[1], "../TurboModule/TurboModuleRegistry"));

  var _default = TurboModuleRegistry.get('ImagePickerIOS');

  exports.default = _default;
},428,[9,11],"node_modules/react-native/Libraries/Image/NativeImagePickerIOS.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits"));

  var _NativeLinking = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "./NativeLinking"));

  var InteractionManager = _$$_REQUIRE(_dependencyMap[7], "../Interaction/InteractionManager");

  var NativeEventEmitter = _$$_REQUIRE(_dependencyMap[8], "../EventEmitter/NativeEventEmitter");

  var Platform = _$$_REQUIRE(_dependencyMap[9], "../Utilities/Platform");

  var invariant = _$$_REQUIRE(_dependencyMap[10], "invariant");

  var Linking = function (_NativeEventEmitter) {
    (0, _inherits2.default)(Linking, _NativeEventEmitter);

    function Linking() {
      (0, _classCallCheck2.default)(this, Linking);
      return (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(Linking).call(this, _NativeLinking.default));
    }

    (0, _createClass2.default)(Linking, [{
      key: "addEventListener",
      value: function addEventListener(type, handler) {
        this.addListener(type, handler);
      }
    }, {
      key: "removeEventListener",
      value: function removeEventListener(type, handler) {
        this.removeListener(type, handler);
      }
    }, {
      key: "openURL",
      value: function openURL(url) {
        this._validateURL(url);

        return _NativeLinking.default.openURL(url);
      }
    }, {
      key: "canOpenURL",
      value: function canOpenURL(url) {
        this._validateURL(url);

        return _NativeLinking.default.canOpenURL(url);
      }
    }, {
      key: "openSettings",
      value: function openSettings() {
        return _NativeLinking.default.openSettings();
      }
    }, {
      key: "getInitialURL",
      value: function getInitialURL() {
        return "android" === 'android' ? InteractionManager.runAfterInteractions().then(function () {
          return _NativeLinking.default.getInitialURL();
        }) : _NativeLinking.default.getInitialURL();
      }
    }, {
      key: "sendIntent",
      value: function sendIntent(action, extras) {
        if ("android" === 'android') {
          return _NativeLinking.default.sendIntent(action, extras);
        }

        return new Promise(function (resolve, reject) {
          return reject(new Error('Unsupported'));
        });
      }
    }, {
      key: "_validateURL",
      value: function _validateURL(url) {
        invariant(typeof url === 'string', 'Invalid URL: should be a string. Was: ' + url);
        invariant(url, 'Invalid URL: cannot be empty');
      }
    }]);
    return Linking;
  }(NativeEventEmitter);

  module.exports = new Linking();
},429,[1,24,25,32,34,37,430,270,134,48,3],"node_modules/react-native/Libraries/Linking/Linking.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/interopRequireWildcard");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[2], "../TurboModule/TurboModuleRegistry"));

  var _Platform = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../Utilities/Platform"));

  var _default = _Platform.default.OS === 'android' ? TurboModuleRegistry.getEnforcing('IntentAndroid') : TurboModuleRegistry.getEnforcing('LinkingManager');

  exports.default = _default;
},430,[1,9,11,48],"node_modules/react-native/Libraries/Linking/NativeLinking.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var InteractionManager = _$$_REQUIRE(_dependencyMap[0], "./InteractionManager");

  var TouchHistoryMath = _$$_REQUIRE(_dependencyMap[1], "./TouchHistoryMath");

  var currentCentroidXOfTouchesChangedAfter = TouchHistoryMath.currentCentroidXOfTouchesChangedAfter;
  var currentCentroidYOfTouchesChangedAfter = TouchHistoryMath.currentCentroidYOfTouchesChangedAfter;
  var previousCentroidXOfTouchesChangedAfter = TouchHistoryMath.previousCentroidXOfTouchesChangedAfter;
  var previousCentroidYOfTouchesChangedAfter = TouchHistoryMath.previousCentroidYOfTouchesChangedAfter;
  var currentCentroidX = TouchHistoryMath.currentCentroidX;
  var currentCentroidY = TouchHistoryMath.currentCentroidY;
  var PanResponder = {
    _initializeGestureState: function _initializeGestureState(gestureState) {
      gestureState.moveX = 0;
      gestureState.moveY = 0;
      gestureState.x0 = 0;
      gestureState.y0 = 0;
      gestureState.dx = 0;
      gestureState.dy = 0;
      gestureState.vx = 0;
      gestureState.vy = 0;
      gestureState.numberActiveTouches = 0;
      gestureState._accountsForMovesUpTo = 0;
    },
    _updateGestureStateOnMove: function _updateGestureStateOnMove(gestureState, touchHistory) {
      gestureState.numberActiveTouches = touchHistory.numberActiveTouches;
      gestureState.moveX = currentCentroidXOfTouchesChangedAfter(touchHistory, gestureState._accountsForMovesUpTo);
      gestureState.moveY = currentCentroidYOfTouchesChangedAfter(touchHistory, gestureState._accountsForMovesUpTo);
      var movedAfter = gestureState._accountsForMovesUpTo;
      var prevX = previousCentroidXOfTouchesChangedAfter(touchHistory, movedAfter);
      var x = currentCentroidXOfTouchesChangedAfter(touchHistory, movedAfter);
      var prevY = previousCentroidYOfTouchesChangedAfter(touchHistory, movedAfter);
      var y = currentCentroidYOfTouchesChangedAfter(touchHistory, movedAfter);
      var nextDX = gestureState.dx + (x - prevX);
      var nextDY = gestureState.dy + (y - prevY);
      var dt = touchHistory.mostRecentTimeStamp - gestureState._accountsForMovesUpTo;
      gestureState.vx = (nextDX - gestureState.dx) / dt;
      gestureState.vy = (nextDY - gestureState.dy) / dt;
      gestureState.dx = nextDX;
      gestureState.dy = nextDY;
      gestureState._accountsForMovesUpTo = touchHistory.mostRecentTimeStamp;
    },
    create: function create(config) {
      var interactionState = {
        handle: null
      };
      var gestureState = {
        stateID: Math.random(),
        moveX: 0,
        moveY: 0,
        x0: 0,
        y0: 0,
        dx: 0,
        dy: 0,
        vx: 0,
        vy: 0,
        numberActiveTouches: 0,
        _accountsForMovesUpTo: 0
      };
      var panHandlers = {
        onStartShouldSetResponder: function onStartShouldSetResponder(event) {
          return config.onStartShouldSetPanResponder == null ? false : config.onStartShouldSetPanResponder(event, gestureState);
        },
        onMoveShouldSetResponder: function onMoveShouldSetResponder(event) {
          return config.onMoveShouldSetPanResponder == null ? false : config.onMoveShouldSetPanResponder(event, gestureState);
        },
        onStartShouldSetResponderCapture: function onStartShouldSetResponderCapture(event) {
          if (event.nativeEvent.touches.length === 1) {
            PanResponder._initializeGestureState(gestureState);
          }

          gestureState.numberActiveTouches = event.touchHistory.numberActiveTouches;
          return config.onStartShouldSetPanResponderCapture != null ? config.onStartShouldSetPanResponderCapture(event, gestureState) : false;
        },
        onMoveShouldSetResponderCapture: function onMoveShouldSetResponderCapture(event) {
          var touchHistory = event.touchHistory;

          if (gestureState._accountsForMovesUpTo === touchHistory.mostRecentTimeStamp) {
            return false;
          }

          PanResponder._updateGestureStateOnMove(gestureState, touchHistory);

          return config.onMoveShouldSetPanResponderCapture ? config.onMoveShouldSetPanResponderCapture(event, gestureState) : false;
        },
        onResponderGrant: function onResponderGrant(event) {
          if (!interactionState.handle) {
            interactionState.handle = InteractionManager.createInteractionHandle();
          }

          gestureState.x0 = currentCentroidX(event.touchHistory);
          gestureState.y0 = currentCentroidY(event.touchHistory);
          gestureState.dx = 0;
          gestureState.dy = 0;

          if (config.onPanResponderGrant) {
            config.onPanResponderGrant(event, gestureState);
          }

          return config.onShouldBlockNativeResponder == null ? true : config.onShouldBlockNativeResponder(event, gestureState);
        },
        onResponderReject: function onResponderReject(event) {
          clearInteractionHandle(interactionState, config.onPanResponderReject, event, gestureState);
        },
        onResponderRelease: function onResponderRelease(event) {
          clearInteractionHandle(interactionState, config.onPanResponderRelease, event, gestureState);

          PanResponder._initializeGestureState(gestureState);
        },
        onResponderStart: function onResponderStart(event) {
          var touchHistory = event.touchHistory;
          gestureState.numberActiveTouches = touchHistory.numberActiveTouches;

          if (config.onPanResponderStart) {
            config.onPanResponderStart(event, gestureState);
          }
        },
        onResponderMove: function onResponderMove(event) {
          var touchHistory = event.touchHistory;

          if (gestureState._accountsForMovesUpTo === touchHistory.mostRecentTimeStamp) {
            return;
          }

          PanResponder._updateGestureStateOnMove(gestureState, touchHistory);

          if (config.onPanResponderMove) {
            config.onPanResponderMove(event, gestureState);
          }
        },
        onResponderEnd: function onResponderEnd(event) {
          var touchHistory = event.touchHistory;
          gestureState.numberActiveTouches = touchHistory.numberActiveTouches;
          clearInteractionHandle(interactionState, config.onPanResponderEnd, event, gestureState);
        },
        onResponderTerminate: function onResponderTerminate(event) {
          clearInteractionHandle(interactionState, config.onPanResponderTerminate, event, gestureState);

          PanResponder._initializeGestureState(gestureState);
        },
        onResponderTerminationRequest: function onResponderTerminationRequest(event) {
          return config.onPanResponderTerminationRequest == null ? true : config.onPanResponderTerminationRequest(event, gestureState);
        }
      };
      return {
        panHandlers: panHandlers,
        getInteractionHandle: function getInteractionHandle() {
          return interactionState.handle;
        }
      };
    }
  };

  function clearInteractionHandle(interactionState, callback, event, gestureState) {
    if (interactionState.handle) {
      InteractionManager.clearInteractionHandle(interactionState.handle);
      interactionState.handle = null;
    }

    if (callback) {
      callback(event, gestureState);
    }
  }

  module.exports = PanResponder;
},431,[270,432],"node_modules/react-native/Libraries/Interaction/PanResponder.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var TouchHistoryMath = {
    centroidDimension: function centroidDimension(touchHistory, touchesChangedAfter, isXAxis, ofCurrent) {
      var touchBank = touchHistory.touchBank;
      var total = 0;
      var count = 0;
      var oneTouchData = touchHistory.numberActiveTouches === 1 ? touchHistory.touchBank[touchHistory.indexOfSingleActiveTouch] : null;

      if (oneTouchData !== null) {
        if (oneTouchData.touchActive && oneTouchData.currentTimeStamp > touchesChangedAfter) {
          total += ofCurrent && isXAxis ? oneTouchData.currentPageX : ofCurrent && !isXAxis ? oneTouchData.currentPageY : !ofCurrent && isXAxis ? oneTouchData.previousPageX : oneTouchData.previousPageY;
          count = 1;
        }
      } else {
        for (var i = 0; i < touchBank.length; i++) {
          var touchTrack = touchBank[i];

          if (touchTrack !== null && touchTrack !== undefined && touchTrack.touchActive && touchTrack.currentTimeStamp >= touchesChangedAfter) {
            var toAdd = void 0;

            if (ofCurrent && isXAxis) {
              toAdd = touchTrack.currentPageX;
            } else if (ofCurrent && !isXAxis) {
              toAdd = touchTrack.currentPageY;
            } else if (!ofCurrent && isXAxis) {
              toAdd = touchTrack.previousPageX;
            } else {
              toAdd = touchTrack.previousPageY;
            }

            total += toAdd;
            count++;
          }
        }
      }

      return count > 0 ? total / count : TouchHistoryMath.noCentroid;
    },
    currentCentroidXOfTouchesChangedAfter: function currentCentroidXOfTouchesChangedAfter(touchHistory, touchesChangedAfter) {
      return TouchHistoryMath.centroidDimension(touchHistory, touchesChangedAfter, true, true);
    },
    currentCentroidYOfTouchesChangedAfter: function currentCentroidYOfTouchesChangedAfter(touchHistory, touchesChangedAfter) {
      return TouchHistoryMath.centroidDimension(touchHistory, touchesChangedAfter, false, true);
    },
    previousCentroidXOfTouchesChangedAfter: function previousCentroidXOfTouchesChangedAfter(touchHistory, touchesChangedAfter) {
      return TouchHistoryMath.centroidDimension(touchHistory, touchesChangedAfter, true, false);
    },
    previousCentroidYOfTouchesChangedAfter: function previousCentroidYOfTouchesChangedAfter(touchHistory, touchesChangedAfter) {
      return TouchHistoryMath.centroidDimension(touchHistory, touchesChangedAfter, false, false);
    },
    currentCentroidX: function currentCentroidX(touchHistory) {
      return TouchHistoryMath.centroidDimension(touchHistory, 0, true, true);
    },
    currentCentroidY: function currentCentroidY(touchHistory) {
      return TouchHistoryMath.centroidDimension(touchHistory, 0, false, true);
    },
    noCentroid: -1
  };
  module.exports = TouchHistoryMath;
},432,[],"node_modules/react-native/Libraries/Interaction/TouchHistoryMath.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _defineProperty2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/defineProperty"));

  var _regenerator = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/regenerator"));

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/createClass"));

  var _NativeDialogManagerAndroid = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "../NativeModules/specs/NativeDialogManagerAndroid"));

  var _NativePermissionsAndroid = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "./NativePermissionsAndroid"));

  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "invariant"));

  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

  var Platform = _$$_REQUIRE(_dependencyMap[8], "../Utilities/Platform");

  var PERMISSION_REQUEST_RESULT = Object.freeze({
    GRANTED: 'granted',
    DENIED: 'denied',
    NEVER_ASK_AGAIN: 'never_ask_again'
  });
  var PERMISSIONS = Object.freeze({
    READ_CALENDAR: 'android.permission.READ_CALENDAR',
    WRITE_CALENDAR: 'android.permission.WRITE_CALENDAR',
    CAMERA: 'android.permission.CAMERA',
    READ_CONTACTS: 'android.permission.READ_CONTACTS',
    WRITE_CONTACTS: 'android.permission.WRITE_CONTACTS',
    GET_ACCOUNTS: 'android.permission.GET_ACCOUNTS',
    ACCESS_FINE_LOCATION: 'android.permission.ACCESS_FINE_LOCATION',
    ACCESS_COARSE_LOCATION: 'android.permission.ACCESS_COARSE_LOCATION',
    RECORD_AUDIO: 'android.permission.RECORD_AUDIO',
    READ_PHONE_STATE: 'android.permission.READ_PHONE_STATE',
    CALL_PHONE: 'android.permission.CALL_PHONE',
    READ_CALL_LOG: 'android.permission.READ_CALL_LOG',
    WRITE_CALL_LOG: 'android.permission.WRITE_CALL_LOG',
    ADD_VOICEMAIL: 'com.android.voicemail.permission.ADD_VOICEMAIL',
    USE_SIP: 'android.permission.USE_SIP',
    PROCESS_OUTGOING_CALLS: 'android.permission.PROCESS_OUTGOING_CALLS',
    BODY_SENSORS: 'android.permission.BODY_SENSORS',
    SEND_SMS: 'android.permission.SEND_SMS',
    RECEIVE_SMS: 'android.permission.RECEIVE_SMS',
    READ_SMS: 'android.permission.READ_SMS',
    RECEIVE_WAP_PUSH: 'android.permission.RECEIVE_WAP_PUSH',
    RECEIVE_MMS: 'android.permission.RECEIVE_MMS',
    READ_EXTERNAL_STORAGE: 'android.permission.READ_EXTERNAL_STORAGE',
    WRITE_EXTERNAL_STORAGE: 'android.permission.WRITE_EXTERNAL_STORAGE'
  });

  var PermissionsAndroid = function () {
    function PermissionsAndroid() {
      (0, _classCallCheck2.default)(this, PermissionsAndroid);
      this.PERMISSIONS = PERMISSIONS;
      this.RESULTS = PERMISSION_REQUEST_RESULT;
    }

    (0, _createClass2.default)(PermissionsAndroid, [{
      key: "checkPermission",
      value: function checkPermission(permission) {
        console.warn('"PermissionsAndroid.checkPermission" is deprecated. Use "PermissionsAndroid.check" instead');

        if ("android" !== 'android') {
          console.warn('"PermissionsAndroid" module works only for Android platform.');
          return Promise.resolve(false);
        }

        (0, _invariant.default)(_NativePermissionsAndroid.default, 'PermissionsAndroid is not installed correctly.');
        return _NativePermissionsAndroid.default.checkPermission(permission);
      }
    }, {
      key: "check",
      value: function check(permission) {
        if ("android" !== 'android') {
          console.warn('"PermissionsAndroid" module works only for Android platform.');
          return Promise.resolve(false);
        }

        (0, _invariant.default)(_NativePermissionsAndroid.default, 'PermissionsAndroid is not installed correctly.');
        return _NativePermissionsAndroid.default.checkPermission(permission);
      }
    }, {
      key: "requestPermission",
      value: function requestPermission(permission, rationale) {
        var response;
        return _regenerator.default.async(function requestPermission$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                console.warn('"PermissionsAndroid.requestPermission" is deprecated. Use "PermissionsAndroid.request" instead');

                if (!("android" !== 'android')) {
                  _context.next = 4;
                  break;
                }

                console.warn('"PermissionsAndroid" module works only for Android platform.');
                return _context.abrupt("return", Promise.resolve(false));

              case 4:
                _context.next = 6;
                return _regenerator.default.awrap(this.request(permission, rationale));

              case 6:
                response = _context.sent;
                return _context.abrupt("return", response === this.RESULTS.GRANTED);

              case 8:
              case "end":
                return _context.stop();
            }
          }
        }, null, this);
      }
    }, {
      key: "request",
      value: function request(permission, rationale) {
        var shouldShowRationale;
        return _regenerator.default.async(function request$(_context2) {
          while (1) {
            switch (_context2.prev = _context2.next) {
              case 0:
                if (!("android" !== 'android')) {
                  _context2.next = 3;
                  break;
                }

                console.warn('"PermissionsAndroid" module works only for Android platform.');
                return _context2.abrupt("return", Promise.resolve(this.RESULTS.DENIED));

              case 3:
                (0, _invariant.default)(_NativePermissionsAndroid.default, 'PermissionsAndroid is not installed correctly.');

                if (!rationale) {
                  _context2.next = 10;
                  break;
                }

                _context2.next = 7;
                return _regenerator.default.awrap(_NativePermissionsAndroid.default.shouldShowRequestPermissionRationale(permission));

              case 7:
                shouldShowRationale = _context2.sent;

                if (!(shouldShowRationale && !!_NativeDialogManagerAndroid.default)) {
                  _context2.next = 10;
                  break;
                }

                return _context2.abrupt("return", new Promise(function (resolve, reject) {
                  var options = _objectSpread({}, rationale);

                  _NativeDialogManagerAndroid.default.showAlert(options, function () {
                    return reject(new Error('Error showing rationale'));
                  }, function () {
                    return resolve(_NativePermissionsAndroid.default.requestPermission(permission));
                  });
                }));

              case 10:
                return _context2.abrupt("return", _NativePermissionsAndroid.default.requestPermission(permission));

              case 11:
              case "end":
                return _context2.stop();
            }
          }
        }, null, this);
      }
    }, {
      key: "requestMultiple",
      value: function requestMultiple(permissions) {
        if ("android" !== 'android') {
          console.warn('"PermissionsAndroid" module works only for Android platform.');
          return Promise.resolve({});
        }

        (0, _invariant.default)(_NativePermissionsAndroid.default, 'PermissionsAndroid is not installed correctly.');
        return _NativePermissionsAndroid.default.requestMultiplePermissions(permissions);
      }
    }]);
    return PermissionsAndroid;
  }();

  PermissionsAndroid = new PermissionsAndroid();
  module.exports = PermissionsAndroid;
},433,[1,46,103,24,25,149,434,3,48],"node_modules/react-native/Libraries/PermissionsAndroid/PermissionsAndroid.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireWildcard");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[1], "../TurboModule/TurboModuleRegistry"));

  var _default = TurboModuleRegistry.get('PermissionsAndroid');

  exports.default = _default;
},434,[9,11],"node_modules/react-native/Libraries/PermissionsAndroid/NativePermissionsAndroid.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));

  var _NativePushNotificationManagerIOS = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "./NativePushNotificationManagerIOS"));

  var NativeEventEmitter = _$$_REQUIRE(_dependencyMap[4], "../EventEmitter/NativeEventEmitter");

  var invariant = _$$_REQUIRE(_dependencyMap[5], "invariant");

  var PushNotificationEmitter = new NativeEventEmitter(_NativePushNotificationManagerIOS.default);

  var _notifHandlers = new Map();

  var DEVICE_NOTIF_EVENT = 'remoteNotificationReceived';
  var NOTIF_REGISTER_EVENT = 'remoteNotificationsRegistered';
  var NOTIF_REGISTRATION_ERROR_EVENT = 'remoteNotificationRegistrationError';
  var DEVICE_LOCAL_NOTIF_EVENT = 'localNotificationReceived';

  var PushNotificationIOS = function () {
    (0, _createClass2.default)(PushNotificationIOS, null, [{
      key: "presentLocalNotification",
      value: function presentLocalNotification(details) {
        invariant(_NativePushNotificationManagerIOS.default, 'PushNotificationManager is not available.');

        _NativePushNotificationManagerIOS.default.presentLocalNotification(details);
      }
    }, {
      key: "scheduleLocalNotification",
      value: function scheduleLocalNotification(details) {
        invariant(_NativePushNotificationManagerIOS.default, 'PushNotificationManager is not available.');

        _NativePushNotificationManagerIOS.default.scheduleLocalNotification(details);
      }
    }, {
      key: "cancelAllLocalNotifications",
      value: function cancelAllLocalNotifications() {
        invariant(_NativePushNotificationManagerIOS.default, 'PushNotificationManager is not available.');

        _NativePushNotificationManagerIOS.default.cancelAllLocalNotifications();
      }
    }, {
      key: "removeAllDeliveredNotifications",
      value: function removeAllDeliveredNotifications() {
        invariant(_NativePushNotificationManagerIOS.default, 'PushNotificationManager is not available.');

        _NativePushNotificationManagerIOS.default.removeAllDeliveredNotifications();
      }
    }, {
      key: "getDeliveredNotifications",
      value: function getDeliveredNotifications(callback) {
        invariant(_NativePushNotificationManagerIOS.default, 'PushNotificationManager is not available.');

        _NativePushNotificationManagerIOS.default.getDeliveredNotifications(callback);
      }
    }, {
      key: "removeDeliveredNotifications",
      value: function removeDeliveredNotifications(identifiers) {
        invariant(_NativePushNotificationManagerIOS.default, 'PushNotificationManager is not available.');

        _NativePushNotificationManagerIOS.default.removeDeliveredNotifications(identifiers);
      }
    }, {
      key: "setApplicationIconBadgeNumber",
      value: function setApplicationIconBadgeNumber(number) {
        invariant(_NativePushNotificationManagerIOS.default, 'PushNotificationManager is not available.');

        _NativePushNotificationManagerIOS.default.setApplicationIconBadgeNumber(number);
      }
    }, {
      key: "getApplicationIconBadgeNumber",
      value: function getApplicationIconBadgeNumber(callback) {
        invariant(_NativePushNotificationManagerIOS.default, 'PushNotificationManager is not available.');

        _NativePushNotificationManagerIOS.default.getApplicationIconBadgeNumber(callback);
      }
    }, {
      key: "cancelLocalNotifications",
      value: function cancelLocalNotifications(userInfo) {
        invariant(_NativePushNotificationManagerIOS.default, 'PushNotificationManager is not available.');

        _NativePushNotificationManagerIOS.default.cancelLocalNotifications(userInfo);
      }
    }, {
      key: "getScheduledLocalNotifications",
      value: function getScheduledLocalNotifications(callback) {
        invariant(_NativePushNotificationManagerIOS.default, 'PushNotificationManager is not available.');

        _NativePushNotificationManagerIOS.default.getScheduledLocalNotifications(callback);
      }
    }, {
      key: "addEventListener",
      value: function addEventListener(type, handler) {
        invariant(type === 'notification' || type === 'register' || type === 'registrationError' || type === 'localNotification', 'PushNotificationIOS only supports `notification`, `register`, `registrationError`, and `localNotification` events');
        var listener;

        if (type === 'notification') {
          listener = PushNotificationEmitter.addListener(DEVICE_NOTIF_EVENT, function (notifData) {
            handler(new PushNotificationIOS(notifData));
          });
        } else if (type === 'localNotification') {
          listener = PushNotificationEmitter.addListener(DEVICE_LOCAL_NOTIF_EVENT, function (notifData) {
            handler(new PushNotificationIOS(notifData));
          });
        } else if (type === 'register') {
          listener = PushNotificationEmitter.addListener(NOTIF_REGISTER_EVENT, function (registrationInfo) {
            handler(registrationInfo.deviceToken);
          });
        } else if (type === 'registrationError') {
          listener = PushNotificationEmitter.addListener(NOTIF_REGISTRATION_ERROR_EVENT, function (errorInfo) {
            handler(errorInfo);
          });
        }

        _notifHandlers.set(type, listener);
      }
    }, {
      key: "removeEventListener",
      value: function removeEventListener(type, handler) {
        invariant(type === 'notification' || type === 'register' || type === 'registrationError' || type === 'localNotification', 'PushNotificationIOS only supports `notification`, `register`, `registrationError`, and `localNotification` events');

        var listener = _notifHandlers.get(type);

        if (!listener) {
          return;
        }

        listener.remove();

        _notifHandlers.delete(type);
      }
    }, {
      key: "requestPermissions",
      value: function requestPermissions(permissions) {
        var requestedPermissions = {};

        if (permissions) {
          requestedPermissions = {
            alert: !!permissions.alert,
            badge: !!permissions.badge,
            sound: !!permissions.sound
          };
        } else {
          requestedPermissions = {
            alert: true,
            badge: true,
            sound: true
          };
        }

        invariant(_NativePushNotificationManagerIOS.default, 'PushNotificationManager is not available.');
        return _NativePushNotificationManagerIOS.default.requestPermissions(requestedPermissions);
      }
    }, {
      key: "abandonPermissions",
      value: function abandonPermissions() {
        invariant(_NativePushNotificationManagerIOS.default, 'PushNotificationManager is not available.');

        _NativePushNotificationManagerIOS.default.abandonPermissions();
      }
    }, {
      key: "checkPermissions",
      value: function checkPermissions(callback) {
        invariant(typeof callback === 'function', 'Must provide a valid callback');
        invariant(_NativePushNotificationManagerIOS.default, 'PushNotificationManager is not available.');

        _NativePushNotificationManagerIOS.default.checkPermissions(callback);
      }
    }, {
      key: "getInitialNotification",
      value: function getInitialNotification() {
        invariant(_NativePushNotificationManagerIOS.default, 'PushNotificationManager is not available.');
        return _NativePushNotificationManagerIOS.default.getInitialNotification().then(function (notification) {
          return notification && new PushNotificationIOS(notification);
        });
      }
    }]);

    function PushNotificationIOS(nativeNotif) {
      var _this = this;

      (0, _classCallCheck2.default)(this, PushNotificationIOS);
      this._data = {};
      this._remoteNotificationCompleteCallbackCalled = false;
      this._isRemote = nativeNotif.remote;

      if (this._isRemote) {
        this._notificationId = nativeNotif.notificationId;
      }

      if (nativeNotif.remote) {
        Object.keys(nativeNotif).forEach(function (notifKey) {
          var notifVal = nativeNotif[notifKey];

          if (notifKey === 'aps') {
            _this._alert = notifVal.alert;
            _this._sound = notifVal.sound;
            _this._badgeCount = notifVal.badge;
            _this._category = notifVal.category;
            _this._contentAvailable = notifVal['content-available'];
            _this._threadID = notifVal['thread-id'];
          } else {
            _this._data[notifKey] = notifVal;
          }
        });
      } else {
        this._badgeCount = nativeNotif.applicationIconBadgeNumber;
        this._sound = nativeNotif.soundName;
        this._alert = nativeNotif.alertBody;
        this._data = nativeNotif.userInfo;
        this._category = nativeNotif.category;
      }
    }

    (0, _createClass2.default)(PushNotificationIOS, [{
      key: "finish",
      value: function finish(fetchResult) {
        if (!this._isRemote || !this._notificationId || this._remoteNotificationCompleteCallbackCalled) {
          return;
        }

        this._remoteNotificationCompleteCallbackCalled = true;
        invariant(_NativePushNotificationManagerIOS.default, 'PushNotificationManager is not available.');

        _NativePushNotificationManagerIOS.default.onFinishRemoteNotification(this._notificationId, fetchResult);
      }
    }, {
      key: "getMessage",
      value: function getMessage() {
        return this._alert;
      }
    }, {
      key: "getSound",
      value: function getSound() {
        return this._sound;
      }
    }, {
      key: "getCategory",
      value: function getCategory() {
        return this._category;
      }
    }, {
      key: "getAlert",
      value: function getAlert() {
        return this._alert;
      }
    }, {
      key: "getContentAvailable",
      value: function getContentAvailable() {
        return this._contentAvailable;
      }
    }, {
      key: "getBadgeCount",
      value: function getBadgeCount() {
        return this._badgeCount;
      }
    }, {
      key: "getData",
      value: function getData() {
        return this._data;
      }
    }, {
      key: "getThreadID",
      value: function getThreadID() {
        return this._threadID;
      }
    }]);
    return PushNotificationIOS;
  }();

  PushNotificationIOS.FetchResult = {
    NewData: 'UIBackgroundFetchResultNewData',
    NoData: 'UIBackgroundFetchResultNoData',
    ResultFailed: 'UIBackgroundFetchResultFailed'
  };
  module.exports = PushNotificationIOS;
},435,[1,24,25,436,134,3],"node_modules/react-native/Libraries/PushNotificationIOS/PushNotificationIOS.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireWildcard");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[1], "../TurboModule/TurboModuleRegistry"));

  var _default = TurboModuleRegistry.get('PushNotificationManager');

  exports.default = _default;
},436,[9,11],"node_modules/react-native/Libraries/PushNotificationIOS/NativePushNotificationManagerIOS.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var Settings = {
    get: function get(key) {
      console.warn('Settings is not yet supported on Android');
      return null;
    },
    set: function set(settings) {
      console.warn('Settings is not yet supported on Android');
    },
    watchKeys: function watchKeys(keys, callback) {
      console.warn('Settings is not yet supported on Android');
      return -1;
    },
    clearWatch: function clearWatch(watchId) {
      console.warn('Settings is not yet supported on Android');
    }
  };
  module.exports = Settings;
},437,[],"node_modules/react-native/Libraries/Settings/Settings.android.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));

  var _NativeActionSheetManager = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../ActionSheetIOS/NativeActionSheetManager"));

  var _NativeShareModule = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "./NativeShareModule"));

  var Platform = _$$_REQUIRE(_dependencyMap[5], "../Utilities/Platform");

  var invariant = _$$_REQUIRE(_dependencyMap[6], "invariant");

  var processColor = _$$_REQUIRE(_dependencyMap[7], "../StyleSheet/processColor");

  var Share = function () {
    function Share() {
      (0, _classCallCheck2.default)(this, Share);
    }

    (0, _createClass2.default)(Share, null, [{
      key: "share",
      value: function share(content) {
        var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
        invariant(typeof content === 'object' && content !== null, 'Content to share must be a valid object');
        invariant(typeof content.url === 'string' || typeof content.message === 'string', 'At least one of URL and message is required');
        invariant(typeof options === 'object' && options !== null, 'Options must be a valid object');

        if ("android" === 'android') {
          invariant(_NativeShareModule.default, 'ShareModule should be registered on Android.');
          invariant(!content.title || typeof content.title === 'string', 'Invalid title: title should be a string.');
          var newContent = {
            title: content.title,
            message: typeof content.message === 'string' ? content.message : undefined
          };
          return _NativeShareModule.default.share(newContent, options.dialogTitle);
        } else if ("android" === 'ios') {
          return new Promise(function (resolve, reject) {
            var tintColor = processColor(options.tintColor);
            invariant(_NativeActionSheetManager.default, 'NativeActionSheetManager is not registered on iOS, but it should be.');

            _NativeActionSheetManager.default.showShareActionSheetWithOptions({
              message: typeof content.message === 'string' ? content.message : undefined,
              url: typeof content.url === 'string' ? content.url : undefined,
              subject: options.subject,
              tintColor: tintColor != null ? tintColor : undefined,
              excludedActivityTypes: options.excludedActivityTypes
            }, function (error) {
              return reject(error);
            }, function (success, activityType) {
              if (success) {
                resolve({
                  action: 'sharedAction',
                  activityType: activityType
                });
              } else {
                resolve({
                  action: 'dismissedAction'
                });
              }
            });
          });
        } else {
          return Promise.reject(new Error('Unsupported platform'));
        }
      }
    }]);
    return Share;
  }();

  Share.sharedAction = 'sharedAction';
  Share.dismissedAction = 'dismissedAction';
  module.exports = Share;
},438,[1,24,25,404,439,48,3,80],"node_modules/react-native/Libraries/Share/Share.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireWildcard");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[1], "../TurboModule/TurboModuleRegistry"));

  var _default = TurboModuleRegistry.get('ShareModule');

  exports.default = _default;
},439,[9,11],"node_modules/react-native/Libraries/Share/NativeShareModule.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var NativeEventEmitter = _$$_REQUIRE(_dependencyMap[0], "../../EventEmitter/NativeEventEmitter");

  module.exports = new NativeEventEmitter('StatusBarManager');
},440,[134],"node_modules/react-native/Libraries/Components/StatusBar/StatusBarIOS.android.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _regenerator = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/regenerator"));

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass"));

  var _NativeTimePickerAndroid = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "./NativeTimePickerAndroid"));

  var TimePickerAndroid = function () {
    function TimePickerAndroid() {
      (0, _classCallCheck2.default)(this, TimePickerAndroid);
    }

    (0, _createClass2.default)(TimePickerAndroid, null, [{
      key: "open",
      value: function open(options) {
        return _regenerator.default.async(function open$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                if (!_NativeTimePickerAndroid.default) {
                  _context.next = 4;
                  break;
                }

                return _context.abrupt("return", _NativeTimePickerAndroid.default.open(options));

              case 4:
                return _context.abrupt("return", Promise.reject({
                  message: 'TimePickerAndroid is not supported on this platform.'
                }));

              case 5:
              case "end":
                return _context.stop();
            }
          }
        });
      }
    }]);
    return TimePickerAndroid;
  }();

  TimePickerAndroid.timeSetAction = 'timeSetAction';
  TimePickerAndroid.dismissedAction = 'dismissedAction';
  module.exports = TimePickerAndroid;
},441,[1,103,24,25,442],"node_modules/react-native/Libraries/Components/TimePickerAndroid/TimePickerAndroid.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireWildcard");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[1], "../../TurboModule/TurboModuleRegistry"));

  var _default = TurboModuleRegistry.get('TimePickerAndroid');

  exports.default = _default;
},442,[9,11],"node_modules/react-native/Libraries/Components/TimePickerAndroid/NativeTimePickerAndroid.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireWildcard");

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = useWindowDimensions;

  var _Dimensions = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "./Dimensions"));

  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[3], "react"));

  function useWindowDimensions() {
    var dims = _Dimensions.default.get('window');

    var forceUpdate = React.useState(false)[1].bind(null, function (v) {
      return !v;
    });
    var initialDims = React.useState(dims)[0];
    React.useEffect(function () {
      _Dimensions.default.addEventListener('change', forceUpdate);

      var latestDims = _Dimensions.default.get('window');

      if (latestDims !== initialDims) {
        forceUpdate();
      }

      return function () {
        _Dimensions.default.removeEventListener('change', forceUpdate);
      };
    }, [forceUpdate, initialDims]);
    return dims;
  }
},443,[9,1,62,54],"node_modules/react-native/Libraries/Utilities/useWindowDimensions.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _NativeVibration = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./NativeVibration"));

  var Platform = _$$_REQUIRE(_dependencyMap[2], "../Utilities/Platform");

  var _vibrating = false;
  var _id = 0;

  function vibrateByPattern(pattern) {
    var repeat = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;

    if (_vibrating) {
      return;
    }

    _vibrating = true;

    if (pattern[0] === 0) {
      _NativeVibration.default.vibrate();

      pattern = pattern.slice(1);
    }

    if (pattern.length === 0) {
      _vibrating = false;
      return;
    }

    setTimeout(function () {
      return vibrateScheduler(++_id, pattern, repeat, 1);
    }, pattern[0]);
  }

  function vibrateScheduler(id, pattern, repeat, nextIndex) {
    if (!_vibrating || id !== _id) {
      return;
    }

    _NativeVibration.default.vibrate();

    if (nextIndex >= pattern.length) {
      if (repeat) {
        nextIndex = 0;
      } else {
        _vibrating = false;
        return;
      }
    }

    setTimeout(function () {
      return vibrateScheduler(id, pattern, repeat, nextIndex + 1);
    }, pattern[nextIndex]);
  }

  var Vibration = {
    vibrate: function vibrate() {
      var pattern = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 400;
      var repeat = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;

      if ("android" === 'android') {
        if (typeof pattern === 'number') {
          _NativeVibration.default.vibrate(pattern);
        } else if (Array.isArray(pattern)) {
          _NativeVibration.default.vibrateByPattern(pattern, repeat ? 0 : -1);
        } else {
          throw new Error('Vibration pattern should be a number or array');
        }
      } else {
        if (_vibrating) {
          return;
        }

        if (typeof pattern === 'number') {
          _NativeVibration.default.vibrate();
        } else if (Array.isArray(pattern)) {
          vibrateByPattern(pattern, repeat);
        } else {
          throw new Error('Vibration pattern should be a number or array');
        }
      }
    },
    cancel: function cancel() {
      if ("android" === 'ios') {
        _vibrating = false;
      } else {
        _NativeVibration.default.cancel();
      }
    }
  };
  module.exports = Vibration;
},444,[1,445,48],"node_modules/react-native/Libraries/Vibration/Vibration.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireWildcard");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var TurboModuleRegistry = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[1], "../TurboModule/TurboModuleRegistry"));

  var _default = TurboModuleRegistry.getEnforcing('Vibration');

  exports.default = _default;
},445,[9,11],"node_modules/react-native/Libraries/Vibration/NativeVibration.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var PropTypes = _$$_REQUIRE(_dependencyMap[0], "prop-types");

  var PointPropType = PropTypes.shape({
    x: PropTypes.number,
    y: PropTypes.number
  });
  module.exports = PointPropType;
},446,[69],"node_modules/react-native/Libraries/DeprecatedPropTypes/DeprecatedPointPropType.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits"));

  var _react = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "react"));

  var _reactNavigation = _$$_REQUIRE(_dependencyMap[7], "react-navigation");

  var _reactNavigationTabs = _$$_REQUIRE(_dependencyMap[8], "react-navigation-tabs");

  var _Ionicons = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "react-native-vector-icons/Ionicons"));

  var _home = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[10], "./routes/home"));

  var _help = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[11], "./routes/help"));

  var _contact = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[12], "./routes/contact"));

  var _settings = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[13], "./routes/settings"));

  var _themes = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[14], "./config/themes"));

  var _jsxFileName = "/home/flummi/dev/f0ckapp/src/App.js";
  var AppNavigator = (0, _reactNavigationTabs.createBottomTabNavigator)({
    Home: _home.default,
    Help: _help.default,
    Contact: _contact.default,
    Settings: _settings.default
  }, {
    initialRouteName: "Home",
    tabBarOptions: {
      activeTintColor: _themes.default.foreground,
      labelStyle: {
        fontSize: 12
      },
      style: {
        backgroundColor: _themes.default.background
      }
    },
    defaultNavigationOptions: function defaultNavigationOptions(_ref) {
      var navigation = _ref.navigation;
      return {
        tabBarIcon: function tabBarIcon(_ref2) {
          var focused = _ref2.focused,
              horizontal = _ref2.horizontal,
              tintColor = _ref2.tintColor;
          var routeName = navigation.state.routeName;
          var iconName;

          switch (routeName) {
            case "Home":
              iconName = "ios-home";
              break;

            case "Help":
              iconName = "ios-help-buoy";
              break;

            case "Contact":
              iconName = "ios-call";
              break;

            case "Settings":
              iconName = "ios-settings";
              break;
          }

          return _react.default.createElement(_Ionicons.default, {
            name: iconName,
            size: 25,
            color: tintColor,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 48
            }
          });
        }
      };
    }
  });

  var AppContainer = _c = (0, _reactNavigation.createAppContainer)(AppNavigator);

  var App = function (_React$Component) {
    (0, _inherits2.default)(App, _React$Component);

    function App() {
      (0, _classCallCheck2.default)(this, App);
      return (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(App).apply(this, arguments));
    }

    (0, _createClass2.default)(App, [{
      key: "render",
      value: function render() {
        return _react.default.createElement(AppContainer, {
          __source: {
            fileName: _jsxFileName,
            lineNumber: 56
          }
        });
      }
    }]);
    return App;
  }(_react.default.Component);

  exports.default = App;

  var _c;

  $RefreshReg$(_c, "AppContainer");
},447,[1,24,25,32,34,37,54,448,530,611,776,783,784,785,777],"src/App.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  var _exportNames = {
    createNavigationContainer: true,
    createStackNavigator: true,
    createBottomTabNavigator: true,
    createMaterialTopTabNavigator: true,
    createDrawerNavigator: true,
    StackGestureContext: true,
    DrawerGestureContext: true,
    DrawerRouter: true,
    DrawerActions: true,
    Transitioner: true,
    StackView: true,
    StackViewCard: true,
    StackViewTransitionConfigs: true,
    Header: true,
    HeaderTitle: true,
    HeaderBackButton: true,
    HeaderStyleInterpolator: true,
    DrawerView: true,
    DrawerItems: true,
    DrawerSidebar: true,
    BottomTabBar: true,
    MaterialTopTabBar: true
  };
  Object.defineProperty(exports, "createNavigationContainer", {
    enumerable: true,
    get: function get() {
      return _deprecations.createNavigationContainer;
    }
  });
  Object.defineProperty(exports, "createStackNavigator", {
    enumerable: true,
    get: function get() {
      return _deprecations.createStackNavigator;
    }
  });
  Object.defineProperty(exports, "createBottomTabNavigator", {
    enumerable: true,
    get: function get() {
      return _deprecations.createBottomTabNavigator;
    }
  });
  Object.defineProperty(exports, "createMaterialTopTabNavigator", {
    enumerable: true,
    get: function get() {
      return _deprecations.createMaterialTopTabNavigator;
    }
  });
  Object.defineProperty(exports, "createDrawerNavigator", {
    enumerable: true,
    get: function get() {
      return _deprecations.createDrawerNavigator;
    }
  });
  Object.defineProperty(exports, "StackGestureContext", {
    enumerable: true,
    get: function get() {
      return _deprecations.StackGestureContext;
    }
  });
  Object.defineProperty(exports, "DrawerGestureContext", {
    enumerable: true,
    get: function get() {
      return _deprecations.DrawerGestureContext;
    }
  });
  Object.defineProperty(exports, "DrawerRouter", {
    enumerable: true,
    get: function get() {
      return _deprecations.DrawerRouter;
    }
  });
  Object.defineProperty(exports, "DrawerActions", {
    enumerable: true,
    get: function get() {
      return _deprecations.DrawerActions;
    }
  });
  Object.defineProperty(exports, "Transitioner", {
    enumerable: true,
    get: function get() {
      return _deprecations.Transitioner;
    }
  });
  Object.defineProperty(exports, "StackView", {
    enumerable: true,
    get: function get() {
      return _deprecations.StackView;
    }
  });
  Object.defineProperty(exports, "StackViewCard", {
    enumerable: true,
    get: function get() {
      return _deprecations.StackViewCard;
    }
  });
  Object.defineProperty(exports, "StackViewTransitionConfigs", {
    enumerable: true,
    get: function get() {
      return _deprecations.StackViewTransitionConfigs;
    }
  });
  Object.defineProperty(exports, "Header", {
    enumerable: true,
    get: function get() {
      return _deprecations.Header;
    }
  });
  Object.defineProperty(exports, "HeaderTitle", {
    enumerable: true,
    get: function get() {
      return _deprecations.HeaderTitle;
    }
  });
  Object.defineProperty(exports, "HeaderBackButton", {
    enumerable: true,
    get: function get() {
      return _deprecations.HeaderBackButton;
    }
  });
  Object.defineProperty(exports, "HeaderStyleInterpolator", {
    enumerable: true,
    get: function get() {
      return _deprecations.HeaderStyleInterpolator;
    }
  });
  Object.defineProperty(exports, "DrawerView", {
    enumerable: true,
    get: function get() {
      return _deprecations.DrawerView;
    }
  });
  Object.defineProperty(exports, "DrawerItems", {
    enumerable: true,
    get: function get() {
      return _deprecations.DrawerItems;
    }
  });
  Object.defineProperty(exports, "DrawerSidebar", {
    enumerable: true,
    get: function get() {
      return _deprecations.DrawerSidebar;
    }
  });
  Object.defineProperty(exports, "BottomTabBar", {
    enumerable: true,
    get: function get() {
      return _deprecations.BottomTabBar;
    }
  });
  Object.defineProperty(exports, "MaterialTopTabBar", {
    enumerable: true,
    get: function get() {
      return _deprecations.MaterialTopTabBar;
    }
  });

  var _core = _$$_REQUIRE(_dependencyMap[0], "@react-navigation/core");

  Object.keys(_core).forEach(function (key) {
    if (key === "default" || key === "__esModule") return;
    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
    Object.defineProperty(exports, key, {
      enumerable: true,
      get: function get() {
        return _core[key];
      }
    });
  });

  var _native = _$$_REQUIRE(_dependencyMap[1], "@react-navigation/native");

  Object.keys(_native).forEach(function (key) {
    if (key === "default" || key === "__esModule") return;
    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
    Object.defineProperty(exports, key, {
      enumerable: true,
      get: function get() {
        return _native[key];
      }
    });
  });

  var _deprecations = _$$_REQUIRE(_dependencyMap[2], "./deprecations");
},448,[449,491,529],"node_modules/react-navigation/src/react-navigation.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  module.exports = {
    get StateUtils() {
      return _$$_REQUIRE(_dependencyMap[0], "./StateUtils").default;
    },

    get getNavigation() {
      return _$$_REQUIRE(_dependencyMap[1], "./getNavigation").default;
    },

    get createNavigator() {
      return _$$_REQUIRE(_dependencyMap[2], "./navigators/createNavigator").default;
    },

    get NavigationContext() {
      return _$$_REQUIRE(_dependencyMap[3], "./views/NavigationContext").default;
    },

    get NavigationProvider() {
      return _$$_REQUIRE(_dependencyMap[3], "./views/NavigationContext").default.Provider;
    },

    get NavigationConsumer() {
      return _$$_REQUIRE(_dependencyMap[3], "./views/NavigationContext").default.Consumer;
    },

    get createSwitchNavigator() {
      return _$$_REQUIRE(_dependencyMap[4], "./navigators/createSwitchNavigator").default;
    },

    get ThemeContext() {
      return _$$_REQUIRE(_dependencyMap[5], "./views/ThemeContext").default;
    },

    get ThemeProvider() {
      return _$$_REQUIRE(_dependencyMap[5], "./views/ThemeContext").default.Provider;
    },

    get ThemeConsumer() {
      return _$$_REQUIRE(_dependencyMap[5], "./views/ThemeContext").default.Consumer;
    },

    get ThemeColors() {
      return _$$_REQUIRE(_dependencyMap[6], "./ThemeColors").default;
    },

    get useTheme() {
      return _$$_REQUIRE(_dependencyMap[7], "./useTheme").default;
    },

    get NavigationActions() {
      return _$$_REQUIRE(_dependencyMap[8], "./NavigationActions");
    },

    get StackActions() {
      return _$$_REQUIRE(_dependencyMap[9], "./routers/StackActions");
    },

    get SwitchActions() {
      return _$$_REQUIRE(_dependencyMap[10], "./routers/SwitchActions");
    },

    get StackRouter() {
      return _$$_REQUIRE(_dependencyMap[11], "./routers/StackRouter").default;
    },

    get TabRouter() {
      return _$$_REQUIRE(_dependencyMap[12], "./routers/TabRouter").default;
    },

    get SwitchRouter() {
      return _$$_REQUIRE(_dependencyMap[13], "./routers/SwitchRouter").default;
    },

    get createConfigGetter() {
      return _$$_REQUIRE(_dependencyMap[14], "./routers/createConfigGetter").default;
    },

    get getScreenForRouteName() {
      return _$$_REQUIRE(_dependencyMap[15], "./routers/getScreenForRouteName").default;
    },

    get validateRouteConfigMap() {
      return _$$_REQUIRE(_dependencyMap[16], "./routers/validateRouteConfigMap").default;
    },

    get getActiveChildNavigationOptions() {
      return _$$_REQUIRE(_dependencyMap[17], "./utils/getActiveChildNavigationOptions").default;
    },

    get pathUtils() {
      return _$$_REQUIRE(_dependencyMap[18], "./routers/pathUtils");
    },

    get SceneView() {
      return _$$_REQUIRE(_dependencyMap[19], "./views/SceneView").default;
    },

    get SwitchView() {
      return _$$_REQUIRE(_dependencyMap[20], "./views/SwitchView/SwitchView").default;
    },

    get NavigationEvents() {
      return _$$_REQUIRE(_dependencyMap[21], "./views/NavigationEvents").default;
    },

    get withNavigation() {
      return _$$_REQUIRE(_dependencyMap[22], "./views/withNavigation").default;
    },

    get withNavigationFocus() {
      return _$$_REQUIRE(_dependencyMap[23], "./views/withNavigationFocus").default;
    }

  };
},449,[450,453,460,462,463,461,479,480,455,481,468,482,484,464,466,465,469,486,470,478,477,487,488,490],"node_modules/@react-navigation/core/lib/module/index.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _objectSpread2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/objectSpread"));

  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "./utils/invariant"));

  var StateUtils = {
    get: function get(state, key) {
      return state.routes.find(function (route) {
        return route.key === key;
      }) || null;
    },
    indexOf: function indexOf(state, key) {
      return state.routes.findIndex(function (route) {
        return route.key === key;
      });
    },
    has: function has(state, key) {
      return !!state.routes.some(function (route) {
        return route.key === key;
      });
    },
    push: function push(state, route) {
      (0, _invariant.default)(StateUtils.indexOf(state, route.key) === -1, 'should not push route with duplicated key %s', route.key);
      var routes = state.routes.slice();
      routes.push(route);
      return (0, _objectSpread2.default)({}, state, {
        index: routes.length - 1,
        routes: routes
      });
    },
    pop: function pop(state) {
      if (state.index <= 0) {
        return state;
      }

      var routes = state.routes.slice(0, -1);
      return (0, _objectSpread2.default)({}, state, {
        index: routes.length - 1,
        routes: routes
      });
    },
    jumpToIndex: function jumpToIndex(state, index) {
      if (index === state.index) {
        return state;
      }

      (0, _invariant.default)(!!state.routes[index], 'invalid index %s to jump to', index);
      return (0, _objectSpread2.default)({}, state, {
        index: index
      });
    },
    jumpTo: function jumpTo(state, key) {
      var index = StateUtils.indexOf(state, key);
      return StateUtils.jumpToIndex(state, index);
    },
    back: function back(state) {
      var index = state.index - 1;
      var route = state.routes[index];
      return route ? StateUtils.jumpToIndex(state, index) : state;
    },
    forward: function forward(state) {
      var index = state.index + 1;
      var route = state.routes[index];
      return route ? StateUtils.jumpToIndex(state, index) : state;
    },
    replaceAndPrune: function replaceAndPrune(state, key, route) {
      var index = StateUtils.indexOf(state, key);
      var replaced = StateUtils.replaceAtIndex(state, index, route);
      return (0, _objectSpread2.default)({}, replaced, {
        routes: replaced.routes.slice(0, index + 1)
      });
    },
    replaceAt: function replaceAt(state, key, route) {
      var preserveIndex = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
      var index = StateUtils.indexOf(state, key);
      var nextIndex = preserveIndex ? state.index : index;
      var nextState = StateUtils.replaceAtIndex(state, index, route);
      nextState.index = nextIndex;
      return nextState;
    },
    replaceAtIndex: function replaceAtIndex(state, index, route) {
      (0, _invariant.default)(!!state.routes[index], 'invalid index %s for replacing route %s', index, route.key);

      if (state.routes[index] === route && index === state.index) {
        return state;
      }

      var routes = state.routes.slice();
      routes[index] = route;
      return (0, _objectSpread2.default)({}, state, {
        index: index,
        routes: routes
      });
    },
    reset: function reset(state, routes, index) {
      (0, _invariant.default)(routes.length && Array.isArray(routes), 'invalid routes to replace');
      var nextIndex = index === undefined ? routes.length - 1 : index;

      if (state.routes.length === routes.length && state.index === nextIndex) {
        var compare = function compare(route, ii) {
          return routes[ii] === route;
        };

        if (state.routes.every(compare)) {
          return state;
        }
      }

      (0, _invariant.default)(!!routes[nextIndex], 'invalid index %s to reset', nextIndex);
      return (0, _objectSpread2.default)({}, state, {
        index: nextIndex,
        routes: routes
      });
    }
  };
  var _default = StateUtils;
  exports.default = _default;
},450,[1,451,452],"node_modules/@react-navigation/core/lib/module/StateUtils.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var defineProperty = _$$_REQUIRE(_dependencyMap[0], "./defineProperty");

  function _objectSpread(target) {
    for (var i = 1; i < arguments.length; i++) {
      var source = arguments[i] != null ? Object(arguments[i]) : {};
      var ownKeys = Object.keys(source);

      if (typeof Object.getOwnPropertySymbols === 'function') {
        ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) {
          return Object.getOwnPropertyDescriptor(source, sym).enumerable;
        }));
      }

      ownKeys.forEach(function (key) {
        defineProperty(target, key, source[key]);
      });
    }

    return target;
  }

  module.exports = _objectSpread;
},451,[46],"node_modules/@babel/runtime/helpers/objectSpread.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var validateFormat = function validateFormat() {};

  if (process.env !== 'production') {
    validateFormat = function validateFormat(format) {
      if (format === undefined) {
        throw new Error('invariant requires an error message argument');
      }
    };
  }

  function invariant(condition, format, a, b, c, d, e, f) {
    validateFormat(format);

    if (!condition) {
      var error;

      if (format === undefined) {
        error = new Error('Minified exception occurred; use the non-minified dev environment for the full error message and additional helpful warnings.');
      } else {
        var args = [a, b, c, d, e, f];
        var argIndex = 0;
        error = new Error(format.replace(/%s/g, function () {
          return args[argIndex++];
        }));
        error.name = 'Invariant Violation';
      }

      error.framesToPop = 1;
      throw error;
    }
  }

  module.exports = invariant;
},452,[],"node_modules/@react-navigation/core/lib/module/utils/invariant.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = getNavigation;

  var _objectSpread2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/objectSpread"));

  var _getNavigationActionCreators = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "./routers/getNavigationActionCreators"));

  var _getChildNavigation2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "./getChildNavigation"));

  var _getChildrenNavigationCache = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "./getChildrenNavigationCache"));

  function getNavigation(router, state, dispatch, actionSubscribers, getScreenProps, getCurrentNavigation) {
    var actions = router.getActionCreators(state, null);
    var navigation = {
      actions: actions,
      router: router,
      state: state,
      dispatch: dispatch,
      getScreenProps: getScreenProps,
      getChildNavigation: function getChildNavigation(childKey) {
        return (0, _getChildNavigation2.default)(navigation, childKey, getCurrentNavigation);
      },
      isFocused: function isFocused(childKey) {
        var _getCurrentNavigation = getCurrentNavigation().state,
            routes = _getCurrentNavigation.routes,
            index = _getCurrentNavigation.index;

        if (childKey == null || routes[index].key === childKey) {
          return true;
        }

        return false;
      },
      addListener: function addListener(eventName, handler) {
        if (eventName !== 'action') {
          return {
            remove: function remove() {}
          };
        }

        actionSubscribers.add(handler);
        return {
          remove: function remove() {
            actionSubscribers.delete(handler);
          }
        };
      },
      dangerouslyGetParent: function dangerouslyGetParent() {
        return null;
      },
      isFirstRouteInParent: function isFirstRouteInParent() {
        return true;
      },
      _childrenNavigation: (0, _getChildrenNavigationCache.default)(getCurrentNavigation())
    };
    var actionCreators = (0, _objectSpread2.default)({}, (0, _getNavigationActionCreators.default)(navigation.state), actions);
    Object.keys(actionCreators).forEach(function (actionName) {
      navigation[actionName] = function () {
        return navigation.dispatch(actionCreators[actionName].apply(actionCreators, arguments));
      };
    });
    return navigation;
  }
},453,[1,451,454,456,459],"node_modules/@react-navigation/core/lib/module/getNavigation.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/interopRequireWildcard");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var NavigationActions = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[2], "../NavigationActions"));

  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../utils/invariant"));

  var getNavigationActionCreators = function getNavigationActionCreators(route) {
    return {
      goBack: function goBack(key) {
        var actualizedKey = key;

        if (key === undefined && route.key) {
          (0, _invariant.default)(typeof route.key === 'string', 'key should be a string');
          actualizedKey = route.key;
        }

        return NavigationActions.back({
          key: actualizedKey
        });
      },
      navigate: function navigate(navigateTo, params, action) {
        if (typeof navigateTo === 'string') {
          return NavigationActions.navigate({
            routeName: navigateTo,
            params: params,
            action: action
          });
        }

        (0, _invariant.default)(typeof navigateTo === 'object', 'Must navigateTo an object or a string');
        (0, _invariant.default)(params == null, 'Params must not be provided to .navigate() when specifying an object');
        (0, _invariant.default)(action == null, 'Child action must not be provided to .navigate() when specifying an object');
        return NavigationActions.navigate(navigateTo);
      },
      setParams: function setParams(params) {
        (0, _invariant.default)(route.key && typeof route.key === 'string', 'setParams cannot be called by root navigator');
        return NavigationActions.setParams({
          params: params,
          key: route.key
        });
      }
    };
  };

  var _default = getNavigationActionCreators;
  exports.default = _default;
},454,[1,9,455,452],"node_modules/@react-navigation/core/lib/module/routers/getNavigationActionCreators.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.setParams = exports.navigate = exports.init = exports.back = exports.SET_PARAMS = exports.NAVIGATE = exports.INIT = exports.BACK = void 0;
  var BACK = 'Navigation/BACK';
  exports.BACK = BACK;
  var INIT = 'Navigation/INIT';
  exports.INIT = INIT;
  var NAVIGATE = 'Navigation/NAVIGATE';
  exports.NAVIGATE = NAVIGATE;
  var SET_PARAMS = 'Navigation/SET_PARAMS';
  exports.SET_PARAMS = SET_PARAMS;

  var back = function back() {
    var payload = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    return {
      type: BACK,
      key: payload.key,
      immediate: payload.immediate
    };
  };

  exports.back = back;

  var init = function init() {
    var payload = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    var action = {
      type: INIT
    };

    if (payload.params) {
      action.params = payload.params;
    }

    return action;
  };

  exports.init = init;

  var navigate = function navigate(payload) {
    var action = {
      type: NAVIGATE,
      routeName: payload.routeName
    };

    if (payload.params) {
      action.params = payload.params;
    }

    if (payload.action) {
      action.action = payload.action;
    }

    if (payload.key) {
      action.key = payload.key;
    }

    return action;
  };

  exports.navigate = navigate;

  var setParams = function setParams(payload) {
    return {
      type: SET_PARAMS,
      key: payload.key,
      params: payload.params,
      preserveFocus: true
    };
  };

  exports.setParams = setParams;
},455,[],"node_modules/@react-navigation/core/lib/module/NavigationActions.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _objectSpread2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/objectSpread"));

  var _getChildEventSubscriber = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "./getChildEventSubscriber"));

  var _getChildRouter = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "./getChildRouter"));

  var _getNavigationActionCreators = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "./routers/getNavigationActionCreators"));

  var _getChildrenNavigationCache = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "./getChildrenNavigationCache"));

  var createParamGetter = function createParamGetter(route) {
    return function (paramName, defaultValue) {
      var params = route.params;

      if (params && paramName in params) {
        return params[paramName];
      }

      return defaultValue;
    };
  };

  function _getChildNavigation(navigation, childKey, getCurrentParentNavigation) {
    var children = (0, _getChildrenNavigationCache.default)(navigation);
    var childRoute = navigation.state.routes.find(function (r) {
      return r.key === childKey;
    });

    if (!childRoute) {
      return null;
    }

    if (children[childKey] && children[childKey].state === childRoute) {
      return children[childKey];
    }

    var childRouter = (0, _getChildRouter.default)(navigation.router, childRoute.routeName);
    var focusedGrandChildRoute = childRoute.routes && typeof childRoute.index === 'number' ? childRoute.routes[childRoute.index] : null;
    var actionCreators = (0, _objectSpread2.default)({}, navigation.actions, navigation.router.getActionCreators(childRoute, navigation.state.key), childRouter ? childRouter.getActionCreators(focusedGrandChildRoute, childRoute.key) : {}, (0, _getNavigationActionCreators.default)(childRoute));
    var actionHelpers = {};
    Object.keys(actionCreators).forEach(function (actionName) {
      actionHelpers[actionName] = function () {
        var actionCreator = actionCreators[actionName];
        var action = actionCreator.apply(void 0, arguments);
        return navigation.dispatch(action);
      };
    });
    var _isFirstRouteInParent = true;
    var parentNavigation = getCurrentParentNavigation();

    if (parentNavigation) {
      _isFirstRouteInParent = parentNavigation.state.routes.indexOf(childRoute) === 0;
    }

    if (children[childKey] && children[childKey].isFirstRouteInParent() === _isFirstRouteInParent) {
      children[childKey] = (0, _objectSpread2.default)({}, children[childKey], actionHelpers, {
        state: childRoute,
        router: childRouter,
        actions: actionCreators,
        getParam: createParamGetter(childRoute)
      });
      return children[childKey];
    } else {
      var childSubscriber = (0, _getChildEventSubscriber.default)(navigation.addListener, childKey);
      children[childKey] = (0, _objectSpread2.default)({}, actionHelpers, {
        state: childRoute,
        router: childRouter,
        actions: actionCreators,
        getParam: createParamGetter(childRoute),
        getChildNavigation: function getChildNavigation(grandChildKey) {
          return _getChildNavigation(children[childKey], grandChildKey, function () {
            var nav = getCurrentParentNavigation();
            return nav && nav.getChildNavigation(childKey);
          });
        },
        isFocused: function isFocused() {
          var currentNavigation = getCurrentParentNavigation();

          if (!currentNavigation) {
            return false;
          }

          var _currentNavigation$st = currentNavigation.state,
              routes = _currentNavigation$st.routes,
              index = _currentNavigation$st.index;

          if (!currentNavigation.isFocused()) {
            return false;
          }

          if (routes[index].key === childKey) {
            return true;
          }

          return false;
        },
        isFirstRouteInParent: function isFirstRouteInParent() {
          return _isFirstRouteInParent;
        },
        dispatch: navigation.dispatch,
        getScreenProps: navigation.getScreenProps,
        dangerouslyGetParent: getCurrentParentNavigation,
        addListener: childSubscriber.addListener,
        emit: childSubscriber.emit
      });
      return children[childKey];
    }
  }

  var _default = _getChildNavigation;
  exports.default = _default;
},456,[1,451,457,458,454,459],"node_modules/@react-navigation/core/lib/module/getChildNavigation.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = getChildEventSubscriber;

  var _objectSpread2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/objectSpread"));

  function getChildEventSubscriber(addListener, key) {
    var initialLastFocusEvent = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'didBlur';
    var actionSubscribers = new Set();
    var willFocusSubscribers = new Set();
    var didFocusSubscribers = new Set();
    var willBlurSubscribers = new Set();
    var didBlurSubscribers = new Set();
    var refocusSubscribers = new Set();

    var removeAll = function removeAll() {
      [actionSubscribers, willFocusSubscribers, didFocusSubscribers, willBlurSubscribers, didBlurSubscribers, refocusSubscribers].forEach(function (set) {
        return set.clear();
      });
      upstreamSubscribers.forEach(function (subs) {
        return subs && subs.remove();
      });
    };

    var getChildSubscribers = function getChildSubscribers(evtName) {
      switch (evtName) {
        case 'action':
          return actionSubscribers;

        case 'willFocus':
          return willFocusSubscribers;

        case 'didFocus':
          return didFocusSubscribers;

        case 'willBlur':
          return willBlurSubscribers;

        case 'didBlur':
          return didBlurSubscribers;

        case 'refocus':
          return refocusSubscribers;

        default:
          return null;
      }
    };

    var _emit = function emit(type, payload) {
      var payloadWithType = (0, _objectSpread2.default)({}, payload, {
        type: type
      });
      var subscribers = getChildSubscribers(type);
      subscribers && subscribers.forEach(function (subs) {
        subs(payloadWithType);
      });
    };

    var lastFocusEvent = initialLastFocusEvent;
    var upstreamEvents = ['willFocus', 'didFocus', 'willBlur', 'didBlur', 'refocus', 'action'];
    var upstreamSubscribers = upstreamEvents.map(function (eventName) {
      return addListener(eventName, function (payload) {
        if (eventName === 'refocus') {
          _emit(eventName, payload);

          return;
        }

        var state = payload.state,
            lastState = payload.lastState,
            action = payload.action;
        var lastRoutes = lastState && lastState.routes;
        var routes = state && state.routes;
        var focusKey = routes && routes[state.index].key;
        var isChildFocused = focusKey === key;
        var lastRoute = lastRoutes && lastRoutes.find(function (route) {
          return route.key === key;
        });
        var newRoute = routes && routes.find(function (route) {
          return route.key === key;
        });
        var childPayload = {
          context: key + ":" + action.type + "_" + (payload.context || 'Root'),
          state: newRoute,
          lastState: lastRoute,
          action: action,
          type: eventName
        };
        var isTransitioning = !!state && state.isTransitioning;
        var previouslylastFocusEvent = lastFocusEvent;

        if (lastFocusEvent === 'didBlur') {
          if (eventName === 'willFocus' && isChildFocused) {
            _emit(lastFocusEvent = 'willFocus', childPayload);
          } else if (eventName === 'action' && isChildFocused) {
            _emit(lastFocusEvent = 'willFocus', childPayload);
          }
        }

        if (lastFocusEvent === 'willFocus') {
          if (eventName === 'didFocus' && isChildFocused && !isTransitioning) {
            _emit(lastFocusEvent = 'didFocus', childPayload);
          } else if (eventName === 'action' && isChildFocused && !isTransitioning) {
            _emit(lastFocusEvent = 'didFocus', childPayload);
          }
        }

        if (lastFocusEvent === 'didFocus') {
          if (!isChildFocused) {
            _emit(lastFocusEvent = 'willBlur', childPayload);
          } else if (eventName === 'willBlur') {
            _emit(lastFocusEvent = 'willBlur', childPayload);
          } else if (eventName === 'action' && previouslylastFocusEvent === 'didFocus') {
            _emit('action', childPayload);
          }
        }

        if (lastFocusEvent === 'willBlur') {
          if (eventName === 'action' && !isChildFocused && !isTransitioning) {
            _emit(lastFocusEvent = 'didBlur', childPayload);
          } else if (eventName === 'didBlur') {
            _emit(lastFocusEvent = 'didBlur', childPayload);
          } else if (eventName === 'action' && isChildFocused && !isTransitioning) {
            _emit(lastFocusEvent = 'didFocus', childPayload);
          } else if (eventName === 'action' && isChildFocused && isTransitioning) {
            _emit(lastFocusEvent = 'willFocus', childPayload);
          }
        }

        if (lastFocusEvent === 'didBlur' && !newRoute) {
          removeAll();
        }
      });
    });
    return {
      addListener: function addListener(eventName, eventHandler) {
        var subscribers = getChildSubscribers(eventName);

        if (!subscribers) {
          throw new Error("Invalid event name \"" + eventName + "\"");
        }

        subscribers.add(eventHandler);

        var remove = function remove() {
          subscribers.delete(eventHandler);
        };

        return {
          remove: remove
        };
      },
      emit: function emit(eventName, payload) {
        if (eventName !== 'refocus') {
          console.error("navigation.emit only supports the 'refocus' event currently.");
          return;
        }

        _emit(eventName, payload);
      }
    };
  }
},457,[1,451],"node_modules/@react-navigation/core/lib/module/getChildEventSubscriber.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = getChildRouter;

  function getChildRouter(router, routeName) {
    if (router.childRouters && router.childRouters[routeName]) {
      return router.childRouters[routeName];
    }

    var Component = router.getComponentForRouteName(routeName);
    return Component.router;
  }
},458,[],"node_modules/@react-navigation/core/lib/module/getChildRouter.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = getChildrenNavigationCache;

  function getChildrenNavigationCache(navigation) {
    if (!navigation) {
      return {};
    }

    var childrenNavigationCache = navigation._childrenNavigation || (navigation._childrenNavigation = {});
    var childKeys = navigation.state.routes.map(function (route) {
      return route.key;
    });
    Object.keys(childrenNavigationCache).forEach(function (cacheKey) {
      if (!childKeys.includes(cacheKey) && !navigation.state.isTransitioning) {
        delete childrenNavigationCache[cacheKey];
      }
    });
    return navigation._childrenNavigation;
  }
},459,[],"node_modules/@react-navigation/core/lib/module/getChildrenNavigationCache.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _extends2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/extends"));

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits"));

  var _react = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "react"));

  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "../utils/invariant"));

  var _ThemeContext = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "../views/ThemeContext"));

  var _jsxFileName = "/Users/satya/Workspace/Callstack/react-navigation-core/src/navigators/createNavigator.js";

  function createNavigator(NavigatorView, router, navigationConfig) {
    var Navigator = function (_React$Component) {
      (0, _inherits2.default)(Navigator, _React$Component);

      function Navigator(props, context) {
        var _this;

        (0, _classCallCheck2.default)(this, Navigator);
        _this = (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(Navigator).call(this, props, context));
        _this.state = {
          descriptors: {},
          screenProps: _this.props.screenProps,
          theme: context,
          themeContext: context
        };
        return _this;
      }

      (0, _createClass2.default)(Navigator, [{
        key: "componentDidUpdate",
        value: function componentDidUpdate() {
          if (this.context !== this.state.themeContext) {
            this.setState({
              themeContext: this.context
            });
          }
        }
      }, {
        key: "render",
        value: function render() {
          return _react.default.createElement(NavigatorView, (0, _extends2.default)({}, this.props, {
            screenProps: this.state.screenProps,
            navigation: this.props.navigation,
            navigationConfig: navigationConfig,
            descriptors: this.state.descriptors,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 80
            }
          }));
        }
      }], [{
        key: "getDerivedStateFromProps",
        value: function getDerivedStateFromProps(nextProps, currentState) {
          var prevDescriptors = currentState.descriptors;
          var navigation = nextProps.navigation,
              screenProps = nextProps.screenProps;
          (0, _invariant.default)(navigation != null, 'The navigation prop is missing for this navigator. In react-navigation 3 you must set up your app container directly. More info: https://reactnavigation.org/docs/en/app-containers.html');
          var state = navigation.state;
          var routes = state.routes;

          if (typeof routes === 'undefined') {
            throw new TypeError('No "routes" found in navigation state. Did you try to pass the navigation prop of a React component to a Navigator child? See https://reactnavigation.org/docs/en/custom-navigators.html#navigator-navigation-prop');
          }

          var descriptors = routes.reduce(function (acc, route) {
            if (prevDescriptors && prevDescriptors[route.key] && route === prevDescriptors[route.key].state && screenProps === currentState.screenProps && currentState.themeContext === currentState.theme) {
              acc[route.key] = prevDescriptors[route.key];
              return acc;
            }

            var getComponent = router.getComponentForRouteName.bind(null, route.routeName);
            var childNavigation = navigation.getChildNavigation(route.key);
            var options = router.getScreenOptions(childNavigation, screenProps, currentState.themeContext);
            acc[route.key] = {
              key: route.key,
              getComponent: getComponent,
              options: options,
              state: route,
              navigation: childNavigation
            };
            return acc;
          }, {});
          return {
            descriptors: descriptors,
            screenProps: screenProps,
            theme: state.themeContext
          };
        }
      }]);
      return Navigator;
    }(_react.default.Component);

    Navigator.contextType = _ThemeContext.default;
    Navigator.router = router;
    Navigator.navigationOptions = navigationConfig.navigationOptions;
    return Navigator;
  }

  var _default = createNavigator;
  exports.default = _default;
},460,[1,13,24,25,32,34,37,54,452,461],"node_modules/@react-navigation/core/lib/module/navigators/createNavigator.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireWildcard");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[1], "react"));

  var _default = React.createContext('light');

  exports.default = _default;
},461,[9,54],"node_modules/@react-navigation/core/lib/module/views/ThemeContext.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireWildcard");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[1], "react"));

  var _default = React.createContext(undefined);

  exports.default = _default;
},462,[9,54],"node_modules/@react-navigation/core/lib/module/views/NavigationContext.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _createNavigator = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../navigators/createNavigator"));

  var _SwitchRouter = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../routers/SwitchRouter"));

  var _SwitchView = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../views/SwitchView/SwitchView"));

  function createSwitchNavigator(routeConfigMap) {
    var switchConfig = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
    var router = (0, _SwitchRouter.default)(routeConfigMap, switchConfig);
    var Navigator = (0, _createNavigator.default)(_SwitchView.default, router, switchConfig);
    return Navigator;
  }

  var _default = createSwitchNavigator;
  exports.default = _default;
},463,[1,460,464,477],"node_modules/@react-navigation/core/lib/module/navigators/createSwitchNavigator.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireWildcard");

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _toConsumableArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/toConsumableArray"));

  var _objectSpread2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/objectSpread"));

  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "../utils/invariant"));

  var _getScreenForRouteName = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "./getScreenForRouteName"));

  var _createConfigGetter = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "./createConfigGetter"));

  var NavigationActions = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[7], "../NavigationActions"));

  var SwitchActions = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[8], "./SwitchActions"));

  var _validateRouteConfigMap = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "./validateRouteConfigMap"));

  var _pathUtils = _$$_REQUIRE(_dependencyMap[10], "./pathUtils");

  var defaultActionCreators = function defaultActionCreators() {
    return {};
  };

  var _default = function _default(routeConfigs) {
    var config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
    (0, _validateRouteConfigMap.default)(routeConfigs);
    var order = config.order || Object.keys(routeConfigs);
    var getCustomActionCreators = config.getCustomActionCreators || defaultActionCreators;
    var initialRouteParams = config.initialRouteParams;
    var initialRouteName = config.initialRouteName || order[0];
    var backBehavior = config.backBehavior || 'none';
    var resetOnBlur = config.hasOwnProperty('resetOnBlur') ? config.resetOnBlur : true;
    var initialRouteIndex = order.indexOf(initialRouteName);

    if (initialRouteIndex === -1) {
      throw new Error("Invalid initialRouteName '" + initialRouteName + "'." + ("Should be one of " + order.map(function (n) {
        return "\"" + n + "\"";
      }).join(', ')));
    }

    var childRouters = {};
    order.forEach(function (routeName) {
      childRouters[routeName] = null;
      var screen = (0, _getScreenForRouteName.default)(routeConfigs, routeName);

      if (screen.router) {
        childRouters[routeName] = screen.router;
      }
    });

    function getParamsForRoute(routeName, params) {
      var routeConfig = routeConfigs[routeName];

      if (routeConfig && routeConfig.params) {
        return (0, _objectSpread2.default)({}, routeConfig.params, params);
      } else {
        return params;
      }
    }

    var _createPathParser = (0, _pathUtils.createPathParser)(childRouters, routeConfigs, config),
        getPathAndParamsForRoute = _createPathParser.getPathAndParamsForRoute,
        _getActionForPathAndParams = _createPathParser.getActionForPathAndParams;

    function resetChildRoute(routeName) {
      var initialParams = routeName === initialRouteName ? initialRouteParams : undefined;
      var params = getParamsForRoute(routeName, initialParams);
      var childRouter = childRouters[routeName];

      if (childRouter) {
        var childAction = NavigationActions.init();
        return (0, _objectSpread2.default)({}, childRouter.getStateForAction(childAction), {
          key: routeName,
          routeName: routeName,
          params: params
        });
      }

      return {
        key: routeName,
        routeName: routeName,
        params: params
      };
    }

    function getNextState(action, prevState, possibleNextState) {
      function updateNextStateHistory(nextState) {
        if (backBehavior !== 'history') {
          return nextState;
        }

        var nextRouteKeyHistory = prevState ? prevState.routeKeyHistory : [];

        if (action.type === NavigationActions.NAVIGATE) {
          nextRouteKeyHistory = (0, _toConsumableArray2.default)(nextRouteKeyHistory);
          var keyToAdd = nextState.routes[nextState.index].key;
          nextRouteKeyHistory = nextRouteKeyHistory.filter(function (k) {
            return k !== keyToAdd;
          });
          nextRouteKeyHistory.push(keyToAdd);
        } else if (action.type === NavigationActions.BACK) {
          nextRouteKeyHistory = (0, _toConsumableArray2.default)(nextRouteKeyHistory);
          nextRouteKeyHistory.pop();
        }

        return (0, _objectSpread2.default)({}, nextState, {
          routeKeyHistory: nextRouteKeyHistory
        });
      }

      var nextState = possibleNextState;

      if (prevState && prevState.index !== possibleNextState.index && resetOnBlur) {
        var prevRouteName = prevState.routes[prevState.index].routeName;
        var nextRoutes = (0, _toConsumableArray2.default)(possibleNextState.routes);
        nextRoutes[prevState.index] = resetChildRoute(prevRouteName);
        nextState = (0, _objectSpread2.default)({}, possibleNextState, {
          routes: nextRoutes
        });
      }

      return updateNextStateHistory(nextState);
    }

    function getInitialState() {
      var routes = order.map(resetChildRoute);
      var initialState = {
        routes: routes,
        index: initialRouteIndex,
        isTransitioning: false
      };

      if (backBehavior === 'history') {
        var initialKey = routes[initialRouteIndex].key;
        initialState['routeKeyHistory'] = [initialKey];
      }

      return initialState;
    }

    return {
      childRouters: childRouters,
      getActionCreators: function getActionCreators(route, stateKey) {
        return getCustomActionCreators(route, stateKey);
      },
      getStateForAction: function getStateForAction(action, inputState) {
        var prevState = inputState ? (0, _objectSpread2.default)({}, inputState) : inputState;
        var state = inputState || getInitialState();
        var activeChildIndex = state.index;

        if (action.type === NavigationActions.INIT) {
          var params = action.params;

          if (params) {
            state.routes = state.routes.map(function (route) {
              return (0, _objectSpread2.default)({}, route, {
                params: (0, _objectSpread2.default)({}, route.params, params, route.routeName === initialRouteName ? initialRouteParams : null)
              });
            });
          }
        }

        if (action.type === SwitchActions.JUMP_TO && (action.key == null || action.key === state.key)) {
          var _params = action.params;

          var _index = state.routes.findIndex(function (route) {
            return route.routeName === action.routeName;
          });

          if (_index === -1) {
            throw new Error("There is no route named '" + action.routeName + "' in the navigator with the key '" + action.key + "'.\n" + ("Must be one of: " + state.routes.map(function (route) {
              return "'" + route.routeName + "'";
            }).join(',')));
          }

          return getNextState(action, prevState, (0, _objectSpread2.default)({}, state, {
            routes: _params ? state.routes.map(function (route, i) {
              return i === _index ? (0, _objectSpread2.default)({}, route, {
                params: (0, _objectSpread2.default)({}, route.params, _params)
              }) : route;
            }) : state.routes,
            index: _index
          }));
        }

        var activeChildLastState = state.routes[state.index];
        var activeChildRouter = childRouters[order[state.index]];

        if (activeChildRouter) {
          var activeChildState = activeChildRouter.getStateForAction(action, activeChildLastState);

          if (!activeChildState && inputState) {
            return null;
          }

          if (activeChildState && activeChildState !== activeChildLastState) {
            var _routes = (0, _toConsumableArray2.default)(state.routes);

            _routes[state.index] = activeChildState;
            return getNextState(action, prevState, (0, _objectSpread2.default)({}, state, {
              routes: _routes
            }));
          }
        }

        var isBackEligible = action.key == null || action.key === activeChildLastState.key;

        if (action.type === NavigationActions.BACK) {
          if (isBackEligible && backBehavior === 'initialRoute') {
            activeChildIndex = initialRouteIndex;
          } else if (isBackEligible && backBehavior === 'order') {
            activeChildIndex = Math.max(0, activeChildIndex - 1);
          } else if (isBackEligible && backBehavior === 'history' && state.routeKeyHistory.length > 1) {
            var routeKey = state.routeKeyHistory[state.routeKeyHistory.length - 2];
            activeChildIndex = order.indexOf(routeKey);
          } else {
            return state;
          }
        }

        var didNavigate = false;

        if (action.type === NavigationActions.NAVIGATE) {
          didNavigate = !!order.find(function (childId, i) {
            if (childId === action.routeName) {
              activeChildIndex = i;
              return true;
            }

            return false;
          });

          if (didNavigate) {
            var childState = state.routes[activeChildIndex];
            var childRouter = childRouters[action.routeName];
            var newChildState = childState;

            if (action.action && childRouter) {
              var childStateUpdate = childRouter.getStateForAction(action.action, childState);

              if (childStateUpdate) {
                newChildState = childStateUpdate;
              }
            }

            if (action.params) {
              newChildState = (0, _objectSpread2.default)({}, newChildState, {
                params: (0, _objectSpread2.default)({}, newChildState.params || {}, action.params)
              });
            }

            if (newChildState !== childState) {
              var _routes2 = (0, _toConsumableArray2.default)(state.routes);

              _routes2[activeChildIndex] = newChildState;
              var nextState = (0, _objectSpread2.default)({}, state, {
                routes: _routes2,
                index: activeChildIndex
              });
              return getNextState(action, prevState, nextState);
            } else if (newChildState === childState && state.index === activeChildIndex && prevState) {
              return null;
            }
          }
        }

        if (action.type === NavigationActions.SET_PARAMS) {
          var key = action.key;
          var lastRoute = state.routes.find(function (route) {
            return route.key === key;
          });

          if (lastRoute) {
            var _params2 = (0, _objectSpread2.default)({}, lastRoute.params, action.params);

            var _routes3 = (0, _toConsumableArray2.default)(state.routes);

            _routes3[state.routes.indexOf(lastRoute)] = (0, _objectSpread2.default)({}, lastRoute, {
              params: _params2
            });
            return getNextState(action, prevState, (0, _objectSpread2.default)({}, state, {
              routes: _routes3
            }));
          }
        }

        if (activeChildIndex !== state.index) {
          return getNextState(action, prevState, (0, _objectSpread2.default)({}, state, {
            index: activeChildIndex
          }));
        } else if (didNavigate && !inputState) {
          return state;
        } else if (didNavigate) {
          return (0, _objectSpread2.default)({}, state);
        }

        var index = state.index;
        var routes = state.routes;
        order.find(function (childId, i) {
          var childRouter = childRouters[childId];

          if (i === index) {
            return false;
          }

          var childState = routes[i];

          if (childRouter) {
            childState = childRouter.getStateForAction(action, childState);
          }

          if (!childState) {
            index = i;
            return true;
          }

          if (childState !== routes[i]) {
            routes = (0, _toConsumableArray2.default)(routes);
            routes[i] = childState;
            index = i;
            return true;
          }

          return false;
        });

        if (action.preserveFocus) {
          index = state.index;
        }

        if (index !== state.index || routes !== state.routes) {
          return getNextState(action, prevState, (0, _objectSpread2.default)({}, state, {
            index: index,
            routes: routes
          }));
        }

        return state;
      },
      getComponentForState: function getComponentForState(state) {
        var routeName = state.routes[state.index].routeName;
        (0, _invariant.default)(routeName, "There is no route defined for index " + state.index + ". Check that\n        that you passed in a navigation state with a valid tab/screen index.");
        var childRouter = childRouters[routeName];

        if (childRouter) {
          return childRouter.getComponentForState(state.routes[state.index]);
        }

        return (0, _getScreenForRouteName.default)(routeConfigs, routeName);
      },
      getComponentForRouteName: function getComponentForRouteName(routeName) {
        return (0, _getScreenForRouteName.default)(routeConfigs, routeName);
      },
      getPathAndParamsForState: function getPathAndParamsForState(state) {
        var route = state.routes[state.index];
        return getPathAndParamsForRoute(route);
      },
      getActionForPathAndParams: function getActionForPathAndParams(path, params) {
        return _getActionForPathAndParams(path, params);
      },
      getScreenOptions: (0, _createConfigGetter.default)(routeConfigs, config.defaultNavigationOptions)
    };
  };

  exports.default = _default;
},464,[9,1,20,451,452,465,466,455,468,469,470],"node_modules/@react-navigation/core/lib/module/routers/SwitchRouter.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = getScreenForRouteName;

  var _reactIs = _$$_REQUIRE(_dependencyMap[1], "react-is");

  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../utils/invariant"));

  function getScreenForRouteName(routeConfigs, routeName) {
    var routeConfig = routeConfigs[routeName];

    if (!routeConfig) {
      throw new Error("There is no route defined for key " + routeName + ".\n" + ("Must be one of: " + Object.keys(routeConfigs).map(function (a) {
        return "'" + a + "'";
      }).join(',')));
    }

    if (routeConfig.screen) {
      return routeConfig.screen;
    }

    if (typeof routeConfig.getScreen === 'function') {
      var screen = routeConfig.getScreen();
      (0, _invariant.default)((0, _reactIs.isValidElementType)(screen), "The getScreen defined for route '" + routeName + " didn't return a valid " + 'screen or navigator.\n\n' + 'Please pass it like this:\n' + (routeName + ": {\n  getScreen: () => require('./MyScreen').default\n}"));
      return screen;
    }

    return routeConfig;
  }
},465,[1,70,452],"node_modules/@react-navigation/core/lib/module/routers/getScreenForRouteName.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _objectSpread2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/objectSpread"));

  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../utils/invariant"));

  var _getScreenForRouteName = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "./getScreenForRouteName"));

  var _validateScreenOptions = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "./validateScreenOptions"));

  function applyConfig(configurer, navigationOptions, configProps) {
    if (typeof configurer === 'function') {
      return (0, _objectSpread2.default)({}, navigationOptions, configurer((0, _objectSpread2.default)({}, configProps, {
        navigationOptions: navigationOptions
      })));
    }

    if (typeof configurer === 'object') {
      return (0, _objectSpread2.default)({}, navigationOptions, configurer);
    }

    return navigationOptions;
  }

  var _default = function _default(routeConfigs, navigatorScreenConfig) {
    return function (navigation, screenProps, theme) {
      var state = navigation.state;
      var route = state;
      (0, _invariant.default)(route.routeName && typeof route.routeName === 'string', 'Cannot get config because the route does not have a routeName.');
      var Component = (0, _getScreenForRouteName.default)(routeConfigs, route.routeName);
      var routeConfig = routeConfigs[route.routeName];
      var routeScreenConfig = routeConfig === Component ? null : routeConfig.navigationOptions;
      var componentScreenConfig = Component.navigationOptions;
      var configOptions = {
        navigation: navigation,
        screenProps: screenProps || {},
        theme: theme
      };
      var outputConfig = applyConfig(navigatorScreenConfig, {}, configOptions);
      outputConfig = applyConfig(componentScreenConfig, outputConfig, configOptions);
      outputConfig = applyConfig(routeScreenConfig, outputConfig, configOptions);
      (0, _validateScreenOptions.default)(outputConfig, route);
      return outputConfig;
    };
  };

  exports.default = _default;
},466,[1,451,452,465,467],"node_modules/@react-navigation/core/lib/module/routers/createConfigGetter.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _toConsumableArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/toConsumableArray"));

  var deprecatedKeys = ['tabBar'];

  var _default = function _default(screenOptions, route) {
    var keys = Object.keys(screenOptions);
    var deprecatedKey = keys.find(function (key) {
      return deprecatedKeys.includes(key);
    });

    if (typeof screenOptions.title === 'function') {
      throw new Error(["`title` cannot be defined as a function in navigation options for `" + route.routeName + "` screen. \n", 'Try replacing the following:', '{', '    title: ({ state }) => state...', '}', '', 'with:', '({ navigation }) => ({', '    title: navigation.state...', '})'].join('\n'));
    }

    if (deprecatedKey && typeof screenOptions[deprecatedKey] === 'function') {
      throw new Error(["`" + deprecatedKey + "` cannot be defined as a function in navigation options for `" + route.routeName + "` screen. \n", 'Try replacing the following:', '{', "    " + deprecatedKey + ": ({ state }) => ({", '         key: state...', '    })', '}', '', 'with:', '({ navigation }) => ({', "    " + deprecatedKey + "Key: navigation.state...", '})'].join('\n'));
    }

    if (deprecatedKey && typeof screenOptions[deprecatedKey] === 'object') {
      throw new Error(["Invalid key `" + deprecatedKey + "` defined in navigation options for `" + route.routeName + "` screen.", '\n', 'Try replacing the following navigation options:', '{', "    " + deprecatedKey + ": {"].concat((0, _toConsumableArray2.default)(Object.keys(screenOptions[deprecatedKey]).map(function (key) {
        return "        " + key + ": ...,";
      })), ['    },', '}', '\n', 'with:', '{'], (0, _toConsumableArray2.default)(Object.keys(screenOptions[deprecatedKey]).map(function (key) {
        return "    " + (deprecatedKey + key[0].toUpperCase() + key.slice(1)) + ": ...,";
      })), ['}']).join('\n'));
    }
  };

  exports.default = _default;
},467,[1,20],"node_modules/@react-navigation/core/lib/module/routers/validateScreenOptions.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.jumpTo = exports.JUMP_TO = void 0;

  var _objectSpread2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/objectSpread"));

  var JUMP_TO = 'Navigation/JUMP_TO';
  exports.JUMP_TO = JUMP_TO;

  var jumpTo = function jumpTo(payload) {
    return (0, _objectSpread2.default)({
      type: JUMP_TO,
      preserveFocus: true
    }, payload);
  };

  exports.jumpTo = jumpTo;
},468,[1,451],"node_modules/@react-navigation/core/lib/module/routers/SwitchActions.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _reactIs = _$$_REQUIRE(_dependencyMap[1], "react-is");

  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../utils/invariant"));

  function validateRouteConfigMap(routeConfigs) {
    var routeNames = Object.keys(routeConfigs);
    (0, _invariant.default)(routeNames.length > 0, 'Please specify at least one route when configuring a navigator.');
    routeNames.forEach(function (routeName) {
      var routeConfig = routeConfigs[routeName];
      var screenComponent = getScreenComponent(routeConfig);

      if (!screenComponent || !(0, _reactIs.isValidElementType)(screenComponent) && !routeConfig.getScreen) {
        throw new Error("The component for route '" + routeName + "' must be a React component. For example:\n\nimport MyScreen from './MyScreen';\n...\n" + routeName + ": MyScreen,\n}\n\nYou can also use a navigator:\n\nimport MyNavigator from './MyNavigator';\n...\n" + routeName + ": MyNavigator,\n}");
      }

      if (routeConfig.screen && routeConfig.getScreen) {
        throw new Error("Route '" + routeName + "' should declare a screen or a getScreen, not both.");
      }
    });
  }

  function getScreenComponent(routeConfig) {
    if (!routeConfig) {
      return null;
    }

    return routeConfig.screen ? routeConfig.screen : routeConfig;
  }

  var _default = validateRouteConfigMap;
  exports.default = _default;
},469,[1,70,452],"node_modules/@react-navigation/core/lib/module/routers/validateRouteConfigMap.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireWildcard");

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.createPathParser = exports.urlToPathAndParams = exports.getParamsFromPath = void 0;

  var _slicedToArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/slicedToArray"));

  var _objectSpread2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/objectSpread"));

  var _pathToRegexp = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[4], "path-to-regexp"));

  var NavigationActions = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[5], "../NavigationActions"));

  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "../utils/invariant"));

  var queryString = _$$_REQUIRE(_dependencyMap[7], "query-string");

  var getParamsFromPath = function getParamsFromPath(inputParams, pathMatch, pathMatchKeys) {
    var params = pathMatch.slice(1).reduce(function (paramsOut, matchResult, i) {
      var key = pathMatchKeys[i];

      if (!key || key.asterisk) {
        return paramsOut;
      }

      var paramName = key.name;
      var decodedMatchResult;

      if (matchResult) {
        try {
          decodedMatchResult = decodeURIComponent(matchResult);
        } catch (e) {}
      }

      paramsOut[paramName] = decodedMatchResult || matchResult;
      return paramsOut;
    }, (0, _objectSpread2.default)({}, inputParams));
    return params;
  };

  exports.getParamsFromPath = getParamsFromPath;

  var getRestOfPath = function getRestOfPath(pathMatch, pathMatchKeys) {
    var rest = pathMatch[pathMatchKeys.findIndex(function (k) {
      return k.asterisk;
    }) + 1];
    return rest;
  };

  var determineDelimiter = function determineDelimiter(uri, uriPrefix) {
    if (Array.isArray(uriPrefix)) {
      if (uriPrefix.length === 1) return uriPrefix[0];

      for (var _iterator = uriPrefix, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[typeof Symbol === "function" ? typeof Symbol === "function" ? Symbol.iterator : "@@iterator" : "@@iterator"]();;) {
        var _ref;

        if (_isArray) {
          if (_i >= _iterator.length) break;
          _ref = _iterator[_i++];
        } else {
          _i = _iterator.next();
          if (_i.done) break;
          _ref = _i.value;
        }

        var _prefix = _ref;
        if (uri.startsWith(_prefix)) return _prefix;
      }

      return null;
    }

    return uriPrefix;
  };

  var urlToPathAndParams = function urlToPathAndParams(url, uriPrefix) {
    var searchMatch = url.match(/^(.*)\?(.*)$/);

    var _ref2 = searchMatch || [null, url, {}],
        _ref3 = (0, _slicedToArray2.default)(_ref2, 3),
        urlWithoutQuery = _ref3[1],
        query = _ref3[2];

    var params = queryString.parse(query);
    var delimiter = determineDelimiter(urlWithoutQuery, uriPrefix) || '://';
    var path = urlWithoutQuery.split(delimiter)[1];

    if (path === undefined) {
      path = urlWithoutQuery;
    }

    if (path === '/') {
      path = '';
    }

    if (path[path.length - 1] === '/') {
      path = path.slice(0, -1);
    }

    return {
      path: path,
      params: params
    };
  };

  exports.urlToPathAndParams = urlToPathAndParams;

  var createPathParser = function createPathParser(childRouters, routeConfigs, _ref4) {
    var _ref4$paths = _ref4.paths,
        pathConfigs = _ref4$paths === void 0 ? {} : _ref4$paths,
        disableRouteNamePaths = _ref4.disableRouteNamePaths;
    var pathsByRouteNames = {};
    var paths = [];
    Object.keys(childRouters).forEach(function (routeName) {
      var pathPattern;

      if (pathConfigs[routeName] !== undefined) {
        pathPattern = pathConfigs[routeName];
      } else {
        pathPattern = routeConfigs[routeName].path;
      }

      if (pathPattern === undefined) {
        pathPattern = disableRouteNamePaths ? null : routeName;
      }

      (0, _invariant.default)(pathPattern === null || typeof pathPattern === 'string', "Route path for " + routeName + " must be specified as a string, or null.");
      var isPathMatchable = pathPattern !== null;
      var exactReKeys = [];
      var exactRe = isPathMatchable ? (0, _pathToRegexp.default)(pathPattern, exactReKeys) : null;
      var extendedPathReKeys = [];
      var isWildcard = pathPattern === '' || !isPathMatchable;
      var extendedPathRe = (0, _pathToRegexp.default)(isWildcard ? '*' : pathPattern + "/*", extendedPathReKeys);
      pathsByRouteNames[routeName] = {
        exactRe: exactRe,
        exactReKeys: exactReKeys,
        extendedPathRe: extendedPathRe,
        extendedPathReKeys: extendedPathReKeys,
        isWildcard: isWildcard,
        toPath: pathPattern === null ? function () {
          return '';
        } : (0, _pathToRegexp.compile)(pathPattern)
      };
    });
    paths = Object.entries(pathsByRouteNames);

    var getActionForPathAndParams = function getActionForPathAndParams() {
      var pathToResolve = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
      var inputParams = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

      for (var _iterator2 = paths, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[typeof Symbol === "function" ? typeof Symbol === "function" ? Symbol.iterator : "@@iterator" : "@@iterator"]();;) {
        var _ref7;

        if (_isArray2) {
          if (_i2 >= _iterator2.length) break;
          _ref7 = _iterator2[_i2++];
        } else {
          _i2 = _iterator2.next();
          if (_i2.done) break;
          _ref7 = _i2.value;
        }

        var _ref11 = _ref7;

        var _ref6 = (0, _slicedToArray2.default)(_ref11, 2);

        var _routeName2 = _ref6[0];
        var _path2 = _ref6[1];
        var exactRe = _path2.exactRe,
            exactReKeys = _path2.exactReKeys,
            extendedPathRe = _path2.extendedPathRe,
            extendedPathReKeys = _path2.extendedPathReKeys;
        var childRouter = childRouters[_routeName2];
        var exactMatch = exactRe && exactRe.exec(pathToResolve);

        if (exactMatch && exactMatch.length) {
          var extendedMatch = extendedPathRe && extendedPathRe.exec(pathToResolve);
          var childAction = null;

          if (extendedMatch && childRouter) {
            var restOfPath = getRestOfPath(extendedMatch, extendedPathReKeys);
            childAction = childRouter.getActionForPathAndParams(restOfPath, inputParams);
          }

          return NavigationActions.navigate({
            routeName: _routeName2,
            params: getParamsFromPath(inputParams, exactMatch, exactReKeys),
            action: childAction
          });
        }
      }

      for (var _iterator3 = paths, _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[typeof Symbol === "function" ? typeof Symbol === "function" ? Symbol.iterator : "@@iterator" : "@@iterator"]();;) {
        var _ref10;

        if (_isArray3) {
          if (_i3 >= _iterator3.length) break;
          _ref10 = _iterator3[_i3++];
        } else {
          _i3 = _iterator3.next();
          if (_i3.done) break;
          _ref10 = _i3.value;
        }

        var _ref12 = _ref10;

        var _ref9 = (0, _slicedToArray2.default)(_ref12, 2);

        var _routeName3 = _ref9[0];
        var _path3 = _ref9[1];
        var _extendedPathRe = _path3.extendedPathRe,
            _extendedPathReKeys = _path3.extendedPathReKeys;
        var _childRouter = childRouters[_routeName3];

        var _extendedMatch = _extendedPathRe && _extendedPathRe.exec(pathToResolve);

        if (_extendedMatch && _extendedMatch.length) {
          var _restOfPath = getRestOfPath(_extendedMatch, _extendedPathReKeys);

          var _childAction = null;

          if (_childRouter) {
            _childAction = _childRouter.getActionForPathAndParams(_restOfPath, inputParams);
          }

          if (!_childAction) {
            continue;
          }

          return NavigationActions.navigate({
            routeName: _routeName3,
            params: getParamsFromPath(inputParams, _extendedMatch, _extendedPathReKeys),
            action: _childAction
          });
        }
      }

      return null;
    };

    var getPathAndParamsForRoute = function getPathAndParamsForRoute(route) {
      var routeName = route.routeName,
          params = route.params;
      var childRouter = childRouters[routeName];
      var _pathsByRouteNames$ro = pathsByRouteNames[routeName],
          toPath = _pathsByRouteNames$ro.toPath,
          exactReKeys = _pathsByRouteNames$ro.exactReKeys;
      var subPath = toPath(params);
      var nonPathParams = {};

      if (params) {
        Object.keys(params).filter(function (paramName) {
          return !exactReKeys.find(function (k) {
            return k.name === paramName;
          });
        }).forEach(function (paramName) {
          nonPathParams[paramName] = params[paramName];
        });
      }

      if (childRouter) {
        var child = childRouter.getPathAndParamsForState(route);
        return {
          path: subPath ? subPath + "/" + child.path : child.path,
          params: child.params ? (0, _objectSpread2.default)({}, nonPathParams, child.params) : nonPathParams
        };
      }

      return {
        path: subPath,
        params: nonPathParams
      };
    };

    return {
      getActionForPathAndParams: getActionForPathAndParams,
      getPathAndParamsForRoute: getPathAndParamsForRoute
    };
  };

  exports.createPathParser = createPathParser;
},470,[9,1,14,451,471,455,452,473],"node_modules/@react-navigation/core/lib/module/routers/pathUtils.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var isarray = _$$_REQUIRE(_dependencyMap[0], "isarray");

  module.exports = pathToRegexp;
  module.exports.parse = parse;
  module.exports.compile = compile;
  module.exports.tokensToFunction = tokensToFunction;
  module.exports.tokensToRegExp = tokensToRegExp;
  var PATH_REGEXP = new RegExp(['(\\\\.)', '([\\/.])?(?:(?:\\:(\\w+)(?:\\(((?:\\\\.|[^\\\\()])+)\\))?|\\(((?:\\\\.|[^\\\\()])+)\\))([+*?])?|(\\*))'].join('|'), 'g');

  function parse(str, options) {
    var tokens = [];
    var key = 0;
    var index = 0;
    var path = '';
    var defaultDelimiter = options && options.delimiter || '/';
    var res;

    while ((res = PATH_REGEXP.exec(str)) != null) {
      var m = res[0];
      var escaped = res[1];
      var offset = res.index;
      path += str.slice(index, offset);
      index = offset + m.length;

      if (escaped) {
        path += escaped[1];
        continue;
      }

      var next = str[index];
      var prefix = res[2];
      var name = res[3];
      var capture = res[4];
      var group = res[5];
      var modifier = res[6];
      var asterisk = res[7];

      if (path) {
        tokens.push(path);
        path = '';
      }

      var partial = prefix != null && next != null && next !== prefix;
      var repeat = modifier === '+' || modifier === '*';
      var optional = modifier === '?' || modifier === '*';
      var delimiter = res[2] || defaultDelimiter;
      var pattern = capture || group;
      tokens.push({
        name: name || key++,
        prefix: prefix || '',
        delimiter: delimiter,
        optional: optional,
        repeat: repeat,
        partial: partial,
        asterisk: !!asterisk,
        pattern: pattern ? escapeGroup(pattern) : asterisk ? '.*' : '[^' + escapeString(delimiter) + ']+?'
      });
    }

    if (index < str.length) {
      path += str.substr(index);
    }

    if (path) {
      tokens.push(path);
    }

    return tokens;
  }

  function compile(str, options) {
    return tokensToFunction(parse(str, options), options);
  }

  function encodeURIComponentPretty(str) {
    return encodeURI(str).replace(/[\/?#]/g, function (c) {
      return '%' + c.charCodeAt(0).toString(16).toUpperCase();
    });
  }

  function encodeAsterisk(str) {
    return encodeURI(str).replace(/[?#]/g, function (c) {
      return '%' + c.charCodeAt(0).toString(16).toUpperCase();
    });
  }

  function tokensToFunction(tokens, options) {
    var matches = new Array(tokens.length);

    for (var i = 0; i < tokens.length; i++) {
      if (typeof tokens[i] === 'object') {
        matches[i] = new RegExp('^(?:' + tokens[i].pattern + ')$', flags(options));
      }
    }

    return function (obj, opts) {
      var path = '';
      var data = obj || {};
      var options = opts || {};
      var encode = options.pretty ? encodeURIComponentPretty : encodeURIComponent;

      for (var i = 0; i < tokens.length; i++) {
        var token = tokens[i];

        if (typeof token === 'string') {
          path += token;
          continue;
        }

        var value = data[token.name];
        var segment;

        if (value == null) {
          if (token.optional) {
            if (token.partial) {
              path += token.prefix;
            }

            continue;
          } else {
            throw new TypeError('Expected "' + token.name + '" to be defined');
          }
        }

        if (isarray(value)) {
          if (!token.repeat) {
            throw new TypeError('Expected "' + token.name + '" to not repeat, but received `' + JSON.stringify(value) + '`');
          }

          if (value.length === 0) {
            if (token.optional) {
              continue;
            } else {
              throw new TypeError('Expected "' + token.name + '" to not be empty');
            }
          }

          for (var j = 0; j < value.length; j++) {
            segment = encode(value[j]);

            if (!matches[i].test(segment)) {
              throw new TypeError('Expected all "' + token.name + '" to match "' + token.pattern + '", but received `' + JSON.stringify(segment) + '`');
            }

            path += (j === 0 ? token.prefix : token.delimiter) + segment;
          }

          continue;
        }

        segment = token.asterisk ? encodeAsterisk(value) : encode(value);

        if (!matches[i].test(segment)) {
          throw new TypeError('Expected "' + token.name + '" to match "' + token.pattern + '", but received "' + segment + '"');
        }

        path += token.prefix + segment;
      }

      return path;
    };
  }

  function escapeString(str) {
    return str.replace(/([.+*?=^!:${}()[\]|\/\\])/g, '\\$1');
  }

  function escapeGroup(group) {
    return group.replace(/([=!:$\/()])/g, '\\$1');
  }

  function attachKeys(re, keys) {
    re.keys = keys;
    return re;
  }

  function flags(options) {
    return options && options.sensitive ? '' : 'i';
  }

  function regexpToRegexp(path, keys) {
    var groups = path.source.match(/\((?!\?)/g);

    if (groups) {
      for (var i = 0; i < groups.length; i++) {
        keys.push({
          name: i,
          prefix: null,
          delimiter: null,
          optional: false,
          repeat: false,
          partial: false,
          asterisk: false,
          pattern: null
        });
      }
    }

    return attachKeys(path, keys);
  }

  function arrayToRegexp(path, keys, options) {
    var parts = [];

    for (var i = 0; i < path.length; i++) {
      parts.push(pathToRegexp(path[i], keys, options).source);
    }

    var regexp = new RegExp('(?:' + parts.join('|') + ')', flags(options));
    return attachKeys(regexp, keys);
  }

  function stringToRegexp(path, keys, options) {
    return tokensToRegExp(parse(path, options), keys, options);
  }

  function tokensToRegExp(tokens, keys, options) {
    if (!isarray(keys)) {
      options = keys || options;
      keys = [];
    }

    options = options || {};
    var strict = options.strict;
    var end = options.end !== false;
    var route = '';

    for (var i = 0; i < tokens.length; i++) {
      var token = tokens[i];

      if (typeof token === 'string') {
        route += escapeString(token);
      } else {
        var prefix = escapeString(token.prefix);
        var capture = '(?:' + token.pattern + ')';
        keys.push(token);

        if (token.repeat) {
          capture += '(?:' + prefix + capture + ')*';
        }

        if (token.optional) {
          if (!token.partial) {
            capture = '(?:' + prefix + '(' + capture + '))?';
          } else {
            capture = prefix + '(' + capture + ')?';
          }
        } else {
          capture = prefix + '(' + capture + ')';
        }

        route += capture;
      }
    }

    var delimiter = escapeString(options.delimiter || '/');
    var endsWithDelimiter = route.slice(-delimiter.length) === delimiter;

    if (!strict) {
      route = (endsWithDelimiter ? route.slice(0, -delimiter.length) : route) + '(?:' + delimiter + '(?=$))?';
    }

    if (end) {
      route += '$';
    } else {
      route += strict && endsWithDelimiter ? '' : '(?=' + delimiter + '|$)';
    }

    return attachKeys(new RegExp('^' + route, flags(options)), keys);
  }

  function pathToRegexp(path, keys, options) {
    if (!isarray(keys)) {
      options = keys || options;
      keys = [];
    }

    options = options || {};

    if (path instanceof RegExp) {
      return regexpToRegexp(path, keys);
    }

    if (isarray(path)) {
      return arrayToRegexp(path, keys, options);
    }

    return stringToRegexp(path, keys, options);
  }
},471,[472],"node_modules/path-to-regexp/index.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  module.exports = Array.isArray || function (arr) {
    return Object.prototype.toString.call(arr) == '[object Array]';
  };
},472,[],"node_modules/path-to-regexp/node_modules/isarray/index.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _slicedToArray = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/slicedToArray");

  var _extends = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/extends");

  var _toConsumableArray = _$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/toConsumableArray");

  var strictUriEncode = _$$_REQUIRE(_dependencyMap[3], "strict-uri-encode");

  var decodeComponent = _$$_REQUIRE(_dependencyMap[4], "decode-uri-component");

  var splitOnFirst = _$$_REQUIRE(_dependencyMap[5], "split-on-first");

  function encoderForArrayFormat(options) {
    switch (options.arrayFormat) {
      case 'index':
        return function (key) {
          return function (result, value) {
            var index = result.length;

            if (value === undefined || options.skipNull && value === null) {
              return result;
            }

            if (value === null) {
              return [].concat(_toConsumableArray(result), [[encode(key, options), '[', index, ']'].join('')]);
            }

            return [].concat(_toConsumableArray(result), [[encode(key, options), '[', encode(index, options), ']=', encode(value, options)].join('')]);
          };
        };

      case 'bracket':
        return function (key) {
          return function (result, value) {
            if (value === undefined || options.skipNull && value === null) {
              return result;
            }

            if (value === null) {
              return [].concat(_toConsumableArray(result), [[encode(key, options), '[]'].join('')]);
            }

            return [].concat(_toConsumableArray(result), [[encode(key, options), '[]=', encode(value, options)].join('')]);
          };
        };

      case 'comma':
        return function (key) {
          return function (result, value) {
            if (value === null || value === undefined || value.length === 0) {
              return result;
            }

            if (result.length === 0) {
              return [[encode(key, options), '=', encode(value, options)].join('')];
            }

            return [[result, encode(value, options)].join(',')];
          };
        };

      default:
        return function (key) {
          return function (result, value) {
            if (value === undefined || options.skipNull && value === null) {
              return result;
            }

            if (value === null) {
              return [].concat(_toConsumableArray(result), [encode(key, options)]);
            }

            return [].concat(_toConsumableArray(result), [[encode(key, options), '=', encode(value, options)].join('')]);
          };
        };
    }
  }

  function parserForArrayFormat(options) {
    var result;

    switch (options.arrayFormat) {
      case 'index':
        return function (key, value, accumulator) {
          result = /\[(\d*)\]$/.exec(key);
          key = key.replace(/\[\d*\]$/, '');

          if (!result) {
            accumulator[key] = value;
            return;
          }

          if (accumulator[key] === undefined) {
            accumulator[key] = {};
          }

          accumulator[key][result[1]] = value;
        };

      case 'bracket':
        return function (key, value, accumulator) {
          result = /(\[\])$/.exec(key);
          key = key.replace(/\[\]$/, '');

          if (!result) {
            accumulator[key] = value;
            return;
          }

          if (accumulator[key] === undefined) {
            accumulator[key] = [value];
            return;
          }

          accumulator[key] = [].concat(accumulator[key], value);
        };

      case 'comma':
        return function (key, value, accumulator) {
          var isArray = typeof value === 'string' && value.split('').indexOf(',') > -1;
          var newValue = isArray ? value.split(',') : value;
          accumulator[key] = newValue;
        };

      default:
        return function (key, value, accumulator) {
          if (accumulator[key] === undefined) {
            accumulator[key] = value;
            return;
          }

          accumulator[key] = [].concat(accumulator[key], value);
        };
    }
  }

  function encode(value, options) {
    if (options.encode) {
      return options.strict ? strictUriEncode(value) : encodeURIComponent(value);
    }

    return value;
  }

  function decode(value, options) {
    if (options.decode) {
      return decodeComponent(value);
    }

    return value;
  }

  function keysSorter(input) {
    if (Array.isArray(input)) {
      return input.sort();
    }

    if (typeof input === 'object') {
      return keysSorter(Object.keys(input)).sort(function (a, b) {
        return Number(a) - Number(b);
      }).map(function (key) {
        return input[key];
      });
    }

    return input;
  }

  function removeHash(input) {
    var hashStart = input.indexOf('#');

    if (hashStart !== -1) {
      input = input.slice(0, hashStart);
    }

    return input;
  }

  function getHash(url) {
    var hash = '';
    var hashStart = url.indexOf('#');

    if (hashStart !== -1) {
      hash = url.slice(hashStart);
    }

    return hash;
  }

  function extract(input) {
    input = removeHash(input);
    var queryStart = input.indexOf('?');

    if (queryStart === -1) {
      return '';
    }

    return input.slice(queryStart + 1);
  }

  function parseValue(value, options) {
    if (options.parseNumbers && !Number.isNaN(Number(value)) && typeof value === 'string' && value.trim() !== '') {
      value = Number(value);
    } else if (options.parseBooleans && value !== null && (value.toLowerCase() === 'true' || value.toLowerCase() === 'false')) {
      value = value.toLowerCase() === 'true';
    }

    return value;
  }

  function parse(input, options) {
    options = _extends({
      decode: true,
      sort: true,
      arrayFormat: 'none',
      parseNumbers: false,
      parseBooleans: false
    }, options);
    var formatter = parserForArrayFormat(options);
    var ret = Object.create(null);

    if (typeof input !== 'string') {
      return ret;
    }

    input = input.trim().replace(/^[?#&]/, '');

    if (!input) {
      return ret;
    }

    for (var _iterator = input.split('&'), _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"]();;) {
      var _ref;

      if (_isArray) {
        if (_i >= _iterator.length) break;
        _ref = _iterator[_i++];
      } else {
        _i = _iterator.next();
        if (_i.done) break;
        _ref = _i.value;
      }

      var _param = _ref;

      var _splitOnFirst = splitOnFirst(options.decode ? _param.replace(/\+/g, ' ') : _param, '='),
          _splitOnFirst2 = _slicedToArray(_splitOnFirst, 2),
          _key2 = _splitOnFirst2[0],
          _value2 = _splitOnFirst2[1];

      _value2 = _value2 === undefined ? null : decode(_value2, options);
      formatter(decode(_key2, options), _value2, ret);
    }

    for (var _i2 = 0, _Object$keys = Object.keys(ret); _i2 < _Object$keys.length; _i2++) {
      var _key = _Object$keys[_i2];
      var _value = ret[_key];

      if (typeof _value === 'object' && _value !== null) {
        for (var _i3 = 0, _Object$keys2 = Object.keys(_value); _i3 < _Object$keys2.length; _i3++) {
          var k = _Object$keys2[_i3];
          _value[k] = parseValue(_value[k], options);
        }
      } else {
        ret[_key] = parseValue(_value, options);
      }
    }

    if (options.sort === false) {
      return ret;
    }

    return (options.sort === true ? Object.keys(ret).sort() : Object.keys(ret).sort(options.sort)).reduce(function (result, key) {
      var value = ret[key];

      if (Boolean(value) && typeof value === 'object' && !Array.isArray(value)) {
        result[key] = keysSorter(value);
      } else {
        result[key] = value;
      }

      return result;
    }, Object.create(null));
  }

  exports.extract = extract;
  exports.parse = parse;

  exports.stringify = function (object, options) {
    if (!object) {
      return '';
    }

    options = _extends({
      encode: true,
      strict: true,
      arrayFormat: 'none'
    }, options);
    var formatter = encoderForArrayFormat(options);

    var objectCopy = _extends({}, object);

    if (options.skipNull) {
      for (var _i4 = 0, _Object$keys3 = Object.keys(objectCopy); _i4 < _Object$keys3.length; _i4++) {
        var key = _Object$keys3[_i4];

        if (objectCopy[key] === undefined || objectCopy[key] === null) {
          delete objectCopy[key];
        }
      }
    }

    var keys = Object.keys(objectCopy);

    if (options.sort !== false) {
      keys.sort(options.sort);
    }

    return keys.map(function (key) {
      var value = object[key];

      if (value === undefined) {
        return '';
      }

      if (value === null) {
        return encode(key, options);
      }

      if (Array.isArray(value)) {
        return value.reduce(formatter(key), []).join('&');
      }

      return encode(key, options) + '=' + encode(value, options);
    }).filter(function (x) {
      return x.length > 0;
    }).join('&');
  };

  exports.parseUrl = function (input, options) {
    return {
      url: removeHash(input).split('?')[0] || '',
      query: parse(extract(input), options)
    };
  };

  exports.stringifyUrl = function (input, options) {
    var url = removeHash(input.url).split('?')[0] || '';
    var queryFromUrl = exports.extract(input.url);
    var parsedQueryFromUrl = exports.parse(queryFromUrl);
    var hash = getHash(input.url);

    var query = _extends(parsedQueryFromUrl, input.query);

    var queryString = exports.stringify(query, options);

    if (queryString) {
      queryString = "?" + queryString;
    }

    return "" + url + queryString + hash;
  };
},473,[14,13,20,474,475,476],"node_modules/query-string/index.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  module.exports = function (str) {
    return encodeURIComponent(str).replace(/[!'()*]/g, function (x) {
      return "%" + x.charCodeAt(0).toString(16).toUpperCase();
    });
  };
},474,[],"node_modules/strict-uri-encode/index.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var token = '%[a-f0-9]{2}';
  var singleMatcher = new RegExp(token, 'gi');
  var multiMatcher = new RegExp('(' + token + ')+', 'gi');

  function decodeComponents(components, split) {
    try {
      return decodeURIComponent(components.join(''));
    } catch (err) {}

    if (components.length === 1) {
      return components;
    }

    split = split || 1;
    var left = components.slice(0, split);
    var right = components.slice(split);
    return Array.prototype.concat.call([], decodeComponents(left), decodeComponents(right));
  }

  function decode(input) {
    try {
      return decodeURIComponent(input);
    } catch (err) {
      var tokens = input.match(singleMatcher);

      for (var i = 1; i < tokens.length; i++) {
        input = decodeComponents(tokens, i).join('');
        tokens = input.match(singleMatcher);
      }

      return input;
    }
  }

  function customDecodeURIComponent(input) {
    var replaceMap = {
      '%FE%FF': "\uFFFD\uFFFD",
      '%FF%FE': "\uFFFD\uFFFD"
    };
    var match = multiMatcher.exec(input);

    while (match) {
      try {
        replaceMap[match[0]] = decodeURIComponent(match[0]);
      } catch (err) {
        var result = decode(match[0]);

        if (result !== match[0]) {
          replaceMap[match[0]] = result;
        }
      }

      match = multiMatcher.exec(input);
    }

    replaceMap['%C2'] = "\uFFFD";
    var entries = Object.keys(replaceMap);

    for (var i = 0; i < entries.length; i++) {
      var key = entries[i];
      input = input.replace(new RegExp(key, 'g'), replaceMap[key]);
    }

    return input;
  }

  module.exports = function (encodedURI) {
    if (typeof encodedURI !== 'string') {
      throw new TypeError('Expected `encodedURI` to be of type `string`, got `' + typeof encodedURI + '`');
    }

    try {
      encodedURI = encodedURI.replace(/\+/g, ' ');
      return decodeURIComponent(encodedURI);
    } catch (err) {
      return customDecodeURIComponent(encodedURI);
    }
  };
},475,[],"node_modules/decode-uri-component/index.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  module.exports = function (string, separator) {
    if (!(typeof string === 'string' && typeof separator === 'string')) {
      throw new TypeError('Expected the arguments to be of type `string`');
    }

    if (separator === '') {
      return [string];
    }

    var separatorIndex = string.indexOf(separator);

    if (separatorIndex === -1) {
      return [string];
    }

    return [string.slice(0, separatorIndex), string.slice(separatorIndex + separator.length)];
  };
},476,[],"node_modules/split-on-first/index.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits"));

  var _react = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "react"));

  var _SceneView = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "../SceneView"));

  var _jsxFileName = "/Users/satya/Workspace/Callstack/react-navigation-core/src/views/SwitchView/SwitchView.js";

  var SwitchView = function (_React$Component) {
    (0, _inherits2.default)(SwitchView, _React$Component);

    function SwitchView() {
      (0, _classCallCheck2.default)(this, SwitchView);
      return (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(SwitchView).apply(this, arguments));
    }

    (0, _createClass2.default)(SwitchView, [{
      key: "render",
      value: function render() {
        var state = this.props.navigation.state;
        var activeKey = state.routes[state.index].key;
        var descriptor = this.props.descriptors[activeKey];
        var ChildComponent = descriptor.getComponent();
        return _react.default.createElement(_SceneView.default, {
          component: ChildComponent,
          navigation: descriptor.navigation,
          screenProps: this.props.screenProps,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 12
          }
        });
      }
    }]);
    return SwitchView;
  }(_react.default.Component);

  exports.default = SwitchView;
},477,[1,24,25,32,34,37,54,478],"node_modules/@react-navigation/core/lib/module/views/SwitchView/SwitchView.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits"));

  var _react = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "react"));

  var _NavigationContext = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "./NavigationContext"));

  var _jsxFileName = "/Users/satya/Workspace/Callstack/react-navigation-core/src/views/SceneView.js";

  var SceneView = function (_React$PureComponent) {
    (0, _inherits2.default)(SceneView, _React$PureComponent);

    function SceneView() {
      (0, _classCallCheck2.default)(this, SceneView);
      return (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(SceneView).apply(this, arguments));
    }

    (0, _createClass2.default)(SceneView, [{
      key: "render",
      value: function render() {
        var _this$props = this.props,
            screenProps = _this$props.screenProps,
            Component = _this$props.component,
            navigation = _this$props.navigation;
        return _react.default.createElement(_NavigationContext.default.Provider, {
          value: navigation,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 8
          }
        }, _react.default.createElement(Component, {
          screenProps: screenProps,
          navigation: navigation,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 9
          }
        }));
      }
    }]);
    return SceneView;
  }(_react.default.PureComponent);

  exports.default = SceneView;
},478,[1,24,25,32,34,37,54,462],"node_modules/@react-navigation/core/lib/module/views/SceneView.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;
  var _default = {
    light: {
      header: '#fff',
      headerBorder: '#a7a7aa',
      body: '#fff',
      bodyBorder: '#a7a7aa',
      bodyContent: '#fff',
      label: 'rgba(0, 0, 0, 0.9)'
    },
    dark: {
      header: '#2a2a2a',
      headerBorder: '#3a3a3a',
      body: '#000',
      bodyBorder: '#343434',
      bodyContent: '#2a2a2a',
      label: '#fff'
    }
  };
  exports.default = _default;
},479,[],"node_modules/@react-navigation/core/lib/module/ThemeColors.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _react = _$$_REQUIRE(_dependencyMap[1], "react");

  var _ThemeContext = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "./views/ThemeContext"));

  var _default = function _default() {
    return (0, _react.useContext)(_ThemeContext.default);
  };

  exports.default = _default;
},480,[1,54,461],"node_modules/@react-navigation/core/lib/module/useTheme.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.completeTransition = exports.replace = exports.reset = exports.push = exports.popToTop = exports.pop = exports.COMPLETE_TRANSITION = exports.REPLACE = exports.RESET = exports.PUSH = exports.POP_TO_TOP = exports.POP = void 0;

  var _objectSpread2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/objectSpread"));

  var POP = 'Navigation/POP';
  exports.POP = POP;
  var POP_TO_TOP = 'Navigation/POP_TO_TOP';
  exports.POP_TO_TOP = POP_TO_TOP;
  var PUSH = 'Navigation/PUSH';
  exports.PUSH = PUSH;
  var RESET = 'Navigation/RESET';
  exports.RESET = RESET;
  var REPLACE = 'Navigation/REPLACE';
  exports.REPLACE = REPLACE;
  var COMPLETE_TRANSITION = 'Navigation/COMPLETE_TRANSITION';
  exports.COMPLETE_TRANSITION = COMPLETE_TRANSITION;

  var pop = function pop(payload) {
    return (0, _objectSpread2.default)({
      type: POP
    }, payload);
  };

  exports.pop = pop;

  var popToTop = function popToTop(payload) {
    return (0, _objectSpread2.default)({
      type: POP_TO_TOP
    }, payload);
  };

  exports.popToTop = popToTop;

  var push = function push(payload) {
    return (0, _objectSpread2.default)({
      type: PUSH
    }, payload);
  };

  exports.push = push;

  var reset = function reset(payload) {
    return (0, _objectSpread2.default)({
      type: RESET,
      key: null
    }, payload);
  };

  exports.reset = reset;

  var replace = function replace(payload) {
    return (0, _objectSpread2.default)({
      type: REPLACE
    }, payload);
  };

  exports.replace = replace;

  var completeTransition = function completeTransition(payload) {
    return (0, _objectSpread2.default)({
      type: COMPLETE_TRANSITION,
      preserveFocus: true
    }, payload);
  };

  exports.completeTransition = completeTransition;
},481,[1,451],"node_modules/@react-navigation/core/lib/module/routers/StackActions.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireWildcard");

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _toConsumableArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/toConsumableArray"));

  var _objectSpread2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/objectSpread"));

  var NavigationActions = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[4], "../NavigationActions"));

  var StackActions = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[5], "./StackActions"));

  var _createConfigGetter = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "./createConfigGetter"));

  var _getScreenForRouteName = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "./getScreenForRouteName"));

  var _StateUtils = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "../StateUtils"));

  var _validateRouteConfigMap = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "./validateRouteConfigMap"));

  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[10], "../utils/invariant"));

  var _KeyGenerator = _$$_REQUIRE(_dependencyMap[11], "./KeyGenerator");

  var _pathUtils = _$$_REQUIRE(_dependencyMap[12], "./pathUtils");

  function behavesLikePushAction(action) {
    return action.type === NavigationActions.NAVIGATE || action.type === StackActions.PUSH;
  }

  var defaultActionCreators = function defaultActionCreators() {
    return {};
  };

  function isResetToRootStack(action) {
    return action.type === StackActions.RESET && action.key === null;
  }

  var _default = function _default(routeConfigs) {
    var stackConfig = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
    (0, _validateRouteConfigMap.default)(routeConfigs);
    var childRouters = {};
    var routeNames = Object.keys(routeConfigs);
    routeNames.forEach(function (routeName) {
      var routeConfig = routeConfigs[routeName];
      var screen = routeConfig && routeConfig.screen ? routeConfig.screen : routeConfig;

      if (screen && screen.router) {
        childRouters[routeName] = screen.router;
      } else {
        childRouters[routeName] = null;
      }
    });
    var initialRouteParams = stackConfig.initialRouteParams;
    var getCustomActionCreators = stackConfig.getCustomActionCreators || defaultActionCreators;
    var initialRouteName = stackConfig.initialRouteName || routeNames[0];
    var initialChildRouter = childRouters[initialRouteName];

    function getInitialState(action) {
      var route = {};
      var childRouter = childRouters[action.routeName];

      if (behavesLikePushAction(action) && childRouter !== undefined) {
        var childState = {};

        if (childRouter !== null) {
          var childAction = action.action || NavigationActions.init({
            params: action.params
          });
          childState = childRouter.getStateForAction(childAction);
        }

        return {
          key: 'StackRouterRoot',
          isTransitioning: false,
          index: 0,
          routes: [(0, _objectSpread2.default)({
            params: action.params
          }, childState, {
            key: action.key || (0, _KeyGenerator.generateKey)(),
            routeName: action.routeName
          })]
        };
      }

      if (initialChildRouter) {
        route = initialChildRouter.getStateForAction(NavigationActions.navigate({
          routeName: initialRouteName,
          params: initialRouteParams
        }));
      }

      var params = (routeConfigs[initialRouteName].params || route.params || action.params || initialRouteParams) && (0, _objectSpread2.default)({}, routeConfigs[initialRouteName].params || {}, route.params || {}, action.params || {}, initialRouteParams || {});
      var initialRouteKey = stackConfig.initialRouteKey;
      route = (0, _objectSpread2.default)({}, route, params ? {
        params: params
      } : {}, {
        routeName: initialRouteName,
        key: action.key || initialRouteKey || (0, _KeyGenerator.generateKey)()
      });
      return {
        key: 'StackRouterRoot',
        isTransitioning: false,
        index: 0,
        routes: [route]
      };
    }

    function getParamsForRouteAndAction(routeName, action) {
      var routeConfig = routeConfigs[routeName];

      if (routeConfig && routeConfig.params) {
        return (0, _objectSpread2.default)({}, routeConfig.params, action.params);
      } else {
        return action.params;
      }
    }

    var _createPathParser = (0, _pathUtils.createPathParser)(childRouters, routeConfigs, stackConfig),
        getPathAndParamsForRoute = _createPathParser.getPathAndParamsForRoute,
        _getActionForPathAndParams = _createPathParser.getActionForPathAndParams;

    return {
      childRouters: childRouters,
      getComponentForState: function getComponentForState(state) {
        var activeChildRoute = state.routes[state.index];
        var routeName = activeChildRoute.routeName;

        if (childRouters[routeName]) {
          return childRouters[routeName].getComponentForState(activeChildRoute);
        }

        return (0, _getScreenForRouteName.default)(routeConfigs, routeName);
      },
      getComponentForRouteName: function getComponentForRouteName(routeName) {
        return (0, _getScreenForRouteName.default)(routeConfigs, routeName);
      },
      getActionCreators: function getActionCreators(route, navStateKey) {
        return (0, _objectSpread2.default)({}, getCustomActionCreators(route, navStateKey), {
          pop: function pop(n, params) {
            return StackActions.pop((0, _objectSpread2.default)({
              n: n
            }, params));
          },
          popToTop: function popToTop(params) {
            return StackActions.popToTop(params);
          },
          push: function push(routeName, params, action) {
            return StackActions.push({
              routeName: routeName,
              params: params,
              action: action
            });
          },
          replace: function replace(replaceWith, params, action, newKey) {
            if (typeof replaceWith === 'string') {
              return StackActions.replace({
                routeName: replaceWith,
                params: params,
                action: action,
                key: route.key,
                newKey: newKey
              });
            }

            (0, _invariant.default)(typeof replaceWith === 'object', 'Must replaceWith an object or a string');
            (0, _invariant.default)(params == null, 'Params must not be provided to .replace() when specifying an object');
            (0, _invariant.default)(action == null, 'Child action must not be provided to .replace() when specifying an object');
            (0, _invariant.default)(newKey == null, 'Child action must not be provided to .replace() when specifying an object');
            return StackActions.replace(replaceWith);
          },
          reset: function reset(actions, index) {
            return StackActions.reset({
              actions: actions,
              index: index == null ? actions.length - 1 : index,
              key: navStateKey
            });
          },
          dismiss: function dismiss() {
            return NavigationActions.back({
              key: navStateKey
            });
          }
        });
      },
      getStateForAction: function getStateForAction(action, state) {
        if (!state) {
          return getInitialState(action);
        }

        var activeChildRoute = state.routes[state.index];

        if (!isResetToRootStack(action) && action.type !== NavigationActions.NAVIGATE) {
          var activeChildRouter = childRouters[activeChildRoute.routeName];

          if (activeChildRouter) {
            var route = activeChildRouter.getStateForAction(action, activeChildRoute);

            if (route !== null && route !== activeChildRoute) {
              return _StateUtils.default.replaceAt(state, activeChildRoute.key, route, action.type === NavigationActions.SET_PARAMS);
            }
          }
        } else if (action.type === NavigationActions.NAVIGATE) {
          for (var _iterator = state.routes.slice().reverse(), _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[typeof Symbol === "function" ? typeof Symbol === "function" ? Symbol.iterator : "@@iterator" : "@@iterator"]();;) {
            var _ref;

            if (_isArray) {
              if (_i >= _iterator.length) break;
              _ref = _iterator[_i++];
            } else {
              _i = _iterator.next();
              if (_i.done) break;
              _ref = _i.value;
            }

            var _childRoute = _ref;
            var childRouter = childRouters[_childRoute.routeName];
            var childAction = action.routeName === _childRoute.routeName && action.action ? action.action : action;

            if (childRouter) {
              var nextRouteState = childRouter.getStateForAction(childAction, _childRoute);

              if (nextRouteState === null || nextRouteState !== _childRoute) {
                var newState = _StateUtils.default.replaceAndPrune(state, nextRouteState ? nextRouteState.key : _childRoute.key, nextRouteState ? nextRouteState : _childRoute);

                return (0, _objectSpread2.default)({}, newState, {
                  isTransitioning: state.index !== newState.index ? action.immediate !== true : state.isTransitioning
                });
              }
            }
          }
        }

        if (behavesLikePushAction(action) && childRouters[action.routeName] !== undefined) {
          var _childRouter = childRouters[action.routeName];

          var _route;

          (0, _invariant.default)(action.type !== StackActions.PUSH || action.key == null, 'StackRouter does not support key on the push action');
          var lastRouteIndex = state.routes.findIndex(function (r) {
            if (action.key) {
              return r.key === action.key;
            } else {
              return r.routeName === action.routeName;
            }
          });

          if (action.type !== StackActions.PUSH && lastRouteIndex !== -1) {
            if (state.index === lastRouteIndex && !action.params) {
              return null;
            }

            var routes = state.routes.slice(0, lastRouteIndex + 1);

            if (action.params) {
              var _route2 = state.routes[lastRouteIndex];
              routes[lastRouteIndex] = (0, _objectSpread2.default)({}, _route2, {
                params: (0, _objectSpread2.default)({}, _route2.params, action.params)
              });
            }

            return (0, _objectSpread2.default)({}, state, {
              isTransitioning: state.index !== lastRouteIndex ? action.immediate !== true : state.isTransitioning,
              index: lastRouteIndex,
              routes: routes
            });
          }

          if (_childRouter) {
            var _childAction = action.action || NavigationActions.init({
              params: getParamsForRouteAndAction(action.routeName, action)
            });

            _route = (0, _objectSpread2.default)({
              params: getParamsForRouteAndAction(action.routeName, action)
            }, _childRouter.getStateForAction(_childAction), {
              routeName: action.routeName,
              key: action.key || (0, _KeyGenerator.generateKey)()
            });
          } else {
            _route = {
              params: getParamsForRouteAndAction(action.routeName, action),
              routeName: action.routeName,
              key: action.key || (0, _KeyGenerator.generateKey)()
            };
          }

          return (0, _objectSpread2.default)({}, _StateUtils.default.push(state, _route), {
            isTransitioning: action.immediate !== true
          });
        } else if (action.type === StackActions.PUSH && childRouters[action.routeName] === undefined) {
          return state;
        }

        if (behavesLikePushAction(action)) {
          var childRouterNames = Object.keys(childRouters);

          for (var i = 0; i < childRouterNames.length; i++) {
            var childRouterName = childRouterNames[i];
            var _childRouter2 = childRouters[childRouterName];

            if (_childRouter2) {
              var initChildRoute = _childRouter2.getStateForAction(NavigationActions.init());

              var navigatedChildRoute = _childRouter2.getStateForAction(action, initChildRoute);

              var routeToPush = null;

              if (navigatedChildRoute === null) {
                routeToPush = initChildRoute;
              } else if (navigatedChildRoute !== initChildRoute) {
                routeToPush = navigatedChildRoute;
              }

              if (routeToPush) {
                var _route3 = (0, _objectSpread2.default)({}, routeToPush, {
                  routeName: childRouterName,
                  key: action.key || (0, _KeyGenerator.generateKey)()
                });

                return (0, _objectSpread2.default)({}, _StateUtils.default.push(state, _route3), {
                  isTransitioning: action.immediate !== true
                });
              }
            }
          }
        }

        if (action.type === StackActions.POP_TO_TOP) {
          if (action.key && state.key !== action.key) {
            return state;
          }

          if (state.index > 0) {
            return (0, _objectSpread2.default)({}, state, {
              isTransitioning: action.immediate !== true,
              index: 0,
              routes: [state.routes[0]]
            });
          }

          return state;
        }

        if (action.type === StackActions.REPLACE) {
          var routeIndex;

          if (action.key === undefined && state.routes.length) {
            routeIndex = state.routes.length - 1;
          } else {
            routeIndex = state.routes.findIndex(function (r) {
              return r.key === action.key;
            });
          }

          if (routeIndex !== -1) {
            var _childRouter3 = childRouters[action.routeName];
            var childState = {};

            if (_childRouter3) {
              var _childAction2 = action.action || NavigationActions.init({
                params: getParamsForRouteAndAction(action.routeName, action)
              });

              childState = _childRouter3.getStateForAction(_childAction2);
            }

            var _routes = (0, _toConsumableArray2.default)(state.routes);

            _routes[routeIndex] = (0, _objectSpread2.default)({
              params: getParamsForRouteAndAction(action.routeName, action)
            }, childState, {
              routeName: action.routeName,
              key: action.newKey || (0, _KeyGenerator.generateKey)()
            });
            return (0, _objectSpread2.default)({}, state, {
              routes: _routes
            });
          }
        }

        if (action.type === StackActions.COMPLETE_TRANSITION && (action.key == null || action.key === state.key) && action.toChildKey === state.routes[state.index].key && state.isTransitioning) {
          return (0, _objectSpread2.default)({}, state, {
            isTransitioning: false
          });
        }

        if (action.type === NavigationActions.SET_PARAMS) {
          var key = action.key;
          var lastRoute = state.routes.find(function (route) {
            return route.key === key;
          });

          if (lastRoute) {
            var params = (0, _objectSpread2.default)({}, lastRoute.params, action.params);

            var _routes2 = (0, _toConsumableArray2.default)(state.routes);

            _routes2[state.routes.indexOf(lastRoute)] = (0, _objectSpread2.default)({}, lastRoute, {
              params: params
            });
            return (0, _objectSpread2.default)({}, state, {
              routes: _routes2
            });
          }
        }

        if (action.type === StackActions.RESET) {
          if (action.key != null && action.key != state.key) {
            return state;
          }

          var newStackActions = action.actions;
          return (0, _objectSpread2.default)({}, state, {
            routes: newStackActions.map(function (newStackAction) {
              var router = childRouters[newStackAction.routeName];
              var childState = {};

              if (router) {
                var _childAction3 = newStackAction.action || NavigationActions.init({
                  params: getParamsForRouteAndAction(newStackAction.routeName, newStackAction)
                });

                childState = router.getStateForAction(_childAction3);
              }

              return (0, _objectSpread2.default)({
                params: getParamsForRouteAndAction(newStackAction.routeName, newStackAction)
              }, childState, {
                routeName: newStackAction.routeName,
                key: newStackAction.key || (0, _KeyGenerator.generateKey)()
              });
            }),
            index: action.index
          });
        }

        if (action.type === NavigationActions.BACK || action.type === StackActions.POP) {
          var _key = action.key,
              n = action.n,
              immediate = action.immediate;
          var backRouteIndex = state.index;

          if (action.type === StackActions.POP && n != null) {
            backRouteIndex = Math.max(1, state.index - n + 1);
          } else if (_key) {
            var backRoute = state.routes.find(function (route) {
              return route.key === _key;
            });
            backRouteIndex = state.routes.indexOf(backRoute);
          }

          if (backRouteIndex > 0) {
            return (0, _objectSpread2.default)({}, state, {
              routes: state.routes.slice(0, backRouteIndex),
              index: backRouteIndex - 1,
              isTransitioning: immediate !== true
            });
          }
        }

        var keyIndex = action.key ? _StateUtils.default.indexOf(state, action.key) : -1;

        for (var _iterator2 = state.routes.slice().reverse(), _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[typeof Symbol === "function" ? typeof Symbol === "function" ? Symbol.iterator : "@@iterator" : "@@iterator"]();;) {
          var _ref2;

          if (_isArray2) {
            if (_i2 >= _iterator2.length) break;
            _ref2 = _iterator2[_i2++];
          } else {
            _i2 = _iterator2.next();
            if (_i2.done) break;
            _ref2 = _i2.value;
          }

          var _childRoute3 = _ref2;

          if (_childRoute3.key === activeChildRoute.key) {
            continue;
          }

          if (keyIndex >= 0 && _childRoute3.key !== action.key) {
            continue;
          }

          var _childRouter5 = childRouters[_childRoute3.routeName];

          if (_childRouter5) {
            var _route4 = _childRouter5.getStateForAction(action, _childRoute3);

            if (_route4 === null) {
              return state;
            } else if (_route4 && _route4 !== _childRoute3) {
              return _StateUtils.default.replaceAt(state, _childRoute3.key, _route4, action.preserveFocus || action.type.includes('DRAWER'));
            }
          }
        }

        return state;
      },
      getPathAndParamsForState: function getPathAndParamsForState(state) {
        var route = state.routes[state.index];
        return getPathAndParamsForRoute(route);
      },
      getActionForPathAndParams: function getActionForPathAndParams(path, params) {
        return _getActionForPathAndParams(path, params);
      },
      getScreenOptions: (0, _createConfigGetter.default)(routeConfigs, stackConfig.defaultNavigationOptions)
    };
  };

  exports.default = _default;
},482,[9,1,20,451,455,481,466,465,450,469,452,483,470],"node_modules/@react-navigation/core/lib/module/routers/StackRouter.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports._TESTING_ONLY_normalize_keys = _TESTING_ONLY_normalize_keys;
  exports.generateKey = generateKey;
  var uniqueBaseId = "id-" + Date.now();
  var uuidCount = 0;

  function _TESTING_ONLY_normalize_keys() {
    uniqueBaseId = "id";
    uuidCount = 0;
  }

  function generateKey() {
    return uniqueBaseId + "-" + uuidCount++;
  }
},483,[],"node_modules/@react-navigation/core/lib/module/routers/KeyGenerator.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _objectSpread2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/objectSpread"));

  var _SwitchRouter = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "./SwitchRouter"));

  var _withDefaultValue = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../utils/withDefaultValue"));

  var _default = function _default(routeConfigs) {
    var config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
    config = (0, _objectSpread2.default)({}, config);
    config = (0, _withDefaultValue.default)(config, 'resetOnBlur', false);
    config = (0, _withDefaultValue.default)(config, 'backBehavior', 'initialRoute');
    var switchRouter = (0, _SwitchRouter.default)(routeConfigs, config);
    return switchRouter;
  };

  exports.default = _default;
},484,[1,451,464,485],"node_modules/@react-navigation/core/lib/module/routers/TabRouter.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _default = function _default(obj, key, defaultValue) {
    if (obj.hasOwnProperty(key) && typeof obj[key] !== 'undefined') {
      return obj;
    }

    obj[key] = defaultValue;
    return obj;
  };

  exports.default = _default;
},485,[],"node_modules/@react-navigation/core/lib/module/utils/withDefaultValue.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var getActiveChildNavigationOptions = function getActiveChildNavigationOptions(navigation, screenProps) {
    var theme = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'light';
    var state = navigation.state,
        router = navigation.router,
        getChildNavigation = navigation.getChildNavigation;
    var activeRoute = state.routes[state.index];
    var activeNavigation = getChildNavigation(activeRoute.key);
    var options = router.getScreenOptions(activeNavigation, screenProps, theme);
    return options;
  };

  var _default = getActiveChildNavigationOptions;
  exports.default = _default;
},486,[],"node_modules/@react-navigation/core/lib/module/utils/getActiveChildNavigationOptions.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf3 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits"));

  var _react = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "react"));

  var _withNavigation = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "./withNavigation"));

  var EventNameToPropName = {
    willFocus: 'onWillFocus',
    didFocus: 'onDidFocus',
    willBlur: 'onWillBlur',
    didBlur: 'onDidBlur'
  };
  var EventNames = Object.keys(EventNameToPropName);

  var NavigationEvents = function (_React$Component) {
    (0, _inherits2.default)(NavigationEvents, _React$Component);

    function NavigationEvents() {
      var _getPrototypeOf2;

      var _this;

      (0, _classCallCheck2.default)(this, NavigationEvents);

      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
        args[_key] = arguments[_key];
      }

      _this = (0, _possibleConstructorReturn2.default)(this, (_getPrototypeOf2 = (0, _getPrototypeOf3.default)(NavigationEvents)).call.apply(_getPrototypeOf2, [this].concat(args)));

      _this.getPropListener = function (eventName) {
        return _this.props[EventNameToPropName[eventName]];
      };

      return _this;
    }

    (0, _createClass2.default)(NavigationEvents, [{
      key: "componentDidMount",
      value: function componentDidMount() {
        var _this2 = this;

        this.subscriptions = {};
        EventNames.forEach(function (eventName) {
          _this2.subscriptions[eventName] = _this2.props.navigation.addListener(eventName, function () {
            var propListener = _this2.getPropListener(eventName);

            return propListener && propListener.apply(void 0, arguments);
          });
        });
      }
    }, {
      key: "componentWillUnmount",
      value: function componentWillUnmount() {
        var _this3 = this;

        EventNames.forEach(function (eventName) {
          _this3.subscriptions[eventName].remove();
        });
      }
    }, {
      key: "render",
      value: function render() {
        return null;
      }
    }]);
    return NavigationEvents;
  }(_react.default.Component);

  var _default = (0, _withNavigation.default)(NavigationEvents);

  exports.default = _default;
},487,[1,24,25,32,34,37,54,488],"node_modules/@react-navigation/core/lib/module/views/NavigationEvents.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = withNavigation;

  var _extends2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/extends"));

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits"));

  var _react = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "react"));

  var _hoistNonReactStatics = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "hoist-non-react-statics"));

  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "../utils/invariant"));

  var _NavigationContext = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[10], "./NavigationContext"));

  var _jsxFileName = "/Users/satya/Workspace/Callstack/react-navigation-core/src/views/withNavigation.js";

  function withNavigation(Component) {
    var config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
      forwardRef: true
    };

    var ComponentWithNavigation = function (_React$Component) {
      (0, _inherits2.default)(ComponentWithNavigation, _React$Component);

      function ComponentWithNavigation() {
        (0, _classCallCheck2.default)(this, ComponentWithNavigation);
        return (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(ComponentWithNavigation).apply(this, arguments));
      }

      (0, _createClass2.default)(ComponentWithNavigation, [{
        key: "render",
        value: function render() {
          var _this = this;

          var navigationProp = this.props.navigation;
          return _react.default.createElement(_NavigationContext.default.Consumer, {
            __source: {
              fileName: _jsxFileName,
              lineNumber: 17
            }
          }, function (navigationContext) {
            var navigation = navigationProp || navigationContext;
            (0, _invariant.default)(!!navigation, 'withNavigation can only be used on a view hierarchy of a navigator. The wrapped component is unable to get access to navigation from props or context.');
            return _react.default.createElement(Component, (0, _extends2.default)({}, _this.props, {
              navigation: navigation,
              ref: config.forwardRef ? _this.props.onRef : undefined,
              __source: {
                fileName: _jsxFileName,
                lineNumber: 25
              }
            }));
          });
        }
      }]);
      return ComponentWithNavigation;
    }(_react.default.Component);

    ComponentWithNavigation.displayName = "withNavigation(" + (Component.displayName || Component.name) + ")";
    return (0, _hoistNonReactStatics.default)(ComponentWithNavigation, Component);
  }
},488,[1,13,24,25,32,34,37,54,489,452,462],"node_modules/@react-navigation/core/lib/module/views/withNavigation.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var reactIs = _$$_REQUIRE(_dependencyMap[0], "react-is");

  var REACT_STATICS = {
    childContextTypes: true,
    contextType: true,
    contextTypes: true,
    defaultProps: true,
    displayName: true,
    getDefaultProps: true,
    getDerivedStateFromError: true,
    getDerivedStateFromProps: true,
    mixins: true,
    propTypes: true,
    type: true
  };
  var KNOWN_STATICS = {
    name: true,
    length: true,
    prototype: true,
    caller: true,
    callee: true,
    arguments: true,
    arity: true
  };
  var FORWARD_REF_STATICS = {
    '$$typeof': true,
    render: true,
    defaultProps: true,
    displayName: true,
    propTypes: true
  };
  var MEMO_STATICS = {
    '$$typeof': true,
    compare: true,
    defaultProps: true,
    displayName: true,
    propTypes: true,
    type: true
  };
  var TYPE_STATICS = {};
  TYPE_STATICS[reactIs.ForwardRef] = FORWARD_REF_STATICS;

  function getStatics(component) {
    if (reactIs.isMemo(component)) {
      return MEMO_STATICS;
    }

    return TYPE_STATICS[component['$$typeof']] || REACT_STATICS;
  }

  var defineProperty = Object.defineProperty;
  var getOwnPropertyNames = Object.getOwnPropertyNames;
  var getOwnPropertySymbols = Object.getOwnPropertySymbols;
  var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
  var getPrototypeOf = Object.getPrototypeOf;
  var objectPrototype = Object.prototype;

  function hoistNonReactStatics(targetComponent, sourceComponent, blacklist) {
    if (typeof sourceComponent !== 'string') {
      if (objectPrototype) {
        var inheritedComponent = getPrototypeOf(sourceComponent);

        if (inheritedComponent && inheritedComponent !== objectPrototype) {
          hoistNonReactStatics(targetComponent, inheritedComponent, blacklist);
        }
      }

      var keys = getOwnPropertyNames(sourceComponent);

      if (getOwnPropertySymbols) {
        keys = keys.concat(getOwnPropertySymbols(sourceComponent));
      }

      var targetStatics = getStatics(targetComponent);
      var sourceStatics = getStatics(sourceComponent);

      for (var i = 0; i < keys.length; ++i) {
        var key = keys[i];

        if (!KNOWN_STATICS[key] && !(blacklist && blacklist[key]) && !(sourceStatics && sourceStatics[key]) && !(targetStatics && targetStatics[key])) {
          var descriptor = getOwnPropertyDescriptor(sourceComponent, key);

          try {
            defineProperty(targetComponent, key, descriptor);
          } catch (e) {}
        }
      }
    }

    return targetComponent;
  }

  module.exports = hoistNonReactStatics;
},489,[70],"node_modules/hoist-non-react-statics/dist/hoist-non-react-statics.cjs.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = withNavigationFocus;

  var _extends2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/extends"));

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits"));

  var _react = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "react"));

  var _hoistNonReactStatics = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "hoist-non-react-statics"));

  var _withNavigation = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "./withNavigation"));

  var _jsxFileName = "/Users/satya/Workspace/Callstack/react-navigation-core/src/views/withNavigationFocus.js";

  function withNavigationFocus(Component) {
    var ComponentWithNavigationFocus = function (_React$Component) {
      (0, _inherits2.default)(ComponentWithNavigationFocus, _React$Component);

      function ComponentWithNavigationFocus(props) {
        var _this;

        (0, _classCallCheck2.default)(this, ComponentWithNavigationFocus);
        _this = (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(ComponentWithNavigationFocus).call(this, props));
        _this.subscriptions = [props.navigation.addListener('didFocus', function () {
          return _this.setState({
            isFocused: true
          });
        }), props.navigation.addListener('willBlur', function () {
          return _this.setState({
            isFocused: false
          });
        })];
        _this.state = {
          isFocused: props.navigation ? props.navigation.isFocused() : false
        };
        return _this;
      }

      (0, _createClass2.default)(ComponentWithNavigationFocus, [{
        key: "componentWillUnmount",
        value: function componentWillUnmount() {
          this.subscriptions.forEach(function (sub) {
            return sub.remove();
          });
        }
      }, {
        key: "render",
        value: function render() {
          return _react.default.createElement(Component, (0, _extends2.default)({}, this.props, {
            isFocused: this.state.isFocused,
            ref: this.props.onRef,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 33
            }
          }));
        }
      }]);
      return ComponentWithNavigationFocus;
    }(_react.default.Component);

    ComponentWithNavigationFocus.displayName = "withNavigationFocus(" + (Component.displayName || Component.name) + ")";
    return (0, _hoistNonReactStatics.default)((0, _withNavigation.default)(ComponentWithNavigationFocus, {
      forwardRef: false
    }), Component);
  }
},490,[1,13,24,25,32,34,37,54,489,488],"node_modules/@react-navigation/core/lib/module/views/withNavigationFocus.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  module.exports = {
    get createAppContainer() {
      return _$$_REQUIRE(_dependencyMap[0], "./createAppContainer").default;
    },

    get createKeyboardAwareNavigator() {
      return _$$_REQUIRE(_dependencyMap[1], "./createKeyboardAwareNavigator").default;
    },

    get createNavigationAwareScrollable() {
      return _$$_REQUIRE(_dependencyMap[2], "./createNavigationAwareScrollable").default;
    },

    get withOrientation() {
      return _$$_REQUIRE(_dependencyMap[3], "./withOrientation").default;
    },

    get ResourceSavingSceneView() {
      return _$$_REQUIRE(_dependencyMap[4], "./ResourceSavingSceneView").default;
    },

    get SafeAreaView() {
      return _$$_REQUIRE(_dependencyMap[5], "react-native-safe-area-view").default;
    },

    get ScrollView() {
      return _$$_REQUIRE(_dependencyMap[6], "./Scrollables").ScrollView;
    },

    get FlatList() {
      return _$$_REQUIRE(_dependencyMap[6], "./Scrollables").FlatList;
    },

    get SectionList() {
      return _$$_REQUIRE(_dependencyMap[6], "./Scrollables").SectionList;
    },

    get Themed() {
      return _$$_REQUIRE(_dependencyMap[7], "./Themed").default;
    }

  };
},491,[492,495,496,497,498,499,502,528],"node_modules/@react-navigation/native/src/index.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports._TESTING_ONLY_reset_container_count = _TESTING_ONLY_reset_container_count;
  exports.default = createNavigationContainer;

  var _extends2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/extends"));

  var _slicedToArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/slicedToArray"));

  var _regenerator = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/regenerator"));

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/classCallCheck"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/getPrototypeOf"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "@babel/runtime/helpers/createClass"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "@babel/runtime/helpers/inherits"));

  var _objectWithoutProperties2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "@babel/runtime/helpers/objectWithoutProperties"));

  var _react = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[10], "react"));

  var _reactNative = _$$_REQUIRE(_dependencyMap[11], "react-native");

  var _core = _$$_REQUIRE(_dependencyMap[12], "@react-navigation/core");

  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[13], "./utils/invariant"));

  var _docsUrl = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[14], "./utils/docsUrl"));

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/@react-navigation/native/src/createAppContainer.js";
  var urlToPathAndParams = _core.pathUtils.urlToPathAndParams;

  function isStateful(props) {
    return !props.navigation;
  }

  function validateProps(props) {
    if (props.persistenceKey) {
      console.warn('You passed persistenceKey prop to a navigator. ' + 'The persistenceKey prop was replaced by a more flexible persistence mechanism, ' + 'please see the navigation state persistence docs for more information. ' + 'Passing the persistenceKey prop is a no-op.');
    }

    if (isStateful(props)) {
      return;
    }

    var navigation = props.navigation,
        screenProps = props.screenProps,
        persistNavigationState = props.persistNavigationState,
        loadNavigationState = props.loadNavigationState,
        theme = props.theme,
        containerProps = (0, _objectWithoutProperties2.default)(props, ["navigation", "screenProps", "persistNavigationState", "loadNavigationState", "theme"]);
    var keys = Object.keys(containerProps);

    if (keys.length !== 0) {
      throw new Error('This navigator has both navigation and container props, so it is ' + ("unclear if it should own its own state. Remove props: \"" + keys.join(', ') + "\" ") + 'if the navigator should get its state from the navigation prop. If the ' + 'navigator should maintain its own state, do not pass a navigation prop.');
    }

    (0, _invariant.default)(persistNavigationState === undefined && loadNavigationState === undefined || typeof persistNavigationState === 'function' && typeof loadNavigationState === 'function', 'both persistNavigationState and loadNavigationState must either be undefined, or be functions');
  }

  var _statefulContainerCount = 0;

  function _TESTING_ONLY_reset_container_count() {
    _statefulContainerCount = 0;
  }

  var _reactNavigationIsHydratingState = false;

  function createNavigationContainer(Component) {
    var NavigationContainer = function (_React$Component) {
      (0, _inherits2.default)(NavigationContainer, _React$Component);
      (0, _createClass2.default)(NavigationContainer, null, [{
        key: "getDerivedStateFromProps",
        value: function getDerivedStateFromProps(nextProps) {
          validateProps(nextProps);
          return null;
        }
      }]);

      function NavigationContainer(props) {
        var _this;

        (0, _classCallCheck2.default)(this, NavigationContainer);
        _this = (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(NavigationContainer).call(this, props));
        _this.subs = null;
        _this._actionEventSubscribers = new Set();

        _this._handleOpenURL = function (_ref) {
          var url = _ref.url;
          var _this$props = _this.props,
              enableURLHandling = _this$props.enableURLHandling,
              uriPrefix = _this$props.uriPrefix;

          if (enableURLHandling === false) {
            return;
          }

          var parsedUrl = urlToPathAndParams(url, uriPrefix);

          if (parsedUrl) {
            var path = parsedUrl.path,
                params = parsedUrl.params;
            var action = Component.router.getActionForPathAndParams(path, params);

            if (action) {
              _this.dispatch(action);
            }
          }
        };

        _this._persistNavigationState = function _callee(nav) {
          var persistNavigationState;
          return _regenerator.default.async(function _callee$(_context) {
            while (1) {
              switch (_context.prev = _context.next) {
                case 0:
                  persistNavigationState = _this.props.persistNavigationState;

                  if (!persistNavigationState) {
                    _context.next = 10;
                    break;
                  }

                  _context.prev = 2;
                  _context.next = 5;
                  return _regenerator.default.awrap(persistNavigationState(nav));

                case 5:
                  _context.next = 10;
                  break;

                case 7:
                  _context.prev = 7;
                  _context.t0 = _context["catch"](2);
                  console.warn('Uncaught exception while calling persistNavigationState()! You should handle exceptions thrown from persistNavigationState(), ignoring them may result in undefined behavior.');

                case 10:
                case "end":
                  return _context.stop();
              }
            }
          }, null, null, [[2, 7]]);
        };

        _this.dispatch = function (action) {
          if (_this.props.navigation) {
            return _this.props.navigation.dispatch(action);
          }

          _this._navState = _this._navState || _this.state.nav;
          var lastNavState = _this._navState;
          (0, _invariant.default)(lastNavState, 'should be set in constructor if stateful');
          var reducedState = Component.router.getStateForAction(action, lastNavState);
          var navState = reducedState === null ? lastNavState : reducedState;

          var dispatchActionEvents = function dispatchActionEvents() {
            _this._actionEventSubscribers.forEach(function (subscriber) {
              return subscriber({
                type: 'action',
                action: action,
                state: navState,
                lastState: lastNavState
              });
            });
          };

          if (reducedState === null) {
            dispatchActionEvents();
            return true;
          }

          if (navState !== lastNavState) {
            _this._navState = navState;

            _this.setState({
              nav: navState
            }, function () {
              _this._onNavigationStateChange(lastNavState, navState, action);

              dispatchActionEvents();

              _this._persistNavigationState(navState);
            });

            return true;
          }

          dispatchActionEvents();
          return false;
        };

        _this._getScreenProps = function () {
          return _this.props.screenProps;
        };

        _this._getTheme = function () {
          if (_this.props.theme === 'light' || _this.props.theme === 'dark') {
            return _this.props.theme;
          } else if (_this.props.theme === 'no-preference') {
            return 'light';
          } else {
            console.warn("Invalid theme provided: " + _this.props.theme + ". Only 'light' and 'dark' are supported. Falling back to 'light'");
            return 'light';
          }
        };

        validateProps(props);
        _this._initialAction = _core.NavigationActions.init();

        if (_this._isStateful() && _reactNative.BackHandler && typeof _reactNative.BackHandler.addEventListener === 'function') {
          _this.subs = _reactNative.BackHandler.addEventListener('hardwareBackPress', function () {
            if (!_this._isMounted) {
              _this.subs && _this.subs.remove();
            } else {
              return _this.dispatch(_core.NavigationActions.back());
            }
          });
        }

        _this.state = {
          nav: _this._isStateful() && !props.loadNavigationState ? Component.router.getStateForAction(_this._initialAction) : null
        };
        return _this;
      }

      (0, _createClass2.default)(NavigationContainer, [{
        key: "_renderLoading",
        value: function _renderLoading() {
          return this.props.renderLoadingExperimental ? this.props.renderLoadingExperimental() : null;
        }
      }, {
        key: "_isStateful",
        value: function _isStateful() {
          return isStateful(this.props);
        }
      }, {
        key: "_onNavigationStateChange",
        value: function _onNavigationStateChange(prevNav, nav, action) {
          if (typeof this.props.onNavigationStateChange === 'undefined' && this._isStateful() && !!process.env.REACT_NAV_LOGGING) {
            if (console.group) {
              console.group('Navigation Dispatch: ');
              console.log('Action: ', action);
              console.log('New State: ', nav);
              console.log('Last State: ', prevNav);
              console.groupEnd();
            } else {
              console.log('Navigation Dispatch: ', {
                action: action,
                newState: nav,
                lastState: prevNav
              });
            }

            return;
          }

          if (typeof this.props.onNavigationStateChange === 'function') {
            this.props.onNavigationStateChange(prevNav, nav, action);
          }
        }
      }, {
        key: "componentDidUpdate",
        value: function componentDidUpdate() {
          if (this._navState === this.state.nav) {
            this._navState = null;
          }
        }
      }, {
        key: "componentDidMount",
        value: function componentDidMount() {
          var _this2 = this;

          var parsedUrl, userProvidedStartupState, _ref2, action, startupState, _parsedUrl, path, params, urlAction, dispatchActions;

          return _regenerator.default.async(function componentDidMount$(_context2) {
            while (1) {
              switch (_context2.prev = _context2.next) {
                case 0:
                  this._isMounted = true;

                  if (this._isStateful()) {
                    _context2.next = 3;
                    break;
                  }

                  return _context2.abrupt("return");

                case 3:
                  if (__DEV__ && !this.props.detached) {
                    if (_statefulContainerCount > 0) {
                      if (_reactNative.Platform.OS === 'ios') {
                        console.warn("You should only render one navigator explicitly in your app, and other navigators should be rendered by including them in that navigator. Full details at: " + (0, _docsUrl.default)('common-mistakes.html#explicitly-rendering-more-than-one-navigator'));
                      }
                    }
                  }

                  _statefulContainerCount++;

                  _reactNative.Linking.addEventListener('url', this._handleOpenURL);

                  parsedUrl = null;
                  userProvidedStartupState = null;

                  if (!(this.props.enableURLHandling !== false)) {
                    _context2.next = 14;
                    break;
                  }

                  _context2.next = 11;
                  return _regenerator.default.awrap(this.getStartupParams());

                case 11:
                  _ref2 = _context2.sent;
                  parsedUrl = _ref2.parsedUrl;
                  userProvidedStartupState = _ref2.userProvidedStartupState;

                case 14:
                  action = this._initialAction;
                  startupState = this.state.nav;

                  if (!startupState && !userProvidedStartupState) {
                    !!process.env.REACT_NAV_LOGGING && console.log('Init new Navigation State');
                    startupState = Component.router.getStateForAction(action);
                  }

                  if (userProvidedStartupState) {
                    startupState = userProvidedStartupState;
                    _reactNavigationIsHydratingState = true;
                  }

                  if (parsedUrl) {
                    _parsedUrl = parsedUrl, path = _parsedUrl.path, params = _parsedUrl.params;
                    urlAction = Component.router.getActionForPathAndParams(path, params);

                    if (urlAction) {
                      !!process.env.REACT_NAV_LOGGING && console.log('Applying Navigation Action for Initial URL:', parsedUrl);
                      action = urlAction;
                      startupState = Component.router.getStateForAction(urlAction, startupState);
                    }
                  }

                  dispatchActions = function dispatchActions() {
                    return _this2._actionEventSubscribers.forEach(function (subscriber) {
                      return subscriber({
                        type: 'action',
                        action: action,
                        state: _this2.state.nav,
                        lastState: null
                      });
                    });
                  };

                  if (!(startupState === this.state.nav)) {
                    _context2.next = 23;
                    break;
                  }

                  dispatchActions();
                  return _context2.abrupt("return");

                case 23:
                  this.setState({
                    nav: startupState
                  }, function () {
                    _reactNavigationIsHydratingState = false;
                    dispatchActions();
                  });

                case 24:
                case "end":
                  return _context2.stop();
              }
            }
          }, null, this);
        }
      }, {
        key: "getStartupParams",
        value: function getStartupParams() {
          var _this$props2, uriPrefix, loadNavigationState, url, loadedNavState, _ref3, _ref4;

          return _regenerator.default.async(function getStartupParams$(_context3) {
            while (1) {
              switch (_context3.prev = _context3.next) {
                case 0:
                  _this$props2 = this.props, uriPrefix = _this$props2.uriPrefix, loadNavigationState = _this$props2.loadNavigationState;
                  _context3.prev = 1;
                  _context3.next = 4;
                  return _regenerator.default.awrap(Promise.all([_reactNative.Linking.getInitialURL(), loadNavigationState && loadNavigationState()]));

                case 4:
                  _ref3 = _context3.sent;
                  _ref4 = (0, _slicedToArray2.default)(_ref3, 2);
                  url = _ref4[0];
                  loadedNavState = _ref4[1];
                  _context3.next = 12;
                  break;

                case 10:
                  _context3.prev = 10;
                  _context3.t0 = _context3["catch"](1);

                case 12:
                  return _context3.abrupt("return", {
                    parsedUrl: url && urlToPathAndParams(url, uriPrefix),
                    userProvidedStartupState: loadedNavState
                  });

                case 13:
                case "end":
                  return _context3.stop();
              }
            }
          }, null, this, [[1, 10]]);
        }
      }, {
        key: "componentDidCatch",
        value: function componentDidCatch(e) {
          if (_reactNavigationIsHydratingState) {
            _reactNavigationIsHydratingState = false;
            console.warn('Uncaught exception while starting app from persisted navigation state! Trying to render again with a fresh navigation state...');
            this.dispatch(_core.NavigationActions.init());
          } else {
            throw e;
          }
        }
      }, {
        key: "componentWillUnmount",
        value: function componentWillUnmount() {
          this._isMounted = false;

          _reactNative.Linking.removeEventListener('url', this._handleOpenURL);

          this.subs && this.subs.remove();

          if (this._isStateful()) {
            _statefulContainerCount--;
          }
        }
      }, {
        key: "render",
        value: function render() {
          var _this3 = this;

          var navigation = this.props.navigation;

          if (this._isStateful()) {
            var navState = this.state.nav;

            if (!navState) {
              return this._renderLoading();
            }

            if (!this._navigation || this._navigation.state !== navState) {
              this._navigation = (0, _core.getNavigation)(Component.router, navState, this.dispatch, this._actionEventSubscribers, this._getScreenProps, function () {
                return _this3._navigation;
              });
            }

            navigation = this._navigation;
          }

          (0, _invariant.default)(navigation, 'failed to get navigation');
          return _react.default.createElement(_core.ThemeProvider, {
            value: this._getTheme(),
            __source: {
              fileName: _jsxFileName,
              lineNumber: 428
            }
          }, _react.default.createElement(_core.NavigationProvider, {
            value: navigation,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 429
            }
          }, _react.default.createElement(Component, (0, _extends2.default)({}, this.props, {
            navigation: navigation,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 430
            }
          }))));
        }
      }]);
      return NavigationContainer;
    }(_react.default.Component);

    NavigationContainer.router = Component.router;
    NavigationContainer.navigationOptions = null;
    NavigationContainer.defaultProps = {
      theme: 'light'
    };
    return NavigationContainer;
  }
},492,[1,13,14,103,24,32,34,25,37,52,54,2,449,493,494],"node_modules/@react-navigation/native/src/createAppContainer.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var validateFormat = function validateFormat() {};

  if (__DEV__) {
    validateFormat = function validateFormat(format) {
      if (format === undefined) {
        throw new Error('invariant requires an error message argument');
      }
    };
  }

  function invariant(condition, format, a, b, c, d, e, f) {
    validateFormat(format);

    if (!condition) {
      var error;

      if (format === undefined) {
        error = new Error('Minified exception occurred; use the non-minified dev environment for the full error message and additional helpful warnings.');
      } else {
        var args = [a, b, c, d, e, f];
        var argIndex = 0;
        error = new Error(format.replace(/%s/g, function () {
          return args[argIndex++];
        }));
        error.name = 'Invariant Violation';
      }

      error.framesToPop = 1;
      throw error;
    }
  }

  module.exports = invariant;
},493,[],"node_modules/@react-navigation/native/src/utils/invariant.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = docsUrl;

  function docsUrl(path) {
    return "https://reactnavigation.org/docs/" + path;
  }
},494,[],"node_modules/@react-navigation/native/src/utils/docsUrl.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _extends2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/extends"));

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf3 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits"));

  var _react = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "react"));

  var _reactNative = _$$_REQUIRE(_dependencyMap[8], "react-native");

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/@react-navigation/native/src/createKeyboardAwareNavigator.js";

  var _default = function _default(Navigator, navigatorConfig) {
    var _class, _temp;

    return _temp = _class = function (_React$Component) {
      (0, _inherits2.default)(KeyboardAwareNavigator, _React$Component);

      function KeyboardAwareNavigator() {
        var _getPrototypeOf2;

        var _this;

        (0, _classCallCheck2.default)(this, KeyboardAwareNavigator);

        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
          args[_key] = arguments[_key];
        }

        _this = (0, _possibleConstructorReturn2.default)(this, (_getPrototypeOf2 = (0, _getPrototypeOf3.default)(KeyboardAwareNavigator)).call.apply(_getPrototypeOf2, [this].concat(args)));
        _this._previouslyFocusedTextInput = null;

        _this._handleGestureBegin = function () {
          _this._previouslyFocusedTextInput = _reactNative.TextInput.State.currentlyFocusedField();

          if (_this._previouslyFocusedTextInput) {
            _reactNative.TextInput.State.blurTextInput(_this._previouslyFocusedTextInput);
          }

          _this.props.onGestureBegin && _this.props.onGestureBegin();
        };

        _this._handleGestureCanceled = function () {
          if (_this._previouslyFocusedTextInput) {
            _reactNative.TextInput.State.focusTextInput(_this._previouslyFocusedTextInput);
          }

          _this.props.onGestureCanceled && _this.props.onGestureCanceled();
        };

        _this._handleGestureEnd = function () {
          _this._previouslyFocusedTextInput = null;
          _this.props.onGestureFinish && _this.props.onGestureFinish();
        };

        _this._handleTransitionStart = function (transitionProps, prevTransitionProps) {
          if (transitionProps.index !== prevTransitionProps.index) {
            var currentField = _reactNative.TextInput.State.currentlyFocusedField();

            if (currentField) {
              _reactNative.TextInput.State.blurTextInput(currentField);
            }
          }

          var onTransitionStart = _this.props.onTransitionStart || navigatorConfig.onTransitionStart;
          onTransitionStart && onTransitionStart(transitionProps, prevTransitionProps);
        };

        return _this;
      }

      (0, _createClass2.default)(KeyboardAwareNavigator, [{
        key: "render",
        value: function render() {
          return _react.default.createElement(Navigator, (0, _extends2.default)({}, this.props, {
            onGestureBegin: this._handleGestureBegin,
            onGestureCanceled: this._handleGestureCanceled,
            onGestureEnd: this._handleGestureEnd,
            onTransitionStart: this._handleTransitionStart,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 12
            }
          }));
        }
      }]);
      return KeyboardAwareNavigator;
    }(_react.default.Component), _class.router = Navigator.router, _class.navigationOptions = Navigator.navigationOptions, _temp;
  };

  exports.default = _default;
},495,[1,13,24,25,32,34,37,54,2],"node_modules/@react-navigation/native/src/createKeyboardAwareNavigator.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = createNavigationAwareScrollable;

  var _extends2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/extends"));

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf3 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits"));

  var _react = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "react"));

  var _hoistNonReactStatics = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "hoist-non-react-statics"));

  var _core = _$$_REQUIRE(_dependencyMap[9], "@react-navigation/core");

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/@react-navigation/native/src/createNavigationAwareScrollable.js";

  function createNavigationAwareScrollable(Component) {
    var _class, _temp;

    var ComponentWithNavigationScrolling = (0, _core.withNavigation)((_temp = _class = function (_React$PureComponent) {
      (0, _inherits2.default)(_class, _React$PureComponent);

      function _class() {
        (0, _classCallCheck2.default)(this, _class);
        return (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf3.default)(_class).apply(this, arguments));
      }

      (0, _createClass2.default)(_class, [{
        key: "componentDidMount",
        value: function componentDidMount() {
          var _this = this;

          this._subscription = this.props.navigation.addListener('refocus', function () {
            var scrollableNode = _this.getNode();

            if (_this.props.navigation.isFocused() && scrollableNode !== null) {
              if (scrollableNode.scrollToTop != null) {
                scrollableNode.scrollToTop();
              } else if (scrollableNode.scrollTo != null) {
                scrollableNode.scrollTo({
                  y: 0
                });
              } else if (scrollableNode.scrollResponderScrollTo != null) {
                scrollableNode.scrollResponderScrollTo({
                  y: 0
                });
              }
            }
          });
        }
      }, {
        key: "getNode",
        value: function getNode() {
          if (this._scrollRef === null) {
            return null;
          }

          if (this._scrollRef.getScrollResponder) {
            return this._scrollRef.getScrollResponder();
          } else if (this._scrollRef.getNode) {
            return this._scrollRef.getNode();
          } else {
            return this._scrollRef;
          }
        }
      }, {
        key: "componentWillUnmount",
        value: function componentWillUnmount() {
          if (this._subscription != null) {
            this._subscription.remove();
          }
        }
      }, {
        key: "render",
        value: function render() {
          var _this2 = this;

          return _react.default.createElement(Component, (0, _extends2.default)({
            ref: function ref(view) {
              _this2._scrollRef = view;
            }
          }, this.props, {
            __source: {
              fileName: _jsxFileName,
              lineNumber: 53
            }
          }));
        }
      }]);
      return _class;
    }(_react.default.PureComponent), _class.displayName = "withNavigationScrolling(" + (Component.displayName || Component.name) + ")", _temp));

    var NavigationAwareScrollable = function (_React$PureComponent2) {
      (0, _inherits2.default)(NavigationAwareScrollable, _React$PureComponent2);

      function NavigationAwareScrollable() {
        var _getPrototypeOf2;

        var _this3;

        (0, _classCallCheck2.default)(this, NavigationAwareScrollable);

        for (var _len = arguments.length, _args = new Array(_len), _key = 0; _key < _len; _key++) {
          _args[_key] = arguments[_key];
        }

        _this3 = (0, _possibleConstructorReturn2.default)(this, (_getPrototypeOf2 = (0, _getPrototypeOf3.default)(NavigationAwareScrollable)).call.apply(_getPrototypeOf2, [this].concat(_args)));

        _this3._captureRef = function (view) {
          _this3._innerRef = view;
          _this3.props.onRef && _this3.props.onRef(view);
        };

        _this3.setNativeProps = function () {
          var _this3$_innerRef$getN;

          return (_this3$_innerRef$getN = _this3._innerRef.getNode()).setNativeProps.apply(_this3$_innerRef$getN, arguments);
        };

        _this3.getScrollResponder = function () {
          var _this3$_innerRef$getN2;

          return (_this3$_innerRef$getN2 = _this3._innerRef.getNode()).getScrollResponder.apply(_this3$_innerRef$getN2, arguments);
        };

        _this3.getScrollableNode = function () {
          var _this3$_innerRef$getN3;

          return (_this3$_innerRef$getN3 = _this3._innerRef.getNode()).getScrollableNode.apply(_this3$_innerRef$getN3, arguments);
        };

        _this3.getInnerViewNode = function () {
          var _this3$_innerRef$getN4;

          return (_this3$_innerRef$getN4 = _this3._innerRef.getNode()).getInnerViewNode.apply(_this3$_innerRef$getN4, arguments);
        };

        _this3.scrollTo = function () {
          var _this3$_innerRef$getN5;

          return (_this3$_innerRef$getN5 = _this3._innerRef.getNode()).scrollTo.apply(_this3$_innerRef$getN5, arguments);
        };

        _this3.scrollToEnd = function () {
          var _this3$_innerRef$getN6;

          return (_this3$_innerRef$getN6 = _this3._innerRef.getNode()).scrollToEnd.apply(_this3$_innerRef$getN6, arguments);
        };

        _this3.scrollWithoutAnimationTo = function () {
          var _this3$_innerRef$getN7;

          return (_this3$_innerRef$getN7 = _this3._innerRef.getNode()).scrollWithoutAnimationTo.apply(_this3$_innerRef$getN7, arguments);
        };

        _this3.flashScrollIndicators = function () {
          var _this3$_innerRef$getN8;

          return (_this3$_innerRef$getN8 = _this3._innerRef.getNode()).flashScrollIndicators.apply(_this3$_innerRef$getN8, arguments);
        };

        return _this3;
      }

      (0, _createClass2.default)(NavigationAwareScrollable, [{
        key: "render",
        value: function render() {
          return _react.default.createElement(ComponentWithNavigationScrolling, (0, _extends2.default)({}, this.props, {
            onRef: this._captureRef,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 107
            }
          }));
        }
      }]);
      return NavigationAwareScrollable;
    }(_react.default.PureComponent);

    NavigationAwareScrollable.displayName = "NavigationAwareScrollable(" + (Component.displayName || Component.name) + ")";
    return (0, _hoistNonReactStatics.default)(NavigationAwareScrollable, Component);
  }
},496,[1,13,24,25,32,34,37,54,489,449],"node_modules/@react-navigation/native/src/createNavigationAwareScrollable.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = _default;
  exports.isOrientationLandscape = void 0;

  var _extends2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/extends"));

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits"));

  var _react = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "react"));

  var _reactNative = _$$_REQUIRE(_dependencyMap[8], "react-native");

  var _hoistNonReactStatics = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "hoist-non-react-statics"));

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/@react-navigation/native/src/withOrientation.js";

  var isOrientationLandscape = function isOrientationLandscape(_ref) {
    var width = _ref.width,
        height = _ref.height;
    return width > height;
  };

  exports.isOrientationLandscape = isOrientationLandscape;

  function _default(WrappedComponent) {
    var withOrientation = function (_React$Component) {
      (0, _inherits2.default)(withOrientation, _React$Component);

      function withOrientation() {
        var _this;

        (0, _classCallCheck2.default)(this, withOrientation);
        _this = (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(withOrientation).call(this));

        _this.handleOrientationChange = function (_ref2) {
          var window = _ref2.window;
          var isLandscape = isOrientationLandscape(window);

          _this.setState({
            isLandscape: isLandscape
          });
        };

        var _isLandscape = isOrientationLandscape(_reactNative.Dimensions.get('window'));

        _this.state = {
          isLandscape: _isLandscape
        };
        return _this;
      }

      (0, _createClass2.default)(withOrientation, [{
        key: "componentDidMount",
        value: function componentDidMount() {
          _reactNative.Dimensions.addEventListener('change', this.handleOrientationChange);
        }
      }, {
        key: "componentWillUnmount",
        value: function componentWillUnmount() {
          _reactNative.Dimensions.removeEventListener('change', this.handleOrientationChange);
        }
      }, {
        key: "render",
        value: function render() {
          return _react.default.createElement(WrappedComponent, (0, _extends2.default)({}, this.props, this.state, {
            __source: {
              fileName: _jsxFileName,
              lineNumber: 30
            }
          }));
        }
      }]);
      return withOrientation;
    }(_react.default.Component);

    return (0, _hoistNonReactStatics.default)(withOrientation, WrappedComponent);
  }
},497,[1,13,24,25,32,34,37,54,2,489],"node_modules/@react-navigation/native/src/withOrientation.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _extends2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/extends"));

  var _objectWithoutProperties2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/objectWithoutProperties"));

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/classCallCheck"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/getPrototypeOf"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/createClass"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "@babel/runtime/helpers/inherits"));

  var _react = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "react"));

  var _reactNative = _$$_REQUIRE(_dependencyMap[9], "react-native");

  var _core = _$$_REQUIRE(_dependencyMap[10], "@react-navigation/core");

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/@react-navigation/native/src/ResourceSavingSceneView.js";
  var FAR_FAR_AWAY = 3000;

  var ResourceSavingSceneView = function (_React$PureComponent) {
    (0, _inherits2.default)(ResourceSavingSceneView, _React$PureComponent);
    (0, _createClass2.default)(ResourceSavingSceneView, null, [{
      key: "getDerivedStateFromProps",
      value: function getDerivedStateFromProps(nextProps, prevState) {
        if (nextProps.isFocused && !prevState.awake) {
          return {
            awake: true
          };
        } else {
          return null;
        }
      }
    }]);

    function ResourceSavingSceneView(props) {
      var _this;

      (0, _classCallCheck2.default)(this, ResourceSavingSceneView);
      _this = (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(ResourceSavingSceneView).call(this));

      _this._mustAlwaysBeVisible = function () {
        return _this.props.animationEnabled || _this.props.swipeEnabled;
      };

      _this.state = {
        awake: props.lazy ? props.isFocused : true
      };
      return _this;
    }

    (0, _createClass2.default)(ResourceSavingSceneView, [{
      key: "render",
      value: function render() {
        var awake = this.state.awake;
        var _this$props = this.props,
            isFocused = _this$props.isFocused,
            childNavigation = _this$props.childNavigation,
            removeClippedSubviews = _this$props.removeClippedSubviews,
            rest = (0, _objectWithoutProperties2.default)(_this$props, ["isFocused", "childNavigation", "removeClippedSubviews"]);
        return _react.default.createElement(_reactNative.View, {
          style: styles.container,
          collapsable: false,
          removeClippedSubviews: _reactNative.Platform.OS === 'android' ? removeClippedSubviews : !isFocused && removeClippedSubviews,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 34
          }
        }, _react.default.createElement(_reactNative.View, {
          style: this._mustAlwaysBeVisible() || isFocused ? styles.innerAttached : styles.innerDetached,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 43
          }
        }, awake ? _react.default.createElement(_core.SceneView, (0, _extends2.default)({}, rest, {
          navigation: childNavigation,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 50
          }
        })) : null));
      }
    }]);
    return ResourceSavingSceneView;
  }(_react.default.PureComponent);

  var styles = _reactNative.StyleSheet.create({
    container: {
      flex: 1,
      overflow: 'hidden'
    },
    innerAttached: {
      flex: 1
    },
    innerDetached: {
      flex: 1,
      top: FAR_FAR_AWAY
    }
  });

  var _default = ResourceSavingSceneView;
  exports.default = _default;
},498,[1,13,52,24,32,34,25,37,54,2,449],"node_modules/@react-navigation/native/src/ResourceSavingSceneView.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/interopRequireWildcard");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.getInset = getInset;
  exports.getStatusBarHeight = getStatusBarHeight;
  exports.withSafeArea = exports.default = void 0;

  var _extends2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/extends"));

  var _objectWithoutProperties2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/objectWithoutProperties"));

  var _defineProperty2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/defineProperty"));

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf3 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "@babel/runtime/helpers/inherits"));

  var _react = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[10], "react"));

  var _reactNative = _$$_REQUIRE(_dependencyMap[11], "react-native");

  var _hoistNonReactStatics = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[12], "hoist-non-react-statics"));

  var _withOrientation = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[13], "./withOrientation"));

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native-safe-area-view/index.js";

  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

  var X_WIDTH = 375;
  var X_HEIGHT = 812;
  var XSMAX_WIDTH = 414;
  var XSMAX_HEIGHT = 896;
  var PAD_WIDTH = 768;
  var PAD_HEIGHT = 1024;
  var IPADPRO11_WIDTH = 834;
  var IPADPRO11_HEIGHT = 1194;
  var IPADPRO129_HEIGHT = 1024;
  var IPADPRO129_WIDTH = 1366;

  var getResolvedDimensions = function getResolvedDimensions() {
    var _Dimensions$get = _reactNative.Dimensions.get('window'),
        width = _Dimensions$get.width,
        height = _Dimensions$get.height;

    if (width === 0 && height === 0) return _reactNative.Dimensions.get('screen');
    return {
      width: width,
      height: height
    };
  };

  var _getResolvedDimension = getResolvedDimensions(),
      D_HEIGHT = _getResolvedDimension.height,
      D_WIDTH = _getResolvedDimension.width;

  var PlatformConstants = _reactNative.Platform.constants || {};

  var _ref = PlatformConstants.reactNativeVersion || {},
      _ref$minor = _ref.minor,
      minor = _ref$minor === void 0 ? 0 : _ref$minor;

  var isIPhoneX = function () {
    if (_reactNative.Platform.OS === 'web') return false;
    return _reactNative.Platform.OS === 'ios' && (D_HEIGHT === X_HEIGHT && D_WIDTH === X_WIDTH || D_HEIGHT === X_WIDTH && D_WIDTH === X_HEIGHT) || D_HEIGHT === XSMAX_HEIGHT && D_WIDTH === XSMAX_WIDTH || D_HEIGHT === XSMAX_WIDTH && D_WIDTH === XSMAX_HEIGHT;
  }();

  var isNewIPadPro = function () {
    if (_reactNative.Platform.OS !== 'ios') return false;
    return D_HEIGHT === IPADPRO11_HEIGHT && D_WIDTH === IPADPRO11_WIDTH || D_HEIGHT === IPADPRO11_WIDTH && D_WIDTH === IPADPRO11_HEIGHT || D_HEIGHT === IPADPRO129_HEIGHT && D_WIDTH === IPADPRO129_WIDTH || D_HEIGHT === IPADPRO129_WIDTH && D_WIDTH === IPADPRO129_HEIGHT;
  }();

  var isIPad = function () {
    if (_reactNative.Platform.OS !== 'ios' || isIPhoneX) return false;

    if (D_HEIGHT > D_WIDTH && D_WIDTH < PAD_WIDTH) {
      return false;
    }

    if (D_WIDTH > D_HEIGHT && D_HEIGHT < PAD_WIDTH) {
      return false;
    }

    return true;
  }();

  var _customStatusBarHeight = null;
  var _customStatusBarHidden = null;

  var statusBarHeight = function statusBarHeight(isLandscape) {
    if (_customStatusBarHeight !== null) {
      return _customStatusBarHeight;
    }

    if (_reactNative.Platform.OS === 'android') {
      if (global.Expo) {
        return global.Expo.Constants.statusBarHeight;
      } else {
        return 0;
      }
    }

    if (isIPhoneX) {
      return isLandscape ? 0 : 44;
    }

    if (isNewIPadPro) {
      return 24;
    }

    if (isIPad) {
      return _customStatusBarHidden ? 0 : 20;
    }

    return isLandscape || _customStatusBarHidden ? 0 : 20;
  };

  var doubleFromPercentString = function doubleFromPercentString(percent) {
    if (!percent.includes('%')) {
      return 0;
    }

    var dbl = parseFloat(percent) / 100;
    if (isNaN(dbl)) return 0;
    return dbl;
  };

  var SafeView = function (_Component) {
    (0, _inherits2.default)(SafeView, _Component);

    function SafeView() {
      var _getPrototypeOf2;

      var _this;

      (0, _classCallCheck2.default)(this, SafeView);

      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
        args[_key] = arguments[_key];
      }

      _this = (0, _possibleConstructorReturn2.default)(this, (_getPrototypeOf2 = (0, _getPrototypeOf3.default)(SafeView)).call.apply(_getPrototypeOf2, [this].concat(args)));
      _this.state = {
        touchesTop: true,
        touchesBottom: true,
        touchesLeft: true,
        touchesRight: true,
        orientation: null,
        viewWidth: 0,
        viewHeight: 0
      };

      _this._handleLayout = function (e) {
        if (_this.props.onLayout) _this.props.onLayout(e);

        _this._updateMeasurements();
      };

      _this._updateMeasurements = function () {
        if (!_this._isMounted) return;
        if (!_this.view) return;
        var isLandscape = _this.props.isLandscape;
        var orientation = _this.state.orientation;
        var newOrientation = isLandscape ? 'landscape' : 'portrait';

        if (orientation && orientation === newOrientation) {
          return;
        }

        var _getResolvedDimension2 = getResolvedDimensions(),
            WIDTH = _getResolvedDimension2.width,
            HEIGHT = _getResolvedDimension2.height;

        _this.view.getNode().measureInWindow(function (winX, winY, winWidth, winHeight) {
          if (!_this.view) {
            return;
          }

          var realY = winY;
          var realX = winX;

          if (realY >= HEIGHT) {
            realY = realY % HEIGHT;
          } else if (realY < 0) {
            realY = realY % HEIGHT + HEIGHT;
          }

          if (realX >= WIDTH) {
            realX = realX % WIDTH;
          } else if (realX < 0) {
            realX = realX % WIDTH + WIDTH;
          }

          var touchesTop = realY === 0;
          var touchesBottom = realY + winHeight >= HEIGHT;
          var touchesLeft = realX === 0;
          var touchesRight = realX + winWidth >= WIDTH;

          _this.setState({
            touchesTop: touchesTop,
            touchesBottom: touchesBottom,
            touchesLeft: touchesLeft,
            touchesRight: touchesRight,
            orientation: newOrientation,
            viewWidth: winWidth,
            viewHeight: winHeight
          });
        });
      };

      _this._getSafeAreaStyle = function () {
        var _this$state = _this.state,
            touchesTop = _this$state.touchesTop,
            touchesBottom = _this$state.touchesBottom,
            touchesLeft = _this$state.touchesLeft,
            touchesRight = _this$state.touchesRight;
        var _this$props = _this.props,
            forceInset = _this$props.forceInset,
            isLandscape = _this$props.isLandscape;

        var _this$_getViewStyles = _this._getViewStyles(),
            paddingTop = _this$_getViewStyles.paddingTop,
            paddingBottom = _this$_getViewStyles.paddingBottom,
            paddingLeft = _this$_getViewStyles.paddingLeft,
            paddingRight = _this$_getViewStyles.paddingRight,
            viewStyle = _this$_getViewStyles.viewStyle;

        var style = _objectSpread({}, viewStyle, {
          paddingTop: touchesTop ? _this._getInset('top') : 0,
          paddingBottom: touchesBottom ? _this._getInset('bottom') : 0,
          paddingLeft: touchesLeft ? _this._getInset('left') : 0,
          paddingRight: touchesRight ? _this._getInset('right') : 0
        });

        if (forceInset) {
          Object.keys(forceInset).forEach(function (key) {
            var inset = forceInset[key];

            if (inset === 'always') {
              inset = _this._getInset(key);
            }

            if (inset === 'never') {
              inset = 0;
            }

            switch (key) {
              case 'horizontal':
                {
                  style.paddingLeft = inset;
                  style.paddingRight = inset;
                  break;
                }

              case 'vertical':
                {
                  style.paddingTop = inset;
                  style.paddingBottom = inset;
                  break;
                }

              case 'left':
              case 'right':
              case 'top':
              case 'bottom':
                {
                  var padding = "padding" + key[0].toUpperCase() + key.slice(1);
                  style[padding] = inset;
                  break;
                }
            }
          });
        }

        if (style.height && typeof style.height === 'number') {
          style.height += style.paddingTop + style.paddingBottom;
        }

        if (style.width && typeof style.width === 'number') {
          style.width += style.paddingLeft + style.paddingRight;
        }

        style.paddingTop = Math.max(style.paddingTop, paddingTop);
        style.paddingBottom = Math.max(style.paddingBottom, paddingBottom);
        style.paddingLeft = Math.max(style.paddingLeft, paddingLeft);
        style.paddingRight = Math.max(style.paddingRight, paddingRight);
        return style;
      };

      _this._getViewStyles = function () {
        var viewWidth = _this.state.viewWidth;

        var _StyleSheet$flatten = _reactNative.StyleSheet.flatten(_this.props.style || {}),
            _StyleSheet$flatten$p = _StyleSheet$flatten.padding,
            padding = _StyleSheet$flatten$p === void 0 ? 0 : _StyleSheet$flatten$p,
            _StyleSheet$flatten$p2 = _StyleSheet$flatten.paddingVertical,
            paddingVertical = _StyleSheet$flatten$p2 === void 0 ? padding : _StyleSheet$flatten$p2,
            _StyleSheet$flatten$p3 = _StyleSheet$flatten.paddingHorizontal,
            paddingHorizontal = _StyleSheet$flatten$p3 === void 0 ? padding : _StyleSheet$flatten$p3,
            _StyleSheet$flatten$p4 = _StyleSheet$flatten.paddingTop,
            paddingTop = _StyleSheet$flatten$p4 === void 0 ? paddingVertical : _StyleSheet$flatten$p4,
            _StyleSheet$flatten$p5 = _StyleSheet$flatten.paddingBottom,
            paddingBottom = _StyleSheet$flatten$p5 === void 0 ? paddingVertical : _StyleSheet$flatten$p5,
            _StyleSheet$flatten$p6 = _StyleSheet$flatten.paddingLeft,
            paddingLeft = _StyleSheet$flatten$p6 === void 0 ? paddingHorizontal : _StyleSheet$flatten$p6,
            _StyleSheet$flatten$p7 = _StyleSheet$flatten.paddingRight,
            paddingRight = _StyleSheet$flatten$p7 === void 0 ? paddingHorizontal : _StyleSheet$flatten$p7,
            viewStyle = (0, _objectWithoutProperties2.default)(_StyleSheet$flatten, ["padding", "paddingVertical", "paddingHorizontal", "paddingTop", "paddingBottom", "paddingLeft", "paddingRight"]);

        if (typeof paddingTop !== 'number') {
          paddingTop = doubleFromPercentString(paddingTop) * viewWidth;
        }

        if (typeof paddingBottom !== 'number') {
          paddingBottom = doubleFromPercentString(paddingBottom) * viewWidth;
        }

        if (typeof paddingLeft !== 'number') {
          paddingLeft = doubleFromPercentString(paddingLeft) * viewWidth;
        }

        if (typeof paddingRight !== 'number') {
          paddingRight = doubleFromPercentString(paddingRight) * viewWidth;
        }

        return {
          paddingTop: paddingTop,
          paddingBottom: paddingBottom,
          paddingLeft: paddingLeft,
          paddingRight: paddingRight,
          viewStyle: viewStyle
        };
      };

      _this._getInset = function (key) {
        var isLandscape = _this.props.isLandscape;
        return getInset(key, isLandscape);
      };

      return _this;
    }

    (0, _createClass2.default)(SafeView, [{
      key: "componentDidMount",
      value: function componentDidMount() {
        var _this2 = this;

        this._isMounted = true;

        _reactNative.InteractionManager.runAfterInteractions(function () {
          _this2._updateMeasurements();
        });
      }
    }, {
      key: "componentWillUnmount",
      value: function componentWillUnmount() {
        this._isMounted = false;
      }
    }, {
      key: "componentDidUpdate",
      value: function componentDidUpdate() {
        this._updateMeasurements();
      }
    }, {
      key: "render",
      value: function render() {
        var _this3 = this;

        var _this$props2 = this.props,
            _this$props2$forceIns = _this$props2.forceInset,
            forceInset = _this$props2$forceIns === void 0 ? false : _this$props2$forceIns,
            isLandscape = _this$props2.isLandscape,
            style = _this$props2.style,
            props = (0, _objectWithoutProperties2.default)(_this$props2, ["forceInset", "isLandscape", "style"]);

        var safeAreaStyle = this._getSafeAreaStyle();

        return _react.default.createElement(_reactNative.Animated.View, (0, _extends2.default)({
          ref: function ref(c) {
            return _this3.view = c;
          },
          pointerEvents: "box-none"
        }, props, {
          onLayout: this._handleLayout,
          style: safeAreaStyle,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 163
          }
        }));
      }
    }]);
    return SafeView;
  }(_react.Component);

  SafeView.setStatusBarHeight = function (height) {
    _customStatusBarHeight = height;
  };

  SafeView.setStatusBarHidden = function (hidden) {
    _customStatusBarHidden = hidden;
  };

  function getInset(key, isLandscape) {
    switch (key) {
      case 'horizontal':
      case 'right':
      case 'left':
        {
          return isLandscape ? isIPhoneX ? 44 : 0 : 0;
        }

      case 'vertical':
      case 'top':
        {
          return statusBarHeight(isLandscape);
        }

      case 'bottom':
        {
          if (isIPhoneX) {
            return isLandscape ? 24 : 34;
          }

          if (isNewIPadPro) {
            return 20;
          }

          return 0;
        }
    }
  }

  function getStatusBarHeight(isLandscape) {
    return statusBarHeight(isLandscape);
  }

  var SafeAreaView = (0, _withOrientation.default)(SafeView);
  var _default = SafeAreaView;
  exports.default = _default;

  var withSafeArea = function withSafeArea() {
    var forceInset = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    return function (WrappedComponent) {
      var withSafeArea = function (_Component2) {
        (0, _inherits2.default)(withSafeArea, _Component2);

        function withSafeArea() {
          (0, _classCallCheck2.default)(this, withSafeArea);
          return (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf3.default)(withSafeArea).apply(this, arguments));
        }

        (0, _createClass2.default)(withSafeArea, [{
          key: "render",
          value: function render() {
            return _react.default.createElement(SafeAreaView, {
              style: {
                flex: 1
              },
              forceInset: forceInset,
              __source: {
                fileName: _jsxFileName,
                lineNumber: 385
              }
            }, _react.default.createElement(WrappedComponent, (0, _extends2.default)({}, this.props, {
              __source: {
                fileName: _jsxFileName,
                lineNumber: 386
              }
            })));
          }
        }]);
        return withSafeArea;
      }(_react.Component);

      return (0, _hoistNonReactStatics.default)(withSafeArea, WrappedComponent);
    };
  };

  exports.withSafeArea = withSafeArea;
},499,[1,9,13,52,46,24,25,32,34,37,54,2,500,501],"node_modules/react-native-safe-area-view/index.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var REACT_STATICS = {
    childContextTypes: true,
    contextTypes: true,
    defaultProps: true,
    displayName: true,
    getDefaultProps: true,
    getDerivedStateFromProps: true,
    mixins: true,
    propTypes: true,
    type: true
  };
  var KNOWN_STATICS = {
    name: true,
    length: true,
    prototype: true,
    caller: true,
    callee: true,
    arguments: true,
    arity: true
  };
  var defineProperty = Object.defineProperty;
  var getOwnPropertyNames = Object.getOwnPropertyNames;
  var getOwnPropertySymbols = Object.getOwnPropertySymbols;
  var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
  var getPrototypeOf = Object.getPrototypeOf;
  var objectPrototype = getPrototypeOf && getPrototypeOf(Object);

  function hoistNonReactStatics(targetComponent, sourceComponent, blacklist) {
    if (typeof sourceComponent !== 'string') {
      if (objectPrototype) {
        var inheritedComponent = getPrototypeOf(sourceComponent);

        if (inheritedComponent && inheritedComponent !== objectPrototype) {
          hoistNonReactStatics(targetComponent, inheritedComponent, blacklist);
        }
      }

      var keys = getOwnPropertyNames(sourceComponent);

      if (getOwnPropertySymbols) {
        keys = keys.concat(getOwnPropertySymbols(sourceComponent));
      }

      for (var i = 0; i < keys.length; ++i) {
        var key = keys[i];

        if (!REACT_STATICS[key] && !KNOWN_STATICS[key] && (!blacklist || !blacklist[key])) {
          var descriptor = getOwnPropertyDescriptor(sourceComponent, key);

          try {
            defineProperty(targetComponent, key, descriptor);
          } catch (e) {}
        }
      }

      return targetComponent;
    }

    return targetComponent;
  }

  module.exports = hoistNonReactStatics;
},500,[],"node_modules/react-native-safe-area-view/node_modules/hoist-non-react-statics/dist/hoist-non-react-statics.cjs.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/interopRequireWildcard");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = _default;
  exports.isOrientationLandscape = void 0;

  var _extends2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/extends"));

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "@babel/runtime/helpers/inherits"));

  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[8], "react"));

  var _reactNative = _$$_REQUIRE(_dependencyMap[9], "react-native");

  var _hoistNonReactStatics = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[10], "hoist-non-react-statics"));

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native-safe-area-view/withOrientation.js";

  var isOrientationLandscape = function isOrientationLandscape(_ref) {
    var width = _ref.width,
        height = _ref.height;
    return width > height;
  };

  exports.isOrientationLandscape = isOrientationLandscape;

  function _default(WrappedComponent) {
    var withOrientation = function (_React$Component) {
      (0, _inherits2.default)(withOrientation, _React$Component);

      function withOrientation() {
        var _this;

        (0, _classCallCheck2.default)(this, withOrientation);
        _this = (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(withOrientation).call(this));

        _this.handleOrientationChange = function (_ref2) {
          var window = _ref2.window;
          var isLandscape = isOrientationLandscape(window);

          _this.setState({
            isLandscape: isLandscape
          });
        };

        var _isLandscape = isOrientationLandscape(_reactNative.Dimensions.get('window'));

        _this.state = {
          isLandscape: _isLandscape
        };
        return _this;
      }

      (0, _createClass2.default)(withOrientation, [{
        key: "componentDidMount",
        value: function componentDidMount() {
          if (typeof _reactNative.Dimensions.addEventListener === 'function') {
            _reactNative.Dimensions.addEventListener('change', this.handleOrientationChange);
          }
        }
      }, {
        key: "componentWillUnmount",
        value: function componentWillUnmount() {
          if (typeof _reactNative.Dimensions.removeEventListener === 'function') {
            _reactNative.Dimensions.removeEventListener('change', this.handleOrientationChange);
          }
        }
      }, {
        key: "render",
        value: function render() {
          return React.createElement(WrappedComponent, (0, _extends2.default)({}, this.props, this.state, {
            __source: {
              fileName: _jsxFileName,
              lineNumber: 54
            }
          }));
        }
      }]);
      return withOrientation;
    }(React.Component);

    return (0, _hoistNonReactStatics.default)(withOrientation, WrappedComponent);
  }
},501,[1,9,13,24,25,32,34,37,54,2,500],"node_modules/react-native-safe-area-view/withOrientation.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _extends2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/extends"));

  var _defineProperty2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/defineProperty"));

  var _react = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "react"));

  var _reactNative = _$$_REQUIRE(_dependencyMap[4], "react-native");

  var _reactNativeGestureHandler = _$$_REQUIRE(_dependencyMap[5], "react-native-gesture-handler");

  var _createNavigationAwareScrollable = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "./createNavigationAwareScrollable"));

  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "./utils/invariant"));

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/@react-navigation/native/src/Scrollables.js";

  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

  var WrappedScrollView;

  if (_reactNative.Platform.OS === 'android') {
    WrappedScrollView = (0, _createNavigationAwareScrollable.default)(_reactNative.ScrollView);
  } else {
    WrappedScrollView = (0, _createNavigationAwareScrollable.default)(_reactNativeGestureHandler.ScrollView);
  }

  function propsMaybeWithRefreshControl(props) {
    var onRefresh = props.onRefresh;

    if (onRefresh) {
      (0, _invariant.default)(typeof props.refreshing === 'boolean', '`refreshing` prop must be set as a boolean in order to use `onRefresh`, but got `' + JSON.stringify(props.refreshing) + '`');
      return _objectSpread({}, props, {
        refreshControl: props.refreshControl == null ? _react.default.createElement(_reactNative.RefreshControl, {
          refreshing: props.refreshing,
          onRefresh: onRefresh,
          progressViewOffset: props.progressViewOffset,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 36
          }
        }) : props.refreshControl
      });
    } else {
      return props;
    }
  }

  var WrappedFlatList = _react.default.forwardRef(function (props, ref) {
    return _react.default.createElement(_reactNative.FlatList, (0, _extends2.default)({
      ref: ref
    }, props, {
      renderScrollComponent: function renderScrollComponent(props) {
        return _react.default.createElement(WrappedScrollView, (0, _extends2.default)({}, propsMaybeWithRefreshControl(props), {
          __source: {
            fileName: _jsxFileName,
            lineNumber: 55
          }
        }));
      },
      __source: {
        fileName: _jsxFileName,
        lineNumber: 51
      }
    }));
  });

  var WrappedSectionList = _react.default.forwardRef(function (props, ref) {
    return _react.default.createElement(_reactNative.SectionList, (0, _extends2.default)({
      ref: ref
    }, props, {
      renderScrollComponent: function renderScrollComponent(props) {
        return _react.default.createElement(WrappedScrollView, (0, _extends2.default)({}, propsMaybeWithRefreshControl(props), {
          __source: {
            fileName: _jsxFileName,
            lineNumber: 65
          }
        }));
      },
      __source: {
        fileName: _jsxFileName,
        lineNumber: 61
      }
    }));
  });

  module.exports = {
    ScrollView: WrappedScrollView,
    FlatList: WrappedFlatList,
    SectionList: WrappedSectionList
  };
},502,[1,13,46,54,2,503,496,493],"node_modules/@react-navigation/native/src/Scrollables.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  var _exportNames = {
    Swipeable: true,
    DrawerLayout: true
  };
  Object.defineProperty(exports, "Swipeable", {
    enumerable: true,
    get: function get() {
      return _Swipeable.default;
    }
  });
  Object.defineProperty(exports, "DrawerLayout", {
    enumerable: true,
    get: function get() {
      return _DrawerLayout.default;
    }
  });

  var _Swipeable = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./Swipeable"));

  var _DrawerLayout = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "./DrawerLayout"));

  var _GestureHandler = _$$_REQUIRE(_dependencyMap[3], "./GestureHandler");

  Object.keys(_GestureHandler).forEach(function (key) {
    if (key === "default" || key === "__esModule") return;
    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
    Object.defineProperty(exports, key, {
      enumerable: true,
      get: function get() {
        return _GestureHandler[key];
      }
    });
  });

  var _touchables = _$$_REQUIRE(_dependencyMap[4], "./touchables");

  Object.keys(_touchables).forEach(function (key) {
    if (key === "default" || key === "__esModule") return;
    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
    Object.defineProperty(exports, key, {
      enumerable: true,
      get: function get() {
        return _touchables[key];
      }
    });
  });
},503,[1,504,521,505,522],"node_modules/react-native-gesture-handler/index.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/interopRequireWildcard");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _extends2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/extends"));

  var _defineProperty2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/defineProperty"));

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "@babel/runtime/helpers/inherits"));

  var _react = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[9], "react"));

  var _reactNative = _$$_REQUIRE(_dependencyMap[10], "react-native");

  var _GestureHandler = _$$_REQUIRE(_dependencyMap[11], "./GestureHandler");

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native-gesture-handler/Swipeable.js";

  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

  var DRAG_TOSS = 0.05;

  var Swipeable = function (_Component) {
    (0, _inherits2.default)(Swipeable, _Component);

    function Swipeable(_props) {
      var _this;

      (0, _classCallCheck2.default)(this, Swipeable);
      _this = (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(Swipeable).call(this, _props));

      _this._updateAnimatedEvent = function (props, state) {
        var friction = props.friction,
            overshootFriction = props.overshootFriction,
            useNativeAnimations = props.useNativeAnimations;
        var dragX = state.dragX,
            rowTranslation = state.rowTranslation,
            _state$leftWidth = state.leftWidth,
            leftWidth = _state$leftWidth === void 0 ? 0 : _state$leftWidth,
            _state$rowWidth = state.rowWidth,
            rowWidth = _state$rowWidth === void 0 ? 0 : _state$rowWidth;
        var _state$rightOffset = state.rightOffset,
            rightOffset = _state$rightOffset === void 0 ? rowWidth : _state$rightOffset;
        var rightWidth = Math.max(0, rowWidth - rightOffset);
        var _props$overshootLeft = props.overshootLeft,
            overshootLeft = _props$overshootLeft === void 0 ? leftWidth > 0 : _props$overshootLeft,
            _props$overshootRight = props.overshootRight,
            overshootRight = _props$overshootRight === void 0 ? rightWidth > 0 : _props$overshootRight;

        var transX = _reactNative.Animated.add(rowTranslation, dragX.interpolate({
          inputRange: [0, friction],
          outputRange: [0, 1]
        })).interpolate({
          inputRange: [-rightWidth - (overshootRight ? 1 : overshootFriction), -rightWidth, leftWidth, leftWidth + (overshootLeft ? 1 : overshootFriction)],
          outputRange: [-rightWidth - (overshootRight || overshootFriction > 1 ? 1 : 0), -rightWidth, leftWidth, leftWidth + (overshootLeft || overshootFriction > 1 ? 1 : 0)]
        });

        _this._transX = transX;
        _this._showLeftAction = leftWidth > 0 ? transX.interpolate({
          inputRange: [-1, 0, leftWidth],
          outputRange: [0, 0, 1]
        }) : new _reactNative.Animated.Value(0);
        _this._leftActionTranslate = _this._showLeftAction.interpolate({
          inputRange: [0, Number.MIN_VALUE],
          outputRange: [-10000, 0],
          extrapolate: 'clamp'
        });
        _this._showRightAction = rightWidth > 0 ? transX.interpolate({
          inputRange: [-rightWidth, 0, 1],
          outputRange: [1, 0, 0]
        }) : new _reactNative.Animated.Value(0);
        _this._rightActionTranslate = _this._showRightAction.interpolate({
          inputRange: [0, Number.MIN_VALUE],
          outputRange: [-10000, 0],
          extrapolate: 'clamp'
        });
      };

      _this._onTapHandlerStateChange = function (_ref) {
        var nativeEvent = _ref.nativeEvent;

        if (nativeEvent.oldState === _GestureHandler.State.ACTIVE) {
          _this.close();
        }
      };

      _this._onHandlerStateChange = function (_ref2) {
        var nativeEvent = _ref2.nativeEvent;

        if (nativeEvent.oldState === _GestureHandler.State.ACTIVE) {
          _this._handleRelease(nativeEvent);
        }
      };

      _this._handleRelease = function (nativeEvent) {
        var velocityX = nativeEvent.velocityX,
            dragX = nativeEvent.translationX;
        var _this$state = _this.state,
            _this$state$leftWidth = _this$state.leftWidth,
            leftWidth = _this$state$leftWidth === void 0 ? 0 : _this$state$leftWidth,
            _this$state$rowWidth = _this$state.rowWidth,
            rowWidth = _this$state$rowWidth === void 0 ? 0 : _this$state$rowWidth,
            rowState = _this$state.rowState;
        var _this$state$rightOffs = _this.state.rightOffset,
            rightOffset = _this$state$rightOffs === void 0 ? rowWidth : _this$state$rightOffs;
        var rightWidth = rowWidth - rightOffset;
        var _this$props = _this.props,
            friction = _this$props.friction,
            _this$props$leftThres = _this$props.leftThreshold,
            leftThreshold = _this$props$leftThres === void 0 ? leftWidth / 2 : _this$props$leftThres,
            _this$props$rightThre = _this$props.rightThreshold,
            rightThreshold = _this$props$rightThre === void 0 ? rightWidth / 2 : _this$props$rightThre;
        var startOffsetX = _this._currentOffset() + dragX / friction;
        var translationX = (dragX + DRAG_TOSS * velocityX) / friction;
        var toValue = 0;

        if (rowState === 0) {
          if (translationX > leftThreshold) {
            toValue = leftWidth;
          } else if (translationX < -rightThreshold) {
            toValue = -rightWidth;
          }
        } else if (rowState === 1) {
          if (translationX > -leftThreshold) {
            toValue = leftWidth;
          }
        } else {
          if (translationX < rightThreshold) {
            toValue = -rightWidth;
          }
        }

        _this._animateRow(startOffsetX, toValue, velocityX / friction);
      };

      _this._animateRow = function (fromValue, toValue, velocityX) {
        var _this$state2 = _this.state,
            dragX = _this$state2.dragX,
            rowTranslation = _this$state2.rowTranslation;
        dragX.setValue(0);
        rowTranslation.setValue(fromValue);

        _this.setState({
          rowState: Math.sign(toValue)
        });

        _reactNative.Animated.spring(rowTranslation, _objectSpread({
          restSpeedThreshold: 1.7,
          restDisplacementThreshold: 0.4,
          velocity: velocityX,
          bounciness: 0,
          toValue: toValue,
          useNativeDriver: _this.props.useNativeAnimations
        }, _this.props.animationOptions)).start(function (_ref3) {
          var finished = _ref3.finished;

          if (finished) {
            if (toValue > 0 && _this.props.onSwipeableLeftOpen) {
              _this.props.onSwipeableLeftOpen();
            } else if (toValue < 0 && _this.props.onSwipeableRightOpen) {
              _this.props.onSwipeableRightOpen();
            }

            if (toValue === 0) {
              _this.props.onSwipeableClose && _this.props.onSwipeableClose();
            } else {
              _this.props.onSwipeableOpen && _this.props.onSwipeableOpen();
            }
          }
        });

        if (toValue > 0 && _this.props.onSwipeableLeftWillOpen) {
          _this.props.onSwipeableLeftWillOpen();
        } else if (toValue < 0 && _this.props.onSwipeableRightWillOpen) {
          _this.props.onSwipeableRightWillOpen();
        }

        if (toValue === 0) {
          _this.props.onSwipeableWillClose && _this.props.onSwipeableWillClose();
        } else {
          _this.props.onSwipeableWillOpen && _this.props.onSwipeableWillOpen();
        }
      };

      _this._onRowLayout = function (_ref4) {
        var nativeEvent = _ref4.nativeEvent;

        _this.setState({
          rowWidth: nativeEvent.layout.width
        });
      };

      _this._currentOffset = function () {
        var _this$state3 = _this.state,
            _this$state3$leftWidt = _this$state3.leftWidth,
            leftWidth = _this$state3$leftWidt === void 0 ? 0 : _this$state3$leftWidt,
            _this$state3$rowWidth = _this$state3.rowWidth,
            rowWidth = _this$state3$rowWidth === void 0 ? 0 : _this$state3$rowWidth,
            rowState = _this$state3.rowState;
        var _this$state$rightOffs2 = _this.state.rightOffset,
            rightOffset = _this$state$rightOffs2 === void 0 ? rowWidth : _this$state$rightOffs2;
        var rightWidth = rowWidth - rightOffset;

        if (rowState === 1) {
          return leftWidth;
        } else if (rowState === -1) {
          return -rightWidth;
        }

        return 0;
      };

      _this.close = function () {
        _this._animateRow(_this._currentOffset(), 0);
      };

      _this.openLeft = function () {
        var _this$state$leftWidth2 = _this.state.leftWidth,
            leftWidth = _this$state$leftWidth2 === void 0 ? 0 : _this$state$leftWidth2;

        _this._animateRow(_this._currentOffset(), leftWidth);
      };

      _this.openRight = function () {
        var _this$state$rowWidth2 = _this.state.rowWidth,
            rowWidth = _this$state$rowWidth2 === void 0 ? 0 : _this$state$rowWidth2;
        var _this$state$rightOffs3 = _this.state.rightOffset,
            rightOffset = _this$state$rightOffs3 === void 0 ? rowWidth : _this$state$rightOffs3;
        var rightWidth = rowWidth - rightOffset;

        _this._animateRow(_this._currentOffset(), -rightWidth);
      };

      var _dragX = new _reactNative.Animated.Value(0);

      _this.state = {
        dragX: _dragX,
        rowTranslation: new _reactNative.Animated.Value(0),
        rowState: 0,
        leftWidth: undefined,
        rightOffset: undefined,
        rowWidth: undefined
      };

      _this._updateAnimatedEvent(_props, _this.state);

      _this._onGestureEvent = _reactNative.Animated.event([{
        nativeEvent: {
          translationX: _dragX
        }
      }], {
        useNativeDriver: _props.useNativeAnimations
      });
      return _this;
    }

    (0, _createClass2.default)(Swipeable, [{
      key: "UNSAFE_componentWillUpdate",
      value: function UNSAFE_componentWillUpdate(props, state) {
        if (this.props.friction !== props.friction || this.props.overshootLeft !== props.overshootLeft || this.props.overshootRight !== props.overshootRight || this.props.overshootFriction !== props.overshootFriction || this.state.leftWidth !== state.leftWidth || this.state.rightOffset !== state.rightOffset || this.state.rowWidth !== state.rowWidth) {
          this._updateAnimatedEvent(props, state);
        }
      }
    }, {
      key: "render",
      value: function render() {
        var _this2 = this;

        var rowState = this.state.rowState;
        var _this$props2 = this.props,
            children = _this$props2.children,
            renderLeftActions = _this$props2.renderLeftActions,
            renderRightActions = _this$props2.renderRightActions;

        var left = renderLeftActions && _react.default.createElement(_reactNative.Animated.View, {
          style: [styles.leftActions, {
            transform: [{
              translateX: this._leftActionTranslate
            }]
          }],
          __source: {
            fileName: _jsxFileName,
            lineNumber: 283
          }
        }, renderLeftActions(this._showLeftAction, this._transX), _react.default.createElement(_reactNative.View, {
          onLayout: function onLayout(_ref5) {
            var nativeEvent = _ref5.nativeEvent;
            return _this2.setState({
              leftWidth: nativeEvent.layout.x
            });
          },
          __source: {
            fileName: _jsxFileName,
            lineNumber: 289
          }
        }));

        var right = renderRightActions && _react.default.createElement(_reactNative.Animated.View, {
          style: [styles.rightActions, {
            transform: [{
              translateX: this._rightActionTranslate
            }]
          }],
          __source: {
            fileName: _jsxFileName,
            lineNumber: 298
          }
        }, renderRightActions(this._showRightAction, this._transX), _react.default.createElement(_reactNative.View, {
          onLayout: function onLayout(_ref6) {
            var nativeEvent = _ref6.nativeEvent;
            return _this2.setState({
              rightOffset: nativeEvent.layout.x
            });
          },
          __source: {
            fileName: _jsxFileName,
            lineNumber: 304
          }
        }));

        return _react.default.createElement(_GestureHandler.PanGestureHandler, (0, _extends2.default)({
          activeOffsetX: [-10, 10]
        }, this.props, {
          onGestureEvent: this._onGestureEvent,
          onHandlerStateChange: this._onHandlerStateChange,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 313
          }
        }), _react.default.createElement(_reactNative.Animated.View, {
          onLayout: this._onRowLayout,
          style: [styles.container, this.props.containerStyle],
          __source: {
            fileName: _jsxFileName,
            lineNumber: 318
          }
        }, left, right, _react.default.createElement(_GestureHandler.TapGestureHandler, {
          enabled: rowState !== 0,
          onHandlerStateChange: this._onTapHandlerStateChange,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 323
          }
        }, _react.default.createElement(_reactNative.Animated.View, {
          pointerEvents: rowState === 0 ? 'auto' : 'box-only',
          style: [{
            transform: [{
              translateX: this._transX
            }]
          }, this.props.childrenContainerStyle],
          __source: {
            fileName: _jsxFileName,
            lineNumber: 326
          }
        }, children))));
      }
    }]);
    return Swipeable;
  }(_react.Component);

  exports.default = Swipeable;
  Swipeable.defaultProps = {
    friction: 1,
    overshootFriction: 1,
    useNativeAnimations: true
  };

  var styles = _reactNative.StyleSheet.create({
    container: {
      overflow: 'hidden'
    },
    leftActions: _objectSpread({}, _reactNative.StyleSheet.absoluteFillObject, {
      flexDirection: _reactNative.I18nManager.isRTL ? 'row-reverse' : 'row'
    }),
    rightActions: _objectSpread({}, _reactNative.StyleSheet.absoluteFillObject, {
      flexDirection: _reactNative.I18nManager.isRTL ? 'row' : 'row-reverse'
    })
  });
},504,[1,9,13,46,24,25,32,34,37,54,2,505],"node_modules/react-native-gesture-handler/Swipeable.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  var _exportNames = {
    createNativeWrapper: true,
    Directions: true,
    gestureHandlerRootHOC: true,
    NativeViewGestureHandler: true,
    State: true
  };
  Object.defineProperty(exports, "createNativeWrapper", {
    enumerable: true,
    get: function get() {
      return _createNativeWrapper.default;
    }
  });
  Object.defineProperty(exports, "Directions", {
    enumerable: true,
    get: function get() {
      return _Directions.default;
    }
  });
  Object.defineProperty(exports, "gestureHandlerRootHOC", {
    enumerable: true,
    get: function get() {
      return _gestureHandlerRootHOC.default;
    }
  });
  Object.defineProperty(exports, "NativeViewGestureHandler", {
    enumerable: true,
    get: function get() {
      return _NativeViewGestureHandler.default;
    }
  });
  Object.defineProperty(exports, "State", {
    enumerable: true,
    get: function get() {
      return _State.default;
    }
  });

  var _createNativeWrapper = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./createNativeWrapper"));

  var _Directions = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "./Directions"));

  var _gestureHandlerRootHOC = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "./gestureHandlerRootHOC"));

  var _NativeViewGestureHandler = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "./NativeViewGestureHandler"));

  var _State = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "./State"));

  var _GestureButtons = _$$_REQUIRE(_dependencyMap[6], "./GestureButtons");

  Object.keys(_GestureButtons).forEach(function (key) {
    if (key === "default" || key === "__esModule") return;
    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
    Object.defineProperty(exports, key, {
      enumerable: true,
      get: function get() {
        return _GestureButtons[key];
      }
    });
  });

  var _GestureComponents = _$$_REQUIRE(_dependencyMap[7], "./GestureComponents");

  Object.keys(_GestureComponents).forEach(function (key) {
    if (key === "default" || key === "__esModule") return;
    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
    Object.defineProperty(exports, key, {
      enumerable: true,
      get: function get() {
        return _GestureComponents[key];
      }
    });
  });

  var _Gestures = _$$_REQUIRE(_dependencyMap[8], "./Gestures");

  Object.keys(_Gestures).forEach(function (key) {
    if (key === "default" || key === "__esModule") return;
    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
    Object.defineProperty(exports, key, {
      enumerable: true,
      get: function get() {
        return _Gestures[key];
      }
    });
  });
},505,[1,506,513,514,507,511,516,518,519],"node_modules/react-native-gesture-handler/GestureHandler.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = createNativeWrapper;

  var _extends2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/extends"));

  var _defineProperty2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/defineProperty"));

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf3 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "@babel/runtime/helpers/inherits"));

  var _react = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "react"));

  var _NativeViewGestureHandler = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "./NativeViewGestureHandler"));

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native-gesture-handler/createNativeWrapper.js";

  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

  var NATIVE_WRAPPER_BIND_BLACKLIST = new Set(['replaceState', 'isMounted']);
  var NATIVE_WRAPPER_PROPS_FILTER = ['id', 'minPointers', 'enabled', 'waitFor', 'simultaneousHandlers', 'shouldCancelWhenOutside', 'hitSlop', 'onGestureEvent', 'onHandlerStateChange', 'onBegan', 'onFailed', 'onCancelled', 'onActivated', 'onEnded', 'shouldActivateOnStart', 'disallowInterruption', 'onGestureHandlerEvent', 'onGestureHandlerStateChange'];

  function createNativeWrapper(Component) {
    var config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

    var ComponentWrapper = function (_React$Component) {
      (0, _inherits2.default)(ComponentWrapper, _React$Component);

      function ComponentWrapper() {
        var _getPrototypeOf2;

        var _this;

        (0, _classCallCheck2.default)(this, ComponentWrapper);

        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
          args[_key] = arguments[_key];
        }

        _this = (0, _possibleConstructorReturn2.default)(this, (_getPrototypeOf2 = (0, _getPrototypeOf3.default)(ComponentWrapper)).call.apply(_getPrototypeOf2, [this].concat(args)));

        _this._refHandler = function (node) {
          var source = node;

          while (source != null) {
            for (var _iterator = Object.getOwnPropertyNames(source), _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[typeof Symbol === "function" ? typeof Symbol === "function" ? typeof Symbol === "function" ? Symbol.iterator : "@@iterator" : "@@iterator" : "@@iterator"]();;) {
              var _ref;

              if (_isArray) {
                if (_i >= _iterator.length) break;
                _ref = _iterator[_i++];
              } else {
                _i = _iterator.next();
                if (_i.done) break;
                _ref = _i.value;
              }

              var _methodName = _ref;

              if (!_methodName.startsWith('_') && !_methodName.startsWith('component') && !NATIVE_WRAPPER_BIND_BLACKLIST.has(_methodName) && typeof source[_methodName] === 'function' && _this[_methodName] === undefined) {
                if (source[_methodName].prototype) {
                  _this[_methodName] = source[_methodName].bind(node);
                } else {
                  _this[_methodName] = source[_methodName];
                }
              }
            }

            source = Object.getPrototypeOf(source);
          }
        };

        return _this;
      }

      (0, _createClass2.default)(ComponentWrapper, [{
        key: "render",
        value: function render() {
          var _this2 = this;

          var gestureHandlerProps = Object.keys(this.props).reduce(function (props, key) {
            if (NATIVE_WRAPPER_PROPS_FILTER.indexOf(key) !== -1) {
              props[key] = _this2.props[key];
            }

            return props;
          }, _objectSpread({}, config));
          return _react.default.createElement(_NativeViewGestureHandler.default, (0, _extends2.default)({}, gestureHandlerProps, {
            __source: {
              fileName: _jsxFileName,
              lineNumber: 79
            }
          }), _react.default.createElement(Component, (0, _extends2.default)({}, this.props, {
            ref: this._refHandler,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 80
            }
          })));
        }
      }]);
      return ComponentWrapper;
    }(_react.default.Component);

    ComponentWrapper.propTypes = _objectSpread({}, Component.propTypes);
    ComponentWrapper.displayName = Component.displayName || 'ComponentWrapper';
    return ComponentWrapper;
  }
},506,[1,13,46,24,25,32,34,37,54,507],"node_modules/react-native-gesture-handler/createNativeWrapper.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _defineProperty2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/defineProperty"));

  var _propTypes = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "prop-types"));

  var _createHandler = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "./createHandler"));

  var _GestureHandlerPropTypes = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "./GestureHandlerPropTypes"));

  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

  var NativeViewGestureHandler = (0, _createHandler.default)('NativeViewGestureHandler', _objectSpread({}, _GestureHandlerPropTypes.default, {
    shouldActivateOnStart: _propTypes.default.bool,
    disallowInterruption: _propTypes.default.bool
  }));
  var _default = NativeViewGestureHandler;
  exports.default = _default;
},507,[1,46,69,508,512],"node_modules/react-native-gesture-handler/NativeViewGestureHandler.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = createHandler;

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits"));

  var _defineProperty2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/defineProperty"));

  var _react = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "react"));

  var _reactNative = _$$_REQUIRE(_dependencyMap[8], "react-native");

  var _areEqual = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "fbjs/lib/areEqual"));

  var _RNGestureHandlerModule = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[10], "./RNGestureHandlerModule"));

  var _State = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[11], "./State"));

  var _stateToPropMappings;

  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

  function findNodeHandle(node) {
    if (_reactNative.Platform.OS === 'web') return node;
    return (0, _reactNative.findNodeHandle)(node);
  }

  var _NativeModules$UIMana = _reactNative.NativeModules.UIManager,
      UIManager = _NativeModules$UIMana === void 0 ? {} : _NativeModules$UIMana;
  var customGHEventsConfig = {
    onGestureHandlerEvent: {
      registrationName: 'onGestureHandlerEvent'
    },
    onGestureHandlerStateChange: {
      registrationName: 'onGestureHandlerStateChange'
    }
  };
  UIManager.genericDirectEventTypes = _objectSpread({}, UIManager.genericDirectEventTypes, {}, customGHEventsConfig);

  if (UIManager.getConstants) {
    UIManager.getConstants().genericDirectEventTypes = _objectSpread({}, UIManager.getConstants().genericDirectEventTypes, {}, customGHEventsConfig);
  }

  var _UIManager$setJSRespo = UIManager.setJSResponder,
      oldSetJSResponder = _UIManager$setJSRespo === void 0 ? function () {} : _UIManager$setJSRespo,
      _UIManager$clearJSRes = UIManager.clearJSResponder,
      oldClearJSResponder = _UIManager$clearJSRes === void 0 ? function () {} : _UIManager$clearJSRes;

  UIManager.setJSResponder = function (tag, blockNativeResponder) {
    _RNGestureHandlerModule.default.handleSetJSResponder(tag, blockNativeResponder);

    oldSetJSResponder(tag, blockNativeResponder);
  };

  UIManager.clearJSResponder = function () {
    _RNGestureHandlerModule.default.handleClearJSResponder();

    oldClearJSResponder();
  };

  var handlerTag = 1;
  var handlerIDToTag = {};

  function isConfigParam(param, name) {
    return param !== undefined && (param !== Object(param) || !('__isNative' in param)) && name !== 'onHandlerStateChange' && name !== 'onGestureEvent';
  }

  function filterConfig(props, validProps) {
    var defaults = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};

    var res = _objectSpread({}, defaults);

    Object.keys(validProps).forEach(function (key) {
      var value = props[key];

      if (isConfigParam(value, key)) {
        var _value = props[key];

        if (key === 'simultaneousHandlers' || key === 'waitFor') {
          _value = transformIntoHandlerTags(props[key]);
        } else if (key === 'hitSlop') {
          if (typeof _value !== 'object') {
            _value = {
              top: _value,
              left: _value,
              bottom: _value,
              right: _value
            };
          }
        }

        res[key] = _value;
      }
    });
    return res;
  }

  function transformIntoHandlerTags(handlerIDs) {
    if (!Array.isArray(handlerIDs)) {
      handlerIDs = [handlerIDs];
    }

    if (_reactNative.Platform.OS === 'web') {
      return handlerIDs.map(function (_ref) {
        var current = _ref.current;
        return current;
      }).filter(function (handle) {
        return handle;
      });
    }

    return handlerIDs.map(function (handlerID) {
      return handlerIDToTag[handlerID] || handlerID.current && handlerID.current._handlerTag || -1;
    }).filter(function (handlerTag) {
      return handlerTag > 0;
    });
  }

  function hasUnresolvedRefs(props) {
    var extract = function extract(refs) {
      if (!Array.isArray(refs)) {
        return refs && refs.current === null;
      }

      return refs.some(function (r) {
        return r && r.current === null;
      });
    };

    return extract(props['simultaneousHandlers']) || extract(props['waitFor']);
  }

  var stateToPropMappings = (_stateToPropMappings = {}, (0, _defineProperty2.default)(_stateToPropMappings, _State.default.BEGAN, 'onBegan'), (0, _defineProperty2.default)(_stateToPropMappings, _State.default.FAILED, 'onFailed'), (0, _defineProperty2.default)(_stateToPropMappings, _State.default.CANCELLED, 'onCancelled'), (0, _defineProperty2.default)(_stateToPropMappings, _State.default.ACTIVE, 'onActivated'), (0, _defineProperty2.default)(_stateToPropMappings, _State.default.END, 'onEnded'), _stateToPropMappings);

  function createHandler(handlerName) {
    var propTypes = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
    var config = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
    var transformProps = arguments.length > 3 ? arguments[3] : undefined;
    var customNativeProps = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};

    var Handler = function (_React$Component) {
      (0, _inherits2.default)(Handler, _React$Component);

      function Handler(props) {
        var _this;

        (0, _classCallCheck2.default)(this, Handler);
        _this = (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(Handler).call(this, props));

        _this._onGestureHandlerEvent = function (event) {
          if (event.nativeEvent.handlerTag === _this._handlerTag) {
            _this.props.onGestureEvent && _this.props.onGestureEvent(event);
          } else {
            _this.props.onGestureHandlerEvent && _this.props.onGestureHandlerEvent(event);
          }
        };

        _this._onGestureHandlerStateChange = function (event) {
          if (event.nativeEvent.handlerTag === _this._handlerTag) {
            _this.props.onHandlerStateChange && _this.props.onHandlerStateChange(event);
            var stateEventName = stateToPropMappings[event.nativeEvent.state];

            if (typeof _this.props[stateEventName] === 'function') {
              _this.props[stateEventName](event);
            }
          } else {
            _this.props.onGestureHandlerStateChange && _this.props.onGestureHandlerStateChange(event);
          }
        };

        _this._refHandler = function (node) {
          _this._viewNode = node;

          var child = _react.default.Children.only(_this.props.children);

          var ref = child.ref;

          if (ref !== null) {
            if (typeof ref === 'function') {
              ref(node);
            } else {
              ref.current = node;
            }
          }
        };

        _this._createGestureHandler = function (newConfig) {
          _this._config = newConfig;

          _RNGestureHandlerModule.default.createGestureHandler(handlerName, _this._handlerTag, newConfig);
        };

        _this._attachGestureHandler = function (newViewTag) {
          _this._viewTag = newViewTag;

          _RNGestureHandlerModule.default.attachGestureHandler(_this._handlerTag, newViewTag);
        };

        _this._updateGestureHandler = function (newConfig) {
          _this._config = newConfig;

          _RNGestureHandlerModule.default.updateGestureHandler(_this._handlerTag, newConfig);
        };

        _this._handlerTag = handlerTag++;
        _this._config = {};

        if (props.id) {
          if (handlerIDToTag[props.id] !== undefined) {
            throw new Error("Handler with ID \"" + props.id + "\" already registered");
          }

          handlerIDToTag[props.id] = _this._handlerTag;
        }

        return _this;
      }

      (0, _createClass2.default)(Handler, [{
        key: "componentWillUnmount",
        value: function componentWillUnmount() {
          _RNGestureHandlerModule.default.dropGestureHandler(this._handlerTag);

          if (this._updateEnqueued) {
            clearImmediate(this._updateEnqueued);
          }

          if (this.props.id) {
            delete handlerIDToTag[this.props.id];
          }
        }
      }, {
        key: "componentDidMount",
        value: function componentDidMount() {
          var _this2 = this;

          if (hasUnresolvedRefs(this.props)) {
            this._updateEnqueued = setImmediate(function () {
              _this2._updateEnqueued = null;

              _this2._update();
            });
          }

          this._createGestureHandler(filterConfig(transformProps ? transformProps(this.props) : this.props, _objectSpread({}, this.constructor.propTypes, {}, customNativeProps), config));

          this._attachGestureHandler(findNodeHandle(this._viewNode));
        }
      }, {
        key: "componentDidUpdate",
        value: function componentDidUpdate() {
          var viewTag = findNodeHandle(this._viewNode);

          if (this._viewTag !== viewTag) {
            this._attachGestureHandler(viewTag);
          }

          this._update();
        }
      }, {
        key: "_update",
        value: function _update() {
          var newConfig = filterConfig(transformProps ? transformProps(this.props) : this.props, _objectSpread({}, this.constructor.propTypes, {}, customNativeProps), config);

          if (!(0, _areEqual.default)(this._config, newConfig)) {
            this._updateGestureHandler(newConfig);
          }
        }
      }, {
        key: "setNativeProps",
        value: function setNativeProps(updates) {
          var mergedProps = _objectSpread({}, this.props, {}, updates);

          var newConfig = filterConfig(transformProps ? transformProps(mergedProps) : mergedProps, _objectSpread({}, this.constructor.propTypes, {}, customNativeProps), config);

          this._updateGestureHandler(newConfig);
        }
      }, {
        key: "render",
        value: function render() {
          var gestureEventHandler = this._onGestureHandlerEvent;
          var _this$props = this.props,
              onGestureEvent = _this$props.onGestureEvent,
              onGestureHandlerEvent = _this$props.onGestureHandlerEvent;

          if (onGestureEvent && typeof onGestureEvent !== 'function') {
            if (onGestureHandlerEvent) {
              throw new Error('Nesting touch handlers with native animated driver is not supported yet');
            }

            gestureEventHandler = this.props.onGestureEvent;
          } else {
            if (onGestureHandlerEvent && typeof onGestureHandlerEvent !== 'function') {
              throw new Error('Nesting touch handlers with native animated driver is not supported yet');
            }
          }

          var gestureStateEventHandler = this._onGestureHandlerStateChange;
          var _this$props2 = this.props,
              onHandlerStateChange = _this$props2.onHandlerStateChange,
              onGestureHandlerStateChange = _this$props2.onGestureHandlerStateChange;

          if (onHandlerStateChange && typeof onHandlerStateChange !== 'function') {
            if (onGestureHandlerStateChange) {
              throw new Error('Nesting touch handlers with native animated driver is not supported yet');
            }

            gestureStateEventHandler = this.props.onHandlerStateChange;
          } else {
            if (onGestureHandlerStateChange && typeof onGestureHandlerStateChange !== 'function') {
              throw new Error('Nesting touch handlers with native animated driver is not supported yet');
            }
          }

          var child = _react.default.Children.only(this.props.children);

          var grandChildren = child.props.children;

          if (_reactNative.Touchable.TOUCH_TARGET_DEBUG && child.type && (child.type === 'RNGestureHandlerButton' || child.type.name === 'View' || child.type.displayName === 'View')) {
            grandChildren = _react.default.Children.toArray(grandChildren);
            grandChildren.push(_reactNative.Touchable.renderDebugView({
              color: 'mediumspringgreen',
              hitSlop: child.props.hitSlop
            }));
          }

          return _react.default.cloneElement(child, {
            ref: this._refHandler,
            collapsable: false,
            onGestureHandlerEvent: gestureEventHandler,
            onGestureHandlerStateChange: gestureStateEventHandler
          }, grandChildren);
        }
      }]);
      return Handler;
    }(_react.default.Component);

    Handler.displayName = handlerName;
    Handler.propTypes = propTypes;
    return Handler;
  }
},508,[1,24,25,32,34,37,46,54,2,509,510,511],"node_modules/react-native-gesture-handler/createHandler.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  "use strict";

  var aStackPool = [];
  var bStackPool = [];
  /**
   * Checks if two values are equal. Values may be primitives, arrays, or objects.
   * Returns true if both arguments have the same keys and values.
   *
   * @see http://underscorejs.org
   * @copyright 2009-2013 Jeremy Ashkenas, DocumentCloud Inc.
   * @license MIT
   */

  function areEqual(a, b) {
    var aStack = aStackPool.length ? aStackPool.pop() : [];
    var bStack = bStackPool.length ? bStackPool.pop() : [];
    var result = eq(a, b, aStack, bStack);
    aStack.length = 0;
    bStack.length = 0;
    aStackPool.push(aStack);
    bStackPool.push(bStack);
    return result;
  }

  function eq(a, b, aStack, bStack) {
    if (a === b) {
      return a !== 0 || 1 / a == 1 / b;
    }

    if (a == null || b == null) {
      return false;
    }

    if (typeof a != 'object' || typeof b != 'object') {
      return false;
    }

    var objToStr = Object.prototype.toString;
    var className = objToStr.call(a);

    if (className != objToStr.call(b)) {
      return false;
    }

    switch (className) {
      case '[object String]':
        return a == String(b);

      case '[object Number]':
        return isNaN(a) || isNaN(b) ? false : a == Number(b);

      case '[object Date]':
      case '[object Boolean]':
        return +a == +b;

      case '[object RegExp]':
        return a.source == b.source && a.global == b.global && a.multiline == b.multiline && a.ignoreCase == b.ignoreCase;
    }

    var length = aStack.length;

    while (length--) {
      if (aStack[length] == a) {
        return bStack[length] == b;
      }
    }

    aStack.push(a);
    bStack.push(b);
    var size = 0;

    if (className === '[object Array]') {
      size = a.length;

      if (size !== b.length) {
        return false;
      }

      while (size--) {
        if (!eq(a[size], b[size], aStack, bStack)) {
          return false;
        }
      }
    } else {
      if (a.constructor !== b.constructor) {
        return false;
      }

      if (a.hasOwnProperty('valueOf') && b.hasOwnProperty('valueOf')) {
        return a.valueOf() == b.valueOf();
      }

      var keys = Object.keys(a);

      if (keys.length != Object.keys(b).length) {
        return false;
      }

      for (var i = 0; i < keys.length; i++) {
        if (!eq(a[keys[i]], b[keys[i]], aStack, bStack)) {
          return false;
        }
      }
    }

    aStack.pop();
    bStack.pop();
    return true;
  }

  module.exports = areEqual;
},509,[],"node_modules/fbjs/lib/areEqual.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _reactNative = _$$_REQUIRE(_dependencyMap[0], "react-native");

  var RNGestureHandlerModule = _reactNative.NativeModules.RNGestureHandlerModule;
  var _default = RNGestureHandlerModule;
  exports.default = _default;
},510,[2],"node_modules/react-native-gesture-handler/RNGestureHandlerModule.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;
  var State = {
    UNDETERMINED: 0,
    FAILED: 1,
    BEGAN: 2,
    CANCELLED: 3,
    ACTIVE: 4,
    END: 5
  };

  State.print = function (state) {
    var keys = Object.keys(State);

    for (var i = 0; i < keys.length; i++) {
      if (state === State[keys[i]]) {
        return keys[i];
      }
    }
  };

  var _default = State;
  exports.default = _default;
},511,[],"node_modules/react-native-gesture-handler/State.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _propTypes = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "prop-types"));

  var GestureHandlerPropTypes = {
    id: _propTypes.default.string,
    minPointers: _propTypes.default.number,
    enabled: _propTypes.default.bool,
    waitFor: _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.object, _propTypes.default.arrayOf(_propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.object]))]),
    simultaneousHandlers: _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.object, _propTypes.default.arrayOf(_propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.object]))]),
    shouldCancelWhenOutside: _propTypes.default.bool,
    hitSlop: _propTypes.default.oneOfType([_propTypes.default.number, _propTypes.default.shape({
      left: _propTypes.default.number,
      top: _propTypes.default.number,
      right: _propTypes.default.number,
      bottom: _propTypes.default.number,
      vertical: _propTypes.default.number,
      horizontal: _propTypes.default.number,
      width: _propTypes.default.number,
      height: _propTypes.default.number
    })]),
    onGestureEvent: _propTypes.default.oneOfType([_propTypes.default.func, _propTypes.default.object]),
    onHandlerStateChange: _propTypes.default.oneOfType([_propTypes.default.func, _propTypes.default.object]),
    onBegan: _propTypes.default.func,
    onFailed: _propTypes.default.func,
    onCancelled: _propTypes.default.func,
    onActivated: _propTypes.default.func,
    onEnded: _propTypes.default.func
  };
  var _default = GestureHandlerPropTypes;
  exports.default = _default;
},512,[1,69],"node_modules/react-native-gesture-handler/GestureHandlerPropTypes.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _RNGestureHandlerModule = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./RNGestureHandlerModule"));

  var _default = _RNGestureHandlerModule.default.Direction;
  exports.default = _default;
},513,[1,510],"node_modules/react-native-gesture-handler/Directions.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = gestureHandlerRootHOC;

  var _extends2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/extends"));

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits"));

  var _defineProperty2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "@babel/runtime/helpers/defineProperty"));

  var _react = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "react"));

  var _reactNative = _$$_REQUIRE(_dependencyMap[9], "react-native");

  var _hoistNonReactStatics = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[10], "hoist-non-react-statics"));

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native-gesture-handler/gestureHandlerRootHOC.android.js";

  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

  var iface = {
    name: 'GestureHandlerRootView',
    propTypes: _objectSpread({}, _reactNative.ViewPropTypes)
  };
  var GestureHandlerRootView = (0, _reactNative.requireNativeComponent)('GestureHandlerRootView', iface);

  function gestureHandlerRootHOC(Component) {
    var containerStyles = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : undefined;

    var Wrapper = function (_React$Component) {
      (0, _inherits2.default)(Wrapper, _React$Component);

      function Wrapper() {
        (0, _classCallCheck2.default)(this, Wrapper);
        return (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(Wrapper).apply(this, arguments));
      }

      (0, _createClass2.default)(Wrapper, [{
        key: "render",
        value: function render() {
          return _react.default.createElement(GestureHandlerRootView, {
            style: [styles.container, containerStyles],
            __source: {
              fileName: _jsxFileName,
              lineNumber: 28
            }
          }, _react.default.createElement(Component, (0, _extends2.default)({}, this.props, {
            __source: {
              fileName: _jsxFileName,
              lineNumber: 29
            }
          })));
        }
      }]);
      return Wrapper;
    }(_react.default.Component);

    (0, _hoistNonReactStatics.default)(Wrapper, Component);
    return Wrapper;
  }

  var styles = _reactNative.StyleSheet.create({
    container: {
      flex: 1
    }
  });
},514,[1,13,24,25,32,34,37,46,54,2,515],"node_modules/react-native-gesture-handler/gestureHandlerRootHOC.android.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var REACT_STATICS = {
    childContextTypes: true,
    contextTypes: true,
    defaultProps: true,
    displayName: true,
    getDefaultProps: true,
    getDerivedStateFromProps: true,
    mixins: true,
    propTypes: true,
    type: true
  };
  var KNOWN_STATICS = {
    name: true,
    length: true,
    prototype: true,
    caller: true,
    callee: true,
    arguments: true,
    arity: true
  };
  var defineProperty = Object.defineProperty;
  var getOwnPropertyNames = Object.getOwnPropertyNames;
  var getOwnPropertySymbols = Object.getOwnPropertySymbols;
  var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
  var getPrototypeOf = Object.getPrototypeOf;
  var objectPrototype = getPrototypeOf && getPrototypeOf(Object);

  function hoistNonReactStatics(targetComponent, sourceComponent, blacklist) {
    if (typeof sourceComponent !== 'string') {
      if (objectPrototype) {
        var inheritedComponent = getPrototypeOf(sourceComponent);

        if (inheritedComponent && inheritedComponent !== objectPrototype) {
          hoistNonReactStatics(targetComponent, inheritedComponent, blacklist);
        }
      }

      var keys = getOwnPropertyNames(sourceComponent);

      if (getOwnPropertySymbols) {
        keys = keys.concat(getOwnPropertySymbols(sourceComponent));
      }

      for (var i = 0; i < keys.length; ++i) {
        var key = keys[i];

        if (!REACT_STATICS[key] && !KNOWN_STATICS[key] && (!blacklist || !blacklist[key])) {
          var descriptor = getOwnPropertyDescriptor(sourceComponent, key);

          try {
            defineProperty(targetComponent, key, descriptor);
          } catch (e) {}
        }
      }

      return targetComponent;
    }

    return targetComponent;
  }

  module.exports = hoistNonReactStatics;
},515,[],"node_modules/react-native-gesture-handler/node_modules/hoist-non-react-statics/dist/hoist-non-react-statics.cjs.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  Object.defineProperty(exports, "PureNativeButton", {
    enumerable: true,
    get: function get() {
      return _GestureHandlerButton.default;
    }
  });
  exports.BorderlessButton = exports.RectButton = exports.BaseButton = exports.RawButton = void 0;

  var _defineProperty2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/defineProperty"));

  var _extends2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/extends"));

  var _objectWithoutProperties2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/objectWithoutProperties"));

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "@babel/runtime/helpers/inherits"));

  var _propTypes = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "prop-types"));

  var _react = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[10], "react"));

  var _reactNative = _$$_REQUIRE(_dependencyMap[11], "react-native");

  var _createNativeWrapper = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[12], "./createNativeWrapper"));

  var _GestureHandlerButton = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[13], "./GestureHandlerButton"));

  var _State = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[14], "./State"));

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native-gesture-handler/GestureButtons.js";

  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

  var RawButton = (0, _createNativeWrapper.default)(_GestureHandlerButton.default, {
    shouldCancelWhenOutside: false,
    shouldActivateOnStart: false
  });
  exports.RawButton = RawButton;

  var BaseButton = function (_React$Component) {
    (0, _inherits2.default)(BaseButton, _React$Component);

    function BaseButton(props) {
      var _this;

      (0, _classCallCheck2.default)(this, BaseButton);
      _this = (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(BaseButton).call(this, props));

      _this._handleEvent = function (_ref) {
        var nativeEvent = _ref.nativeEvent;
        var state = nativeEvent.state,
            oldState = nativeEvent.oldState,
            pointerInside = nativeEvent.pointerInside;
        var active = pointerInside && state === _State.default.ACTIVE;

        if (active !== _this._lastActive && _this.props.onActiveStateChange) {
          _this.props.onActiveStateChange(active);
        }

        if (oldState === _State.default.ACTIVE && state !== _State.default.CANCELLED && _this._lastActive && _this.props.onPress) {
          _this.props.onPress(active);
        }

        _this._lastActive = active;
      };

      _this._onHandlerStateChange = function (e) {
        _this.props.onHandlerStateChange && _this.props.onHandlerStateChange(e);

        _this._handleEvent(e);
      };

      _this._onGestureEvent = function (e) {
        _this.props.onGestureEvent && _this.props.onGestureEvent(e);

        _this._handleEvent(e);
      };

      _this._lastActive = false;
      return _this;
    }

    (0, _createClass2.default)(BaseButton, [{
      key: "render",
      value: function render() {
        var _this$props = this.props,
            style = _this$props.style,
            rippleColor = _this$props.rippleColor,
            rest = (0, _objectWithoutProperties2.default)(_this$props, ["style", "rippleColor"]);
        return _react.default.createElement(RawButton, (0, _extends2.default)({
          style: [{
            overflow: 'hidden'
          }, style],
          rippleColor: (0, _reactNative.processColor)(rippleColor)
        }, rest, {
          onGestureEvent: this._onGestureEvent,
          onHandlerStateChange: this._onHandlerStateChange,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 66
          }
        }));
      }
    }]);
    return BaseButton;
  }(_react.default.Component);

  exports.BaseButton = BaseButton;
  BaseButton.propTypes = _objectSpread({}, RawButton.propTypes, {
    onPress: _propTypes.default.func,
    onActiveStateChange: _propTypes.default.func
  });

  var AnimatedBaseButton = _reactNative.Animated.createAnimatedComponent(BaseButton);

  var btnStyles = _reactNative.StyleSheet.create({
    underlay: {
      position: 'absolute',
      left: 0,
      right: 0,
      bottom: 0,
      top: 0
    }
  });

  var RectButton = function (_React$Component2) {
    (0, _inherits2.default)(RectButton, _React$Component2);

    function RectButton(props) {
      var _this2;

      (0, _classCallCheck2.default)(this, RectButton);
      _this2 = (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(RectButton).call(this, props));

      _this2._onActiveStateChange = function (active) {
        if (_reactNative.Platform.OS !== 'android') {
          _this2._opacity.setValue(active ? _this2.props.activeOpacity : 0);
        }

        _this2.props.onActiveStateChange && _this2.props.onActiveStateChange(active);
      };

      _this2._opacity = new _reactNative.Animated.Value(0);
      return _this2;
    }

    (0, _createClass2.default)(RectButton, [{
      key: "render",
      value: function render() {
        var _this$props2 = this.props,
            children = _this$props2.children,
            rest = (0, _objectWithoutProperties2.default)(_this$props2, ["children"]);
        return _react.default.createElement(BaseButton, (0, _extends2.default)({}, rest, {
          onActiveStateChange: this._onActiveStateChange,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 114
          }
        }), _react.default.createElement(_reactNative.Animated.View, {
          style: [btnStyles.underlay, {
            opacity: this._opacity
          }, {
            backgroundColor: this.props.underlayColor
          }],
          __source: {
            fileName: _jsxFileName,
            lineNumber: 115
          }
        }), children);
      }
    }]);
    return RectButton;
  }(_react.default.Component);

  exports.RectButton = RectButton;
  RectButton.propTypes = BaseButton.propTypes;
  RectButton.defaultProps = {
    activeOpacity: 0.105,
    underlayColor: 'black'
  };

  var BorderlessButton = function (_React$Component3) {
    (0, _inherits2.default)(BorderlessButton, _React$Component3);

    function BorderlessButton(props) {
      var _this3;

      (0, _classCallCheck2.default)(this, BorderlessButton);
      _this3 = (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(BorderlessButton).call(this, props));

      _this3._onActiveStateChange = function (active) {
        if (_reactNative.Platform.OS !== 'android') {
          _this3._opacity.setValue(active ? _this3.props.activeOpacity : 1);
        }

        _this3.props.onActiveStateChange && _this3.props.onActiveStateChange(active);
      };

      _this3._opacity = new _reactNative.Animated.Value(1);
      return _this3;
    }

    (0, _createClass2.default)(BorderlessButton, [{
      key: "render",
      value: function render() {
        var _this$props3 = this.props,
            children = _this$props3.children,
            style = _this$props3.style,
            rest = (0, _objectWithoutProperties2.default)(_this$props3, ["children", "style"]);
        return _react.default.createElement(AnimatedBaseButton, (0, _extends2.default)({}, rest, {
          onActiveStateChange: this._onActiveStateChange,
          style: [style, _reactNative.Platform.OS === 'ios' && {
            opacity: this._opacity
          }],
          __source: {
            fileName: _jsxFileName,
            lineNumber: 156
          }
        }), children);
      }
    }]);
    return BorderlessButton;
  }(_react.default.Component);

  exports.BorderlessButton = BorderlessButton;
  BorderlessButton.propTypes = _objectSpread({}, BaseButton.propTypes, {
    borderless: _propTypes.default.bool
  });
  BorderlessButton.defaultProps = {
    activeOpacity: 0.3,
    borderless: true
  };
},516,[1,46,13,52,24,25,32,34,37,69,54,2,506,517,511],"node_modules/react-native-gesture-handler/GestureButtons.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _reactNative = _$$_REQUIRE(_dependencyMap[0], "react-native");

  var RNGestureHandlerButton = (0, _reactNative.requireNativeComponent)('RNGestureHandlerButton', null);
  var _default = RNGestureHandlerButton;
  exports.default = _default;
},517,[2],"node_modules/react-native-gesture-handler/GestureHandlerButton.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _extends2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/extends"));

  var _react = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "react"));

  var _reactNative = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "react-native"));

  var _createNativeWrapper = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "./createNativeWrapper"));

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native-gesture-handler/GestureComponents.js";
  var MEMOIZED = new WeakMap();

  function memoizeWrap(Component, config) {
    if (Component == null) {
      return null;
    }

    var memoized = MEMOIZED.get(Component);

    if (!memoized) {
      memoized = (0, _createNativeWrapper.default)(Component, config);
      MEMOIZED.set(Component, memoized);
    }

    return memoized;
  }

  module.exports = {
    get ScrollView() {
      return memoizeWrap(_reactNative.default.ScrollView, {
        disallowInterruption: true,
        shouldCancelWhenOutside: false
      });
    },

    get Switch() {
      return memoizeWrap(_reactNative.default.Switch, {
        shouldCancelWhenOutside: false,
        shouldActivateOnStart: true,
        disallowInterruption: true
      });
    },

    get TextInput() {
      return memoizeWrap(_reactNative.default.TextInput);
    },

    get ToolbarAndroid() {
      return memoizeWrap(_reactNative.default.ToolbarAndroid);
    },

    get DrawerLayoutAndroid() {
      var DrawerLayoutAndroid = memoizeWrap(_reactNative.default.DrawerLayoutAndroid, {
        disallowInterruption: true
      });
      DrawerLayoutAndroid.positions = _reactNative.default.DrawerLayoutAndroid.positions;
      return DrawerLayoutAndroid;
    },

    get FlatList() {
      if (!MEMOIZED.FlatList) {
        var ScrollView = this.ScrollView;
        MEMOIZED.FlatList = _react.default.forwardRef(function (props, ref) {
          return _react.default.createElement(_reactNative.default.FlatList, (0, _extends2.default)({
            ref: ref
          }, props, {
            renderScrollComponent: function renderScrollComponent(scrollProps) {
              return _react.default.createElement(ScrollView, (0, _extends2.default)({}, scrollProps, {
                __source: {
                  fileName: _jsxFileName,
                  lineNumber: 58
                }
              }));
            },
            __source: {
              fileName: _jsxFileName,
              lineNumber: 55
            }
          }));
        });
      }

      return MEMOIZED.FlatList;
    }

  };
},518,[1,13,54,2,506],"node_modules/react-native-gesture-handler/GestureComponents.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.RotationGestureHandler = exports.PinchGestureHandler = exports.PanGestureHandler = exports.LongPressGestureHandler = exports.ForceTouchGestureHandler = exports.FlingGestureHandler = exports.TapGestureHandler = void 0;

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits"));

  var _defineProperty2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/defineProperty"));

  var _propTypes = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "prop-types"));

  var _react = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "react"));

  var _createHandler = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "./createHandler"));

  var _GestureHandlerPropTypes = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[10], "./GestureHandlerPropTypes"));

  var _PlatformConstants = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[11], "./PlatformConstants"));

  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

  var TapGestureHandler = (0, _createHandler.default)('TapGestureHandler', _objectSpread({}, _GestureHandlerPropTypes.default, {
    maxDurationMs: _propTypes.default.number,
    maxDelayMs: _propTypes.default.number,
    numberOfTaps: _propTypes.default.number,
    maxDeltaX: _propTypes.default.number,
    maxDeltaY: _propTypes.default.number,
    maxDist: _propTypes.default.number,
    minPointers: _propTypes.default.number
  }), {});
  exports.TapGestureHandler = TapGestureHandler;
  var FlingGestureHandler = (0, _createHandler.default)('FlingGestureHandler', _objectSpread({}, _GestureHandlerPropTypes.default, {
    numberOfPointers: _propTypes.default.number,
    direction: _propTypes.default.number
  }), {});
  exports.FlingGestureHandler = FlingGestureHandler;

  var ForceTouchFallback = function (_React$Component) {
    (0, _inherits2.default)(ForceTouchFallback, _React$Component);

    function ForceTouchFallback() {
      (0, _classCallCheck2.default)(this, ForceTouchFallback);
      return (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(ForceTouchFallback).apply(this, arguments));
    }

    (0, _createClass2.default)(ForceTouchFallback, [{
      key: "componentDidMount",
      value: function componentDidMount() {
        console.warn('ForceTouchGestureHandler is not available on this platform. Please use ForceTouchGestureHandler.forceTouchAvailable to conditionally render other components that would provide a fallback behavior specific to your usecase');
      }
    }, {
      key: "render",
      value: function render() {
        return this.props.children;
      }
    }]);
    return ForceTouchFallback;
  }(_react.default.Component);

  var ForceTouchGestureHandler = _PlatformConstants.default && _PlatformConstants.default.forceTouchAvailable ? (0, _createHandler.default)('ForceTouchGestureHandler', _objectSpread({}, _GestureHandlerPropTypes.default, {
    minForce: _propTypes.default.number,
    maxForce: _propTypes.default.number,
    feedbackOnActivation: _propTypes.default.bool
  }), {}) : ForceTouchFallback;
  exports.ForceTouchGestureHandler = ForceTouchGestureHandler;
  ForceTouchGestureHandler.forceTouchAvailable = _PlatformConstants.default && _PlatformConstants.default.forceTouchAvailable || false;
  var LongPressGestureHandler = (0, _createHandler.default)('LongPressGestureHandler', _objectSpread({}, _GestureHandlerPropTypes.default, {
    minDurationMs: _propTypes.default.number,
    maxDist: _propTypes.default.number
  }), {});
  exports.LongPressGestureHandler = LongPressGestureHandler;

  function validatePanGestureHandlerProps(props) {
    if (props.minDeltaX && props.activeOffsetX) {
      throw new Error("It's not supported use minDeltaX with activeOffsetXStart or activeOffsetXEnd");
    }

    if (props.maxDeltaX && props.failOffsetX) {
      throw new Error("It's not supported use minDeltaX with activeOffsetXStart or activeOffsetXEnd");
    }

    if (props.minDeltaY && props.activeOffsetY) {
      throw new Error("It's not supported use minDeltaX with activeOffsetYStart or activeOffsetYEnd");
    }

    if (props.maxDeltaY && props.failOffsetY) {
      throw new Error("It's not supported use minDeltaX with activeOffsetYStart or activeOffsetYEnd");
    }

    if (Array.isArray(props.activeOffsetX) && (props.activeOffsetX[0] > 0 || props.activeOffsetX[1] < 0)) {
      throw new Error("First element of activeOffsetX should be negative, a the second one should be positive");
    }

    if (Array.isArray(props.activeOffsetY) && (props.activeOffsetY[0] > 0 || props.activeOffsetY[1] < 0)) {
      throw new Error("First element of activeOffsetY should be negative, a the second one should be positive");
    }

    if (Array.isArray(props.failOffsetX) && (props.failOffsetX[0] > 0 || props.failOffsetX[1] < 0)) {
      throw new Error("First element of failOffsetX should be negative, a the second one should be positive");
    }

    if (Array.isArray(props.failOffsetY) && (props.failOffsetY[0] > 0 || props.failOffsetY[1] < 0)) {
      throw new Error("First element of failOffsetY should be negative, a the second one should be positive");
    }
  }

  function transformPanGestureHandlerProps(props) {
    var res = _objectSpread({}, props);

    if (props.minDeltaX !== undefined) {
      delete res['minDeltaX'];
      res.activeOffsetXStart = -props.minDeltaX;
      res.activeOffsetXEnd = props.minDeltaX;
    }

    if (props.maxDeltaX !== undefined) {
      delete res['maxDeltaX'];
      res.failOffsetXStart = -props.maxDeltaX;
      res.failOffsetXEnd = props.maxDeltaX;
    }

    if (props.minOffsetX !== undefined) {
      delete res['minOffsetX'];

      if (props.minOffsetX < 0) {
        res.activeOffsetXStart = props.minOffsetX;
      } else {
        res.activeOffsetXEnd = props.minOffsetX;
      }
    }

    if (props.minDeltaY !== undefined) {
      delete res['minDeltaY'];
      res.activeOffsetYStart = -props.minDeltaY;
      res.activeOffsetYEnd = props.minDeltaY;
    }

    if (props.maxDeltaY !== undefined) {
      delete res['maxDeltaY'];
      res.failOffsetYStart = -props.maxDeltaY;
      res.failOffsetYEnd = props.maxDeltaY;
    }

    if (props.minOffsetY !== undefined) {
      delete res['minOffsetY'];

      if (props.minOffsetY < 0) {
        res.activeOffsetYStart = props.minOffsetY;
      } else {
        res.activeOffsetYEnd = props.minOffsetY;
      }
    }

    if (props.activeOffsetX !== undefined) {
      delete res['activeOffsetX'];

      if (Array.isArray(props.activeOffsetX)) {
        res.activeOffsetXStart = props.activeOffsetX[0];
        res.activeOffsetXEnd = props.activeOffsetX[1];
      } else if (props.activeOffsetX < 0) {
        res.activeOffsetXStart = props.activeOffsetX;
      } else {
        res.activeOffsetXEnd = props.activeOffsetX;
      }
    }

    if (props.activeOffsetY !== undefined) {
      delete res['activeOffsetY'];

      if (Array.isArray(props.activeOffsetY)) {
        res.activeOffsetYStart = props.activeOffsetY[0];
        res.activeOffsetYEnd = props.activeOffsetY[1];
      } else if (props.activeOffsetY < 0) {
        res.activeOffsetYStart = props.activeOffsetY;
      } else {
        res.activeOffsetYEnd = props.activeOffsetY;
      }
    }

    if (props.failOffsetX !== undefined) {
      delete res['failOffsetX'];

      if (Array.isArray(props.failOffsetX)) {
        res.failOffsetXStart = props.failOffsetX[0];
        res.failOffsetXEnd = props.failOffsetX[1];
      } else if (props.failOffsetX < 0) {
        res.failOffsetXStart = props.failOffsetX;
      } else {
        res.failOffsetXEnd = props.failOffsetX;
      }
    }

    if (props.failOffsetY !== undefined) {
      delete res['failOffsetY'];

      if (Array.isArray(props.failOffsetY)) {
        res.failOffsetYStart = props.failOffsetY[0];
        res.failOffsetYEnd = props.failOffsetY[1];
      } else if (props.failOffsetY < 0) {
        res.failOffsetYStart = props.failOffsetY;
      } else {
        res.failOffsetYEnd = props.failOffsetY;
      }
    }

    return res;
  }

  function managePanProps(props) {
    if (__DEV__) {
      validatePanGestureHandlerProps(props);
    }

    return transformPanGestureHandlerProps(props);
  }

  var PanGestureHandler = (0, _createHandler.default)('PanGestureHandler', _objectSpread({}, _GestureHandlerPropTypes.default, {
    activeOffsetY: _propTypes.default.oneOfType([_propTypes.default.number, _propTypes.default.arrayOf(_propTypes.default.number)]),
    activeOffsetX: _propTypes.default.oneOfType([_propTypes.default.number, _propTypes.default.arrayOf(_propTypes.default.number)]),
    failOffsetY: _propTypes.default.oneOfType([_propTypes.default.number, _propTypes.default.arrayOf(_propTypes.default.number)]),
    failOffsetX: _propTypes.default.oneOfType([_propTypes.default.number, _propTypes.default.arrayOf(_propTypes.default.number)]),
    minDist: _propTypes.default.number,
    minVelocity: _propTypes.default.number,
    minVelocityX: _propTypes.default.number,
    minVelocityY: _propTypes.default.number,
    minPointers: _propTypes.default.number,
    maxPointers: _propTypes.default.number,
    avgTouches: _propTypes.default.bool
  }), {}, managePanProps, {
    activeOffsetYStart: true,
    activeOffsetYEnd: true,
    activeOffsetXStart: true,
    activeOffsetXEnd: true,
    failOffsetYStart: true,
    failOffsetYEnd: true,
    failOffsetXStart: true,
    failOffsetXEnd: true
  });
  exports.PanGestureHandler = PanGestureHandler;
  var PinchGestureHandler = (0, _createHandler.default)('PinchGestureHandler', _GestureHandlerPropTypes.default, {});
  exports.PinchGestureHandler = PinchGestureHandler;
  var RotationGestureHandler = (0, _createHandler.default)('RotationGestureHandler', _GestureHandlerPropTypes.default, {});
  exports.RotationGestureHandler = RotationGestureHandler;
},519,[1,24,25,32,34,37,46,69,54,508,512,520],"node_modules/react-native-gesture-handler/Gestures.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _reactNative = _$$_REQUIRE(_dependencyMap[0], "react-native");

  var _default = _reactNative.NativeModules.PlatformConstants;
  exports.default = _default;
},520,[2],"node_modules/react-native-gesture-handler/PlatformConstants.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/interopRequireWildcard");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _defineProperty2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/defineProperty"));

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "@babel/runtime/helpers/inherits"));

  var _react = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[8], "react"));

  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "invariant"));

  var _reactNative = _$$_REQUIRE(_dependencyMap[10], "react-native");

  var _GestureHandler = _$$_REQUIRE(_dependencyMap[11], "./GestureHandler");

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native-gesture-handler/DrawerLayout.js";

  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

  var DRAG_TOSS = 0.05;
  var IDLE = 'Idle';
  var DRAGGING = 'Dragging';
  var SETTLING = 'Settling';

  var DrawerLayout = function (_Component) {
    (0, _inherits2.default)(DrawerLayout, _Component);

    function DrawerLayout(_props, context) {
      var _this;

      (0, _classCallCheck2.default)(this, DrawerLayout);
      _this = (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(DrawerLayout).call(this, _props, context));
      _this._accessibilityIsModalView = _react.default.createRef();
      _this._pointerEventsView = _react.default.createRef();
      _this._panGestureHandler = _react.default.createRef();
      _this._drawerShown = false;

      _this._updateAnimatedEvent = function (props, state) {
        var drawerPosition = props.drawerPosition,
            drawerWidth = props.drawerWidth,
            drawerType = props.drawerType;
        var dragXValue = state.dragX,
            touchXValue = state.touchX,
            drawerTranslation = state.drawerTranslation,
            containerWidth = state.containerWidth;
        var dragX = dragXValue;
        var touchX = touchXValue;

        if (drawerPosition !== 'left') {
          dragX = _reactNative.Animated.multiply(new _reactNative.Animated.Value(-1), dragXValue);
          touchX = _reactNative.Animated.add(new _reactNative.Animated.Value(containerWidth), _reactNative.Animated.multiply(new _reactNative.Animated.Value(-1), touchXValue));
          touchXValue.setValue(containerWidth);
        } else {
          touchXValue.setValue(0);
        }

        var translationX = dragX;

        if (drawerType === 'front') {
          var startPositionX = _reactNative.Animated.add(touchX, _reactNative.Animated.multiply(new _reactNative.Animated.Value(-1), dragX));

          var dragOffsetFromOnStartPosition = startPositionX.interpolate({
            inputRange: [drawerWidth - 1, drawerWidth, drawerWidth + 1],
            outputRange: [0, 0, 1]
          });
          translationX = _reactNative.Animated.add(dragX, dragOffsetFromOnStartPosition);
        }

        _this._openValue = _reactNative.Animated.add(translationX, drawerTranslation).interpolate({
          inputRange: [0, drawerWidth],
          outputRange: [0, 1],
          extrapolate: 'clamp'
        });
        _this._onGestureEvent = _reactNative.Animated.event([{
          nativeEvent: {
            translationX: dragXValue,
            x: touchXValue
          }
        }], {
          useNativeDriver: props.useNativeAnimations
        });
      };

      _this._handleContainerLayout = function (_ref) {
        var nativeEvent = _ref.nativeEvent;

        _this.setState({
          containerWidth: nativeEvent.layout.width
        });
      };

      _this._emitStateChanged = function (newState, drawerWillShow) {
        _this.props.onDrawerStateChanged && _this.props.onDrawerStateChanged(newState, drawerWillShow);
      };

      _this._openingHandlerStateChange = function (_ref2) {
        var nativeEvent = _ref2.nativeEvent;

        if (nativeEvent.oldState === _GestureHandler.State.ACTIVE) {
          _this._handleRelease(nativeEvent);
        } else if (nativeEvent.state === _GestureHandler.State.ACTIVE) {
          _this._emitStateChanged(DRAGGING, false);

          if (_this.props.keyboardDismissMode === 'on-drag') {
            _reactNative.Keyboard.dismiss();
          }

          if (_this.props.hideStatusBar) {
            _reactNative.StatusBar.setHidden(true, _this.props.statusBarAnimation || 'slide');
          }
        }
      };

      _this._onTapHandlerStateChange = function (_ref3) {
        var nativeEvent = _ref3.nativeEvent;

        if (_this._drawerShown && nativeEvent.oldState === _GestureHandler.State.ACTIVE && _this.props.drawerLockMode !== 'locked-open') {
          _this.closeDrawer();
        }
      };

      _this._handleRelease = function (nativeEvent) {
        var _this$props = _this.props,
            drawerWidth = _this$props.drawerWidth,
            drawerPosition = _this$props.drawerPosition,
            drawerType = _this$props.drawerType;
        var containerWidth = _this.state.containerWidth;
        var dragX = nativeEvent.translationX,
            velocityX = nativeEvent.velocityX,
            touchX = nativeEvent.x;

        if (drawerPosition !== 'left') {
          dragX = -dragX;
          touchX = containerWidth - touchX;
          velocityX = -velocityX;
        }

        var gestureStartX = touchX - dragX;
        var dragOffsetBasedOnStart = 0;

        if (drawerType === 'front') {
          dragOffsetBasedOnStart = gestureStartX > drawerWidth ? gestureStartX - drawerWidth : 0;
        }

        var startOffsetX = dragX + dragOffsetBasedOnStart + (_this._drawerShown ? drawerWidth : 0);
        var projOffsetX = startOffsetX + DRAG_TOSS * velocityX;
        var shouldOpen = projOffsetX > drawerWidth / 2;

        if (shouldOpen) {
          _this._animateDrawer(startOffsetX, drawerWidth, velocityX);
        } else {
          _this._animateDrawer(startOffsetX, 0, velocityX);
        }
      };

      _this._updateShowing = function (showing) {
        _this._drawerShown = showing;
        _this._accessibilityIsModalView.current && _this._accessibilityIsModalView.current.setNativeProps({
          accessibilityViewIsModal: showing
        });
        _this._pointerEventsView.current && _this._pointerEventsView.current.setNativeProps({
          pointerEvents: showing ? 'auto' : 'none'
        });
        var _this$props2 = _this.props,
            drawerPosition = _this$props2.drawerPosition,
            minSwipeDistance = _this$props2.minSwipeDistance,
            edgeWidth = _this$props2.edgeWidth;
        var fromLeft = drawerPosition === 'left';
        var gestureOrientation = (fromLeft ? 1 : -1) * (_this._drawerShown ? -1 : 1);
        var hitSlop = fromLeft ? {
          left: 0,
          width: showing ? undefined : edgeWidth
        } : {
          right: 0,
          width: showing ? undefined : edgeWidth
        };
        _this._panGestureHandler.current && _this._panGestureHandler.current.setNativeProps({
          hitSlop: hitSlop,
          activeOffsetX: gestureOrientation * minSwipeDistance
        });
      };

      _this._animateDrawer = function (fromValue, toValue, velocity) {
        _this.state.dragX.setValue(0);

        _this.state.touchX.setValue(_this.props.drawerPosition === 'left' ? 0 : _this.state.containerWidth);

        if (fromValue != null) {
          var nextFramePosition = fromValue;

          if (_this.props.useNativeAnimations) {
            if (fromValue < toValue && velocity > 0) {
              nextFramePosition = Math.min(fromValue + velocity / 60.0, toValue);
            } else if (fromValue > toValue && velocity < 0) {
              nextFramePosition = Math.max(fromValue + velocity / 60.0, toValue);
            }
          }

          _this.state.drawerTranslation.setValue(nextFramePosition);
        }

        var willShow = toValue !== 0;

        _this._updateShowing(willShow);

        _this._emitStateChanged(SETTLING, willShow);

        if (_this.props.hideStatusBar) {
          _reactNative.StatusBar.setHidden(willShow, _this.props.statusBarAnimation || 'slide');
        }

        _reactNative.Animated.spring(_this.state.drawerTranslation, {
          velocity: velocity,
          bounciness: 0,
          toValue: toValue,
          useNativeDriver: _this.props.useNativeAnimations
        }).start(function (_ref4) {
          var finished = _ref4.finished;

          if (finished) {
            _this._emitStateChanged(IDLE, willShow);

            if (willShow) {
              _this.props.onDrawerOpen && _this.props.onDrawerOpen();
            } else {
              _this.props.onDrawerClose && _this.props.onDrawerClose();
            }
          }
        });
      };

      _this.openDrawer = function () {
        var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

        _this._animateDrawer(undefined, _this.props.drawerWidth, options.velocity ? options.velocity : 0);

        _this.forceUpdate();
      };

      _this.closeDrawer = function () {
        var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

        _this._animateDrawer(undefined, 0, options.velocity ? options.velocity : 0);

        _this.forceUpdate();
      };

      _this._renderOverlay = function () {
        (0, _invariant.default)(_this._openValue, 'should be set');

        var overlayOpacity = _this._openValue.interpolate({
          inputRange: [0, 1],
          outputRange: [0, 1],
          extrapolate: 'clamp'
        });

        var dynamicOverlayStyles = {
          opacity: overlayOpacity,
          backgroundColor: _this.props.overlayColor
        };
        return _react.default.createElement(_GestureHandler.TapGestureHandler, {
          onHandlerStateChange: _this._onTapHandlerStateChange,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 381
          }
        }, _react.default.createElement(_reactNative.Animated.View, {
          pointerEvents: _this._drawerShown ? 'auto' : 'none',
          ref: _this._pointerEventsView,
          style: [styles.overlay, dynamicOverlayStyles],
          __source: {
            fileName: _jsxFileName,
            lineNumber: 382
          }
        }));
      };

      _this._renderDrawer = function () {
        var _this$props3 = _this.props,
            drawerBackgroundColor = _this$props3.drawerBackgroundColor,
            drawerWidth = _this$props3.drawerWidth,
            drawerPosition = _this$props3.drawerPosition,
            drawerType = _this$props3.drawerType,
            drawerContainerStyle = _this$props3.drawerContainerStyle,
            contentContainerStyle = _this$props3.contentContainerStyle;
        var fromLeft = drawerPosition === 'left';
        var drawerSlide = drawerType !== 'back';
        var containerSlide = drawerType !== 'front';
        var reverseContentDirection = _reactNative.I18nManager.isRTL ? fromLeft : !fromLeft;
        var dynamicDrawerStyles = {
          backgroundColor: drawerBackgroundColor,
          width: drawerWidth
        };
        var openValue = _this._openValue;
        (0, _invariant.default)(openValue, 'should be set');
        var containerStyles;

        if (containerSlide) {
          var containerTranslateX = openValue.interpolate({
            inputRange: [0, 1],
            outputRange: fromLeft ? [0, drawerWidth] : [0, -drawerWidth],
            extrapolate: 'clamp'
          });
          containerStyles = {
            transform: [{
              translateX: containerTranslateX
            }]
          };
        }

        var drawerTranslateX = 0;

        if (drawerSlide) {
          var closedDrawerOffset = fromLeft ? -drawerWidth : drawerWidth;
          drawerTranslateX = openValue.interpolate({
            inputRange: [0, 1],
            outputRange: [closedDrawerOffset, 0],
            extrapolate: 'clamp'
          });
        }

        var drawerStyles = {
          transform: [{
            translateX: drawerTranslateX
          }],
          flexDirection: reverseContentDirection ? 'row-reverse' : 'row'
        };
        return _react.default.createElement(_reactNative.Animated.View, {
          style: styles.main,
          onLayout: _this._handleContainerLayout,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 445
          }
        }, _react.default.createElement(_reactNative.Animated.View, {
          style: [drawerType === 'front' ? styles.containerOnBack : styles.containerInFront, containerStyles, contentContainerStyle],
          importantForAccessibility: _this._drawerShown ? 'no-hide-descendants' : 'yes',
          __source: {
            fileName: _jsxFileName,
            lineNumber: 446
          }
        }, typeof _this.props.children === 'function' ? _this.props.children(_this._openValue) : _this.props.children, _this._renderOverlay()), _react.default.createElement(_reactNative.Animated.View, {
          pointerEvents: "box-none",
          ref: _this._accessibilityIsModalView,
          accessibilityViewIsModal: _this._drawerShown,
          style: [styles.drawerContainer, drawerStyles, drawerContainerStyle],
          __source: {
            fileName: _jsxFileName,
            lineNumber: 462
          }
        }, _react.default.createElement(_reactNative.View, {
          style: dynamicDrawerStyles,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 467
          }
        }, _this.props.renderNavigationView(_this._openValue))));
      };

      _this._setPanGestureRef = function (ref) {
        _this._panGestureHandler.current = ref;
        _this.props.onGestureRef && _this.props.onGestureRef(ref);
      };

      var _dragX = new _reactNative.Animated.Value(0);

      var _touchX = new _reactNative.Animated.Value(0);

      var _drawerTranslation = new _reactNative.Animated.Value(0);

      _this.state = {
        dragX: _dragX,
        touchX: _touchX,
        drawerTranslation: _drawerTranslation,
        containerWidth: 0
      };

      _this._updateAnimatedEvent(_props, _this.state);

      return _this;
    }

    (0, _createClass2.default)(DrawerLayout, [{
      key: "UNSAFE_componentWillUpdate",
      value: function UNSAFE_componentWillUpdate(props, state) {
        if (this.props.drawerPosition !== props.drawerPosition || this.props.drawerWidth !== props.drawerWidth || this.props.drawerType !== props.drawerType || this.state.containerWidth !== state.containerWidth) {
          this._updateAnimatedEvent(props, state);
        }
      }
    }, {
      key: "render",
      value: function render() {
        var _this$props4 = this.props,
            drawerPosition = _this$props4.drawerPosition,
            drawerLockMode = _this$props4.drawerLockMode,
            edgeWidth = _this$props4.edgeWidth,
            minSwipeDistance = _this$props4.minSwipeDistance;
        var fromLeft = drawerPosition === 'left';
        var gestureOrientation = (fromLeft ? 1 : -1) * (this._drawerShown ? -1 : 1);
        var hitSlop = fromLeft ? {
          left: 0,
          width: this._drawerShown ? undefined : edgeWidth
        } : {
          right: 0,
          width: this._drawerShown ? undefined : edgeWidth
        };
        return _react.default.createElement(_GestureHandler.PanGestureHandler, {
          ref: this._setPanGestureRef,
          hitSlop: hitSlop,
          activeOffsetX: gestureOrientation * minSwipeDistance,
          failOffsetY: [-15, 15],
          onGestureEvent: this._onGestureEvent,
          onHandlerStateChange: this._openingHandlerStateChange,
          enabled: drawerLockMode !== 'locked-closed' && drawerLockMode !== 'locked-open',
          __source: {
            fileName: _jsxFileName,
            lineNumber: 504
          }
        }, this._renderDrawer());
      }
    }]);
    return DrawerLayout;
  }(_react.Component);

  exports.default = DrawerLayout;
  DrawerLayout.defaultProps = {
    drawerWidth: 200,
    drawerPosition: 'left',
    useNativeAnimations: true,
    drawerType: 'front',
    edgeWidth: 20,
    minSwipeDistance: 3,
    overlayColor: 'rgba(0, 0, 0, 0.7)',
    drawerLockMode: 'unlocked'
  };
  DrawerLayout.positions = {
    Left: 'left',
    Right: 'right'
  };

  var styles = _reactNative.StyleSheet.create({
    drawerContainer: _objectSpread({}, _reactNative.StyleSheet.absoluteFillObject, {
      zIndex: 1001,
      flexDirection: 'row'
    }),
    containerInFront: _objectSpread({}, _reactNative.StyleSheet.absoluteFillObject, {
      zIndex: 1002
    }),
    containerOnBack: _objectSpread({}, _reactNative.StyleSheet.absoluteFillObject),
    main: {
      flex: 1,
      zIndex: 0,
      overflow: 'hidden'
    },
    overlay: _objectSpread({}, _reactNative.StyleSheet.absoluteFillObject, {
      zIndex: 1000
    })
  });
},521,[1,9,46,24,25,32,34,37,54,3,2,505],"node_modules/react-native-gesture-handler/DrawerLayout.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  Object.defineProperty(exports, "TouchableNativeFeedback", {
    enumerable: true,
    get: function get() {
      return _TouchableNativeFeedback.default;
    }
  });
  Object.defineProperty(exports, "TouchableWithoutFeedback", {
    enumerable: true,
    get: function get() {
      return _TouchableWithoutFeedback.default;
    }
  });
  Object.defineProperty(exports, "TouchableOpacity", {
    enumerable: true,
    get: function get() {
      return _TouchableOpacity.default;
    }
  });
  Object.defineProperty(exports, "TouchableHighlight", {
    enumerable: true,
    get: function get() {
      return _TouchableHighlight.default;
    }
  });

  var _TouchableNativeFeedback = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./TouchableNativeFeedback"));

  var _TouchableWithoutFeedback = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "./TouchableWithoutFeedback"));

  var _TouchableOpacity = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "./TouchableOpacity"));

  var _TouchableHighlight = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "./TouchableHighlight"));
},522,[1,523,525,526,527],"node_modules/react-native-gesture-handler/touchables/index.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/interopRequireWildcard");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _defineProperty2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/defineProperty"));

  var _extends2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/extends"));

  var _objectWithoutProperties2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/objectWithoutProperties"));

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf3 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "@babel/runtime/helpers/inherits"));

  var _GenericTouchable = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[10], "./GenericTouchable"));

  var _react = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[11], "react"));

  var _propTypes = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[12], "prop-types"));

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native-gesture-handler/touchables/TouchableNativeFeedback.android.js";

  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

  var TouchableNativeFeedback = function (_Component) {
    (0, _inherits2.default)(TouchableNativeFeedback, _Component);

    function TouchableNativeFeedback() {
      var _getPrototypeOf2;

      var _this;

      (0, _classCallCheck2.default)(this, TouchableNativeFeedback);

      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
        args[_key] = arguments[_key];
      }

      _this = (0, _possibleConstructorReturn2.default)(this, (_getPrototypeOf2 = (0, _getPrototypeOf3.default)(TouchableNativeFeedback)).call.apply(_getPrototypeOf2, [this].concat(args)));

      _this.getExtraButtonProps = function () {
        var extraProps = {};
        var background = _this.props.background;

        if (background) {
          if (background.type === 'Ripple') {
            extraProps['borderless'] = background.borderless;
            extraProps['rippleColor'] = background.color;
          } else if (background.type === 'SelectableBackgroundBorderless') {
            extraProps['borderless'] = true;
          }
        }

        extraProps['foreground'] = _this.props.useForeground;
        return extraProps;
      };

      return _this;
    }

    (0, _createClass2.default)(TouchableNativeFeedback, [{
      key: "render",
      value: function render() {
        var _this$props = this.props,
            _this$props$style = _this$props.style,
            style = _this$props$style === void 0 ? {} : _this$props$style,
            rest = (0, _objectWithoutProperties2.default)(_this$props, ["style"]);
        return _react.default.createElement(_GenericTouchable.default, (0, _extends2.default)({}, rest, {
          style: style,
          extraButtonProps: this.getExtraButtonProps(),
          __source: {
            fileName: _jsxFileName,
            lineNumber: 58
          }
        }));
      }
    }]);
    return TouchableNativeFeedback;
  }(_react.Component);

  exports.default = TouchableNativeFeedback;

  TouchableNativeFeedback.SelectableBackground = function () {
    return {
      type: 'SelectableBackground'
    };
  };

  TouchableNativeFeedback.SelectableBackgroundBorderless = function () {
    return {
      type: 'SelectableBackgroundBorderless'
    };
  };

  TouchableNativeFeedback.Ripple = function (color, borderless) {
    return {
      type: 'Ripple',
      color: color,
      borderless: borderless
    };
  };

  TouchableNativeFeedback.canUseNativeForeground = function () {
    return "android" === 'android' && Platform.Version >= 23;
  };

  TouchableNativeFeedback.defaultProps = _objectSpread({}, _GenericTouchable.default.defaultProps, {
    useForeground: true,
    extraButtonProps: {
      rippleColor: null
    }
  });
  TouchableNativeFeedback.propTypes = _objectSpread({}, _GenericTouchable.default.publicPropTypes, {
    useForeground: _propTypes.default.bool,
    background: _propTypes.default.object,
    style: _propTypes.default.any
  });
},523,[1,9,46,13,52,24,25,32,34,37,524,54,69],"node_modules/react-native-gesture-handler/touchables/TouchableNativeFeedback.android.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/interopRequireWildcard");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = exports.TOUCHABLE_STATE = void 0;

  var _defineProperty2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/defineProperty"));

  var _extends2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/extends"));

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf3 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "@babel/runtime/helpers/inherits"));

  var _react = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[9], "react"));

  var _reactNative = _$$_REQUIRE(_dependencyMap[10], "react-native");

  var _GestureHandler = _$$_REQUIRE(_dependencyMap[11], "../GestureHandler");

  var _propTypes = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[12], "prop-types"));

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native-gesture-handler/touchables/GenericTouchable.js";

  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

  var TOUCHABLE_STATE = {
    UNDETERMINED: 0,
    BEGAN: 1,
    MOVED_OUTSIDE: 2
  };
  exports.TOUCHABLE_STATE = TOUCHABLE_STATE;
  var PublicPropTypes = {
    accessible: _propTypes.default.bool,
    accessibilityLabel: _propTypes.default.node,
    accessibilityHint: _propTypes.default.string,
    hitSlop: _propTypes.default.shape({
      top: _propTypes.default.number,
      left: _propTypes.default.number,
      bottom: _propTypes.default.number,
      right: _propTypes.default.number
    }),
    disabled: _propTypes.default.bool,
    onPress: _propTypes.default.func,
    onPressIn: _propTypes.default.func,
    onPressOut: _propTypes.default.func,
    onLayout: _propTypes.default.func,
    onLongPress: _propTypes.default.func,
    nativeID: _propTypes.default.string,
    testID: _propTypes.default.string,
    delayPressIn: _propTypes.default.number,
    delayPressOut: _propTypes.default.number,
    delayLongPress: _propTypes.default.number,
    shouldActivateOnStart: _propTypes.default.bool,
    disallowInterruption: _propTypes.default.bool
  };
  var InternalPropTypes = {
    extraButtonProps: _propTypes.default.object,
    onStateChange: _propTypes.default.func
  };

  var GenericTouchable = function (_Component) {
    (0, _inherits2.default)(GenericTouchable, _Component);

    function GenericTouchable() {
      var _getPrototypeOf2;

      var _this;

      (0, _classCallCheck2.default)(this, GenericTouchable);

      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
        args[_key] = arguments[_key];
      }

      _this = (0, _possibleConstructorReturn2.default)(this, (_getPrototypeOf2 = (0, _getPrototypeOf3.default)(GenericTouchable)).call.apply(_getPrototypeOf2, [this].concat(args)));
      _this.longPressDetected = false;
      _this.pointerInside = true;
      _this.STATE = TOUCHABLE_STATE.UNDETERMINED;

      _this.onGestureEvent = function (_ref) {
        var pointerInside = _ref.nativeEvent.pointerInside;

        if (_this.pointerInside !== pointerInside) {
          if (pointerInside) {
            _this.onMoveIn();
          } else {
            _this.onMoveOut();
          }
        }

        _this.pointerInside = pointerInside;
      };

      _this.onHandlerStateChange = function (_ref2) {
        var nativeEvent = _ref2.nativeEvent;
        var state = nativeEvent.state;

        if (state === _GestureHandler.State.CANCELLED || state === _GestureHandler.State.FAILED) {
          _this.moveToState(TOUCHABLE_STATE.UNDETERMINED);
        } else if (state === (_reactNative.Platform.OS === 'ios' ? _GestureHandler.State.ACTIVE : _GestureHandler.State.BEGAN) && _this.STATE === TOUCHABLE_STATE.UNDETERMINED) {
          _this.handlePressIn();
        } else if (state === _GestureHandler.State.END) {
          var shouldCallOnPress = !_this.longPressDetected && _this.STATE !== TOUCHABLE_STATE.MOVED_OUTSIDE && _this.pressOutTimeout === null;

          _this.handleGoToUndetermined();

          if (shouldCallOnPress) {
            _this.props.onPress && _this.props.onPress();
          }
        }
      };

      _this.onLongPressDetected = function () {
        _this.longPressDetected = true;

        _this.props.onLongPress();
      };

      return _this;
    }

    (0, _createClass2.default)(GenericTouchable, [{
      key: "handlePressIn",
      value: function handlePressIn() {
        var _this2 = this;

        if (this.props.delayPressIn) {
          this.pressInTimeout = setTimeout(function () {
            _this2.moveToState(TOUCHABLE_STATE.BEGAN);

            _this2.pressInTimeout = null;
          }, this.props.delayPressIn);
        } else {
          this.moveToState(TOUCHABLE_STATE.BEGAN);
        }

        if (this.props.onLongPress) {
          var time = (this.props.delayPressIn || 0) + (this.props.delayLongPress || 0);
          this.longPressTimeout = setTimeout(this.onLongPressDetected, time);
        }
      }
    }, {
      key: "handleMoveOutside",
      value: function handleMoveOutside() {
        var _this3 = this;

        if (this.props.delayPressOut) {
          this.pressOutTimeout = this.pressOutTimeout || setTimeout(function () {
            _this3.moveToState(TOUCHABLE_STATE.MOVED_OUTSIDE);

            _this3.pressOutTimeout = null;
          }, this.props.delayPressOut);
        } else {
          this.moveToState(TOUCHABLE_STATE.MOVED_OUTSIDE);
        }
      }
    }, {
      key: "handleGoToUndetermined",
      value: function handleGoToUndetermined() {
        var _this4 = this;

        clearTimeout(this.pressOutTimeout);

        if (this.props.delayPressOut) {
          this.pressOutTimeout = setTimeout(function () {
            if (_this4.STATE === TOUCHABLE_STATE.UNDETERMINED) {
              _this4.moveToState(TOUCHABLE_STATE.BEGAN);
            }

            _this4.moveToState(TOUCHABLE_STATE.UNDETERMINED);

            _this4.pressOutTimeout = null;
          }, this.props.delayPressOut);
        } else {
          if (this.STATE === TOUCHABLE_STATE.UNDETERMINED) {
            this.moveToState(TOUCHABLE_STATE.BEGAN);
          }

          this.moveToState(TOUCHABLE_STATE.UNDETERMINED);
        }
      }
    }, {
      key: "componentDidMount",
      value: function componentDidMount() {
        this.reset();
      }
    }, {
      key: "reset",
      value: function reset() {
        this.longPressDetected = false;
        this.pointerInside = true;
        clearTimeout(this.pressInTimeout);
        clearTimeout(this.pressOutTimeout);
        clearTimeout(this.longPressTimeout);
        this.pressOutTimeout = null;
        this.longPressTimeout = null;
        this.pressInTimeout = null;
      }
    }, {
      key: "moveToState",
      value: function moveToState(newState) {
        if (newState === this.STATE) {
          return;
        }

        if (newState === TOUCHABLE_STATE.BEGAN) {
          this.props.onPressIn && this.props.onPressIn();
        } else if (newState === TOUCHABLE_STATE.MOVED_OUTSIDE) {
          this.props.onPressOut && this.props.onPressOut();
        } else if (newState === TOUCHABLE_STATE.UNDETERMINED) {
          this.reset();

          if (this.STATE === TOUCHABLE_STATE.BEGAN) {
            this.props.onPressOut && this.props.onPressOut();
          }
        }

        this.props.onStateChange && this.props.onStateChange(this.STATE, newState);
        this.STATE = newState;
      }
    }, {
      key: "componentWillUnmount",
      value: function componentWillUnmount() {
        this.reset();
      }
    }, {
      key: "onMoveIn",
      value: function onMoveIn() {
        if (this.STATE === TOUCHABLE_STATE.MOVED_OUTSIDE) {
          this.moveToState(TOUCHABLE_STATE.BEGAN);
        }
      }
    }, {
      key: "onMoveOut",
      value: function onMoveOut() {
        clearTimeout(this.longPressTimeout);
        this.longPressTimeout = null;

        if (this.STATE === TOUCHABLE_STATE.BEGAN) {
          this.handleMoveOutside();
        }
      }
    }, {
      key: "render",
      value: function render() {
        var coreProps = {
          accessible: this.props.accessible !== false,
          accessibilityLabel: this.props.accessibilityLabel,
          accessibilityHint: this.props.accessibilityHint,
          accessibilityComponentType: this.props.accessibilityComponentType,
          accessibilityRole: this.props.accessibilityRole,
          accessibilityStates: this.props.accessibilityStates,
          accessibilityTraits: this.props.accessibilityTraits,
          nativeID: this.props.nativeID,
          testID: this.props.testID,
          onLayout: this.props.onLayout,
          hitSlop: this.props.hitSlop
        };
        return _react.default.createElement(_GestureHandler.BaseButton, (0, _extends2.default)({
          style: this.props.containerStyle,
          onHandlerStateChange: this.props.disabled ? null : this.onHandlerStateChange,
          onGestureEvent: this.onGestureEvent,
          hitSlop: this.props.hitSlop,
          shouldActivateOnStart: this.props.shouldActivateOnStart,
          disallowInterruption: this.props.disallowInterruption
        }, this.props.extraButtonProps, {
          __source: {
            fileName: _jsxFileName,
            lineNumber: 260
          }
        }), _react.default.createElement(_reactNative.Animated.View, (0, _extends2.default)({}, coreProps, {
          style: this.props.style,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 270
          }
        }), this.props.children));
      }
    }]);
    return GenericTouchable;
  }(_react.Component);

  exports.default = GenericTouchable;
  GenericTouchable.publicPropTypes = PublicPropTypes;
  GenericTouchable.internalPropTypes = InternalPropTypes;
  GenericTouchable.propTypes = _objectSpread({}, InternalPropTypes, {}, PublicPropTypes);
  GenericTouchable.defaultProps = {
    delayLongPress: 600,
    extraButtonProps: {
      rippleColor: 'transparent'
    }
  };
},524,[1,9,46,13,24,25,32,34,37,54,2,505,69],"node_modules/react-native-gesture-handler/touchables/GenericTouchable.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _extends2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/extends"));

  var _react = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "react"));

  var _GenericTouchable = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "./GenericTouchable"));

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native-gesture-handler/touchables/TouchableWithoutFeedback.js";

  var TouchableWithoutFeedback = _react.default.forwardRef(function (props, ref) {
    return _react.default.createElement(_GenericTouchable.default, (0, _extends2.default)({
      ref: ref
    }, props, {
      __source: {
        fileName: _jsxFileName,
        lineNumber: 5
      }
    }));
  });

  TouchableWithoutFeedback.defaultProps = _GenericTouchable.default.defaultProps;
  TouchableWithoutFeedback.propTypes = _GenericTouchable.default.publicPropTypes;
  var _default = TouchableWithoutFeedback;
  exports.default = _default;
},525,[1,13,54,524],"node_modules/react-native-gesture-handler/touchables/TouchableWithoutFeedback.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/interopRequireWildcard");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _defineProperty2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/defineProperty"));

  var _extends2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/extends"));

  var _objectWithoutProperties2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/objectWithoutProperties"));

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf3 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "@babel/runtime/helpers/inherits"));

  var _reactNative = _$$_REQUIRE(_dependencyMap[10], "react-native");

  var _GenericTouchable = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[11], "./GenericTouchable"));

  var _react = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[12], "react"));

  var _propTypes = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[13], "prop-types"));

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native-gesture-handler/touchables/TouchableOpacity.js";

  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

  var TouchableOpacity = function (_Component) {
    (0, _inherits2.default)(TouchableOpacity, _Component);

    function TouchableOpacity() {
      var _getPrototypeOf2;

      var _this;

      (0, _classCallCheck2.default)(this, TouchableOpacity);

      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
        args[_key] = arguments[_key];
      }

      _this = (0, _possibleConstructorReturn2.default)(this, (_getPrototypeOf2 = (0, _getPrototypeOf3.default)(TouchableOpacity)).call.apply(_getPrototypeOf2, [this].concat(args)));

      _this.getChildStyleOpacityWithDefault = function () {
        var childStyle = _reactNative.StyleSheet.flatten(_this.props.style) || {};
        return childStyle.opacity == null ? 1 : childStyle.opacity;
      };

      _this.opacity = new _reactNative.Animated.Value(_this.getChildStyleOpacityWithDefault());

      _this.setOpacityTo = function (value, duration) {
        _reactNative.Animated.timing(_this.opacity, {
          toValue: value,
          duration: duration,
          easing: _reactNative.Easing.inOut(_reactNative.Easing.quad),
          useNativeDriver: true
        }).start();
      };

      _this.onStateChange = function (from, to) {
        if (to === _GenericTouchable.TOUCHABLE_STATE.BEGAN) {
          _this.setOpacityTo(_this.props.activeOpacity, 0);
        } else if (to === _GenericTouchable.TOUCHABLE_STATE.UNDETERMINED || to === _GenericTouchable.TOUCHABLE_STATE.MOVED_OUTSIDE) {
          _this.setOpacityTo(_this.getChildStyleOpacityWithDefault(), 150);
        }
      };

      return _this;
    }

    (0, _createClass2.default)(TouchableOpacity, [{
      key: "render",
      value: function render() {
        var _this$props = this.props,
            _this$props$style = _this$props.style,
            style = _this$props$style === void 0 ? {} : _this$props$style,
            rest = (0, _objectWithoutProperties2.default)(_this$props, ["style"]);
        return _react.default.createElement(_GenericTouchable.default, (0, _extends2.default)({}, rest, {
          style: [style, {
            opacity: this.opacity
          }],
          onStateChange: this.onStateChange,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 52
          }
        }), this.props.children ? this.props.children : _react.default.createElement(_reactNative.View, {
          __source: {
            fileName: _jsxFileName,
            lineNumber: 61
          }
        }));
      }
    }]);
    return TouchableOpacity;
  }(_react.Component);

  exports.default = TouchableOpacity;
  TouchableOpacity.defaultProps = _objectSpread({}, _GenericTouchable.default.defaultProps, {
    activeOpacity: 0.2
  });
  TouchableOpacity.propTypes = _objectSpread({}, _GenericTouchable.default.publicPropTypes, {
    style: _propTypes.default.any,
    activeOpacity: _propTypes.default.number
  });
},526,[1,9,46,13,52,24,25,32,34,37,2,524,54,69],"node_modules/react-native-gesture-handler/touchables/TouchableOpacity.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/interopRequireWildcard");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _defineProperty2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/defineProperty"));

  var _extends2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/extends"));

  var _objectWithoutProperties2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/objectWithoutProperties"));

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "@babel/runtime/helpers/inherits"));

  var _react = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[10], "react"));

  var _GenericTouchable = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[11], "./GenericTouchable"));

  var _reactNative = _$$_REQUIRE(_dependencyMap[12], "react-native");

  var _propTypes = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[13], "prop-types"));

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native-gesture-handler/touchables/TouchableHighlight.js";

  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

  var TouchableHighlight = function (_Component) {
    (0, _inherits2.default)(TouchableHighlight, _Component);

    function TouchableHighlight(props) {
      var _this;

      (0, _classCallCheck2.default)(this, TouchableHighlight);
      _this = (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(TouchableHighlight).call(this, props));

      _this.showUnderlay = function () {
        if (!_this.hasPressHandler()) {
          return;
        }

        _this.setState({
          extraChildStyle: {
            opacity: _this.props.activeOpacity
          },
          extraUnderlayStyle: {
            backgroundColor: _this.props.underlayColor
          }
        });

        _this.props.onShowUnderlay && _this.props.onShowUnderlay();
      };

      _this.hasPressHandler = function () {
        return _this.props.onPress || _this.props.onPressIn || _this.props.onPressOut || _this.props.onLongPress;
      };

      _this.hideUnderlay = function () {
        _this.setState({
          extraChildStyle: null,
          extraUnderlayStyle: null
        });

        _this.props.onHideUnderlay && _this.props.onHideUnderlay();
      };

      _this.onStateChange = function (from, to) {
        if (to === _GenericTouchable.TOUCHABLE_STATE.BEGAN) {
          _this.showUnderlay();
        } else if (to === _GenericTouchable.TOUCHABLE_STATE.UNDETERMINED || to === _GenericTouchable.TOUCHABLE_STATE.MOVED_OUTSIDE) {
          _this.hideUnderlay();
        }
      };

      _this.state = {
        extraChildStyle: null,
        extraUnderlayStyle: null
      };
      return _this;
    }

    (0, _createClass2.default)(TouchableHighlight, [{
      key: "renderChildren",
      value: function renderChildren() {
        if (!this.props.children) {
          return _react.default.createElement(_reactNative.View, {
            __source: {
              fileName: _jsxFileName,
              lineNumber: 66
            }
          });
        }

        var child = _react.default.Children.only(this.props.children);

        return _react.default.cloneElement(child, {
          style: _reactNative.StyleSheet.compose(child.props.style, this.state.extraChildStyle)
        });
      }
    }, {
      key: "render",
      value: function render() {
        var _this$props = this.props,
            _this$props$style = _this$props.style,
            style = _this$props$style === void 0 ? {} : _this$props$style,
            rest = (0, _objectWithoutProperties2.default)(_this$props, ["style"]);
        var extraUnderlayStyle = this.state.extraUnderlayStyle;
        return _react.default.createElement(_GenericTouchable.default, (0, _extends2.default)({}, rest, {
          style: [style, extraUnderlayStyle],
          onStateChange: this.onStateChange,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 93
          }
        }), this.renderChildren());
      }
    }]);
    return TouchableHighlight;
  }(_react.Component);

  exports.default = TouchableHighlight;
  TouchableHighlight.defaultProps = _objectSpread({}, _GenericTouchable.default.defaultProps, {
    activeOpacity: 0.85,
    delayPressOut: 100,
    underlayColor: 'black'
  });
  TouchableHighlight.propTypes = _objectSpread({}, _GenericTouchable.default.publicPropTypes, {
    activeOpacity: _propTypes.default.number,
    underlayColor: _propTypes.default.string,
    style: _propTypes.default.any,
    onShowUnderlay: _propTypes.default.func,
    onHideUnderlay: _propTypes.default.func
  });
},527,[1,9,46,13,52,24,25,32,34,37,54,524,2,69],"node_modules/react-native-gesture-handler/touchables/TouchableHighlight.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/interopRequireWildcard");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _objectWithoutProperties2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/objectWithoutProperties"));

  var _extends2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/extends"));

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "@babel/runtime/helpers/inherits"));

  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[9], "react"));

  var _reactNative = _$$_REQUIRE(_dependencyMap[10], "react-native");

  var _core = _$$_REQUIRE(_dependencyMap[11], "@react-navigation/core");

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/@react-navigation/native/src/Themed.js";

  var ThemedText = function (_React$Component) {
    (0, _inherits2.default)(ThemedText, _React$Component);

    function ThemedText() {
      (0, _classCallCheck2.default)(this, ThemedText);
      return (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(ThemedText).apply(this, arguments));
    }

    (0, _createClass2.default)(ThemedText, [{
      key: "render",
      value: function render() {
        return React.createElement(_reactNative.Text, (0, _extends2.default)({}, this.props, {
          style: [{
            color: _core.ThemeColors[this.context].label
          }, this.props.style],
          __source: {
            fileName: _jsxFileName,
            lineNumber: 10
          }
        }));
      }
    }]);
    return ThemedText;
  }(React.Component);

  ThemedText.contextType = _core.ThemeContext;

  var ThemedTextInput = function (_React$Component2) {
    (0, _inherits2.default)(ThemedTextInput, _React$Component2);

    function ThemedTextInput() {
      (0, _classCallCheck2.default)(this, ThemedTextInput);
      return (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(ThemedTextInput).apply(this, arguments));
    }

    (0, _createClass2.default)(ThemedTextInput, [{
      key: "render",
      value: function render() {
        return React.createElement(_reactNative.TextInput, (0, _extends2.default)({}, this.props, {
          placeholderTextColor: this.context === 'dark' ? '#ebebf54c' : '#3c3c434c',
          style: [{
            color: _core.ThemeColors[this.context].label
          }, this.props.style],
          __source: {
            fileName: _jsxFileName,
            lineNumber: 23
          }
        }));
      }
    }]);
    return ThemedTextInput;
  }(React.Component);

  ThemedTextInput.contextType = _core.ThemeContext;

  var ThemedStatusBar = function (_React$Component3) {
    (0, _inherits2.default)(ThemedStatusBar, _React$Component3);

    function ThemedStatusBar() {
      (0, _classCallCheck2.default)(this, ThemedStatusBar);
      return (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(ThemedStatusBar).apply(this, arguments));
    }

    (0, _createClass2.default)(ThemedStatusBar, [{
      key: "render",
      value: function render() {
        var _this$props = this.props,
            barStyle = _this$props.barStyle,
            props = (0, _objectWithoutProperties2.default)(_this$props, ["barStyle"]);
        return React.createElement(_reactNative.StatusBar, (0, _extends2.default)({
          barStyle: barStyle ? barStyle : this.context === 'dark' ? 'light-content' : 'default'
        }, props, {
          __source: {
            fileName: _jsxFileName,
            lineNumber: 41
          }
        }));
      }
    }]);
    return ThemedStatusBar;
  }(React.Component);

  ThemedStatusBar.contextType = _core.ThemeContext;
  var _default = {
    Text: ThemedText,
    StatusBar: ThemedStatusBar,
    TextInput: ThemedTextInput
  };
  exports.default = _default;
},528,[1,9,52,13,24,25,32,34,37,54,2,449],"node_modules/@react-navigation/native/src/Themed.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var throwError = function throwError(message, page) {
    throw new Error(message + ". See https://reactnavigation.org/docs/" + page + ".html for more details.");
  };

  module.exports = {
    get createNavigationContainer() {
      throw new Error('`createNavigationContainer()` has been removed. Use `createAppContainer()` instead. You can also import createAppContainer directly from `@react-navigation/native`.');
    },

    get createStackNavigator() {
      throwError('`createStackNavigator()` has been moved to `react-navigation-stack`', 'stack-navigator');
    },

    get createBottomTabNavigator() {
      throwError('`createBottomTabNavigator()` has been moved to `react-navigation-tabs`', 'bottom-tab-navigator');
    },

    get createMaterialTopTabNavigator() {
      throwError('`createMaterialTopTabNavigator()` has been moved to `react-navigation-tabs`', 'material-top-tab-navigator');
    },

    get createDrawerNavigator() {
      throwError('`createDrawerNavigator()` has been moved to `react-navigation-drawer`', 'drawer-navigator');
    },

    get StackGestureContext() {
      throwError('`StackGestureContext` has been moved to `react-navigation-stack`', 'stack-navigator');
    },

    get DrawerGestureContext() {
      throwError('`DrawerGestureContext` has been moved to `react-navigation-drawer`', 'stack-navigator');
    },

    get DrawerRouter() {
      throwError('`DrawerRouter` has been moved to `react-navigation-drawer`', 'drawer-navigator');
    },

    get DrawerActions() {
      throwError('`DrawerActions` has been moved to `react-navigation-drawer`', 'drawer-navigator');
    },

    get Transitioner() {
      throwError('`Transitioner` has been removed.', 'stack-navigator');
    },

    get StackView() {
      throwError('`StackView` has been removed', 'stack-navigator');
    },

    get StackViewCard() {
      throwError('`StackViewCard` has been removed', 'stack-navigator');
    },

    get StackViewTransitionConfigs() {
      throwError('`StackViewTransitionConfigs` has been removed', 'stack-navigator');
    },

    get Header() {
      throwError('`Header` has been moved to `react-navigation-stack`', 'stack-navigator');
    },

    get HeaderTitle() {
      throwError('`HeaderTitle` has been moved to `react-navigation-stack`', 'stack-navigator');
    },

    get HeaderBackButton() {
      throwError('`HeaderBackButton` has been moved to `react-navigation-stack`', 'stack-navigator');
    },

    get HeaderStyleInterpolator() {
      throwError('`HeaderStyleInterpolator` has been removed', 'stack-navigator');
    },

    get DrawerView() {
      throwError('`createStackNavigator()` has been moved to `react-navigation-drawer`', 'stack-navigator');
    },

    get DrawerItems() {
      throwError('`DrawerItems` has been moved to `react-navigation-drawer`', 'drawer-navigator');
    },

    get DrawerSidebar() {
      throwError('`DrawerSidebar` has been moved to `react-navigation-drawer`', 'drawer-navigator');
    },

    get BottomTabBar() {
      throwError('`BottomTabBar` has been moved to `react-navigation-tabs`', 'bottom-tab-navigator');
    },

    get MaterialTopTabBar() {
      throwError('`MaterialTopTabBar` has been moved to `react-navigation-tabs`', 'material-top-tab-navigator');
    }

  };
},529,[],"node_modules/react-navigation/src/deprecations.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  Object.defineProperty(exports, "createBottomTabNavigator", {
    enumerable: true,
    get: function get() {
      return _createBottomTabNavigator.default;
    }
  });
  Object.defineProperty(exports, "createMaterialTopTabNavigator", {
    enumerable: true,
    get: function get() {
      return _createMaterialTopTabNavigator.default;
    }
  });
  Object.defineProperty(exports, "BottomTabBar", {
    enumerable: true,
    get: function get() {
      return _BottomTabBar.default;
    }
  });
  Object.defineProperty(exports, "MaterialTopTabBar", {
    enumerable: true,
    get: function get() {
      return _MaterialTopTabBar.default;
    }
  });
  Object.defineProperty(exports, "createTabNavigator", {
    enumerable: true,
    get: function get() {
      return _createTabNavigator.default;
    }
  });
  Object.defineProperty(exports, "BottomTabBarProps", {
    enumerable: true,
    get: function get() {
      return _types.BottomTabBarProps;
    }
  });
  Object.defineProperty(exports, "NavigationTabState", {
    enumerable: true,
    get: function get() {
      return _types.NavigationTabState;
    }
  });
  Object.defineProperty(exports, "NavigationTabProp", {
    enumerable: true,
    get: function get() {
      return _types.NavigationTabProp;
    }
  });
  Object.defineProperty(exports, "NavigationTabScreenProps", {
    enumerable: true,
    get: function get() {
      return _types.NavigationTabScreenProps;
    }
  });
  Object.defineProperty(exports, "NavigationBottomTabOptions", {
    enumerable: true,
    get: function get() {
      return _types.NavigationBottomTabOptions;
    }
  });
  Object.defineProperty(exports, "NavigationMaterialTabOptions", {
    enumerable: true,
    get: function get() {
      return _types.NavigationMaterialTabOptions;
    }
  });
  Object.defineProperty(exports, "NavigationBottomTabScreenComponent", {
    enumerable: true,
    get: function get() {
      return _types.NavigationBottomTabScreenComponent;
    }
  });
  Object.defineProperty(exports, "NavigationMaterialTabScreenComponent", {
    enumerable: true,
    get: function get() {
      return _types.NavigationMaterialTabScreenComponent;
    }
  });

  var _createBottomTabNavigator = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./navigators/createBottomTabNavigator"));

  var _createMaterialTopTabNavigator = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "./navigators/createMaterialTopTabNavigator"));

  var _BottomTabBar = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "./views/BottomTabBar"));

  var _MaterialTopTabBar = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "./views/MaterialTopTabBar"));

  var _createTabNavigator = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "./utils/createTabNavigator"));

  var _types = _$$_REQUIRE(_dependencyMap[6], "./types");
},530,[1,531,597,534,609,533,610],"node_modules/react-navigation-tabs/lib/module/index.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireWildcard");

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _toConsumableArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/toConsumableArray"));

  var _extends2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/extends"));

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf3 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "@babel/runtime/helpers/inherits"));

  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[9], "react"));

  var _reactNative = _$$_REQUIRE(_dependencyMap[10], "react-native");

  var _reactNativeScreens = _$$_REQUIRE(_dependencyMap[11], "react-native-screens");

  var _createTabNavigator = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[12], "../utils/createTabNavigator"));

  var _BottomTabBar = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[13], "../views/BottomTabBar"));

  var _ResourceSavingScene = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[14], "../views/ResourceSavingScene"));

  var _jsxFileName = "/Users/satya/Workspace/Callstack/react-navigation-tabs/src/navigators/createBottomTabNavigator.tsx";

  var TabNavigationView = function (_React$PureComponent) {
    (0, _inherits2.default)(TabNavigationView, _React$PureComponent);

    function TabNavigationView() {
      var _getPrototypeOf2;

      var _this;

      (0, _classCallCheck2.default)(this, TabNavigationView);

      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
        args[_key] = arguments[_key];
      }

      _this = (0, _possibleConstructorReturn2.default)(this, (_getPrototypeOf2 = (0, _getPrototypeOf3.default)(TabNavigationView)).call.apply(_getPrototypeOf2, [this].concat(args)));
      _this.state = {
        loaded: [_this.props.navigation.state.index]
      };

      _this._getButtonComponent = function (_ref) {
        var route = _ref.route;
        var descriptors = _this.props.descriptors;
        var descriptor = descriptors[route.key];
        var options = descriptor.options;

        if (options.tabBarButtonComponent) {
          return options.tabBarButtonComponent;
        }

        return undefined;
      };

      _this._renderTabBar = function () {
        var _this$props = _this.props,
            _this$props$tabBarCom = _this$props.tabBarComponent,
            TabBarComponent = _this$props$tabBarCom === void 0 ? _BottomTabBar.default : _this$props$tabBarCom,
            tabBarOptions = _this$props.tabBarOptions,
            navigation = _this$props.navigation,
            screenProps = _this$props.screenProps,
            getLabelText = _this$props.getLabelText,
            getAccessibilityLabel = _this$props.getAccessibilityLabel,
            getAccessibilityRole = _this$props.getAccessibilityRole,
            getAccessibilityStates = _this$props.getAccessibilityStates,
            getTestID = _this$props.getTestID,
            renderIcon = _this$props.renderIcon,
            onTabPress = _this$props.onTabPress,
            onTabLongPress = _this$props.onTabLongPress;
        var descriptors = _this.props.descriptors;
        var state = _this.props.navigation.state;
        var route = state.routes[state.index];
        var descriptor = descriptors[route.key];
        var options = descriptor.options;

        if (options.tabBarVisible === false) {
          return null;
        }

        return React.createElement(TabBarComponent, (0, _extends2.default)({}, tabBarOptions, {
          jumpTo: _this._jumpTo,
          navigation: navigation,
          screenProps: screenProps,
          onTabPress: onTabPress,
          onTabLongPress: onTabLongPress,
          getLabelText: getLabelText,
          getButtonComponent: _this._getButtonComponent,
          getAccessibilityLabel: getAccessibilityLabel,
          getAccessibilityRole: getAccessibilityRole,
          getAccessibilityStates: getAccessibilityStates,
          getTestID: getTestID,
          renderIcon: renderIcon,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 114
          }
        }));
      };

      _this._jumpTo = function (key) {
        var _this$props2 = _this.props,
            navigation = _this$props2.navigation,
            onIndexChange = _this$props2.onIndexChange;
        var index = navigation.state.routes.findIndex(function (route) {
          return route.key === key;
        });
        onIndexChange(index);
      };

      return _this;
    }

    (0, _createClass2.default)(TabNavigationView, [{
      key: "render",
      value: function render() {
        var _this$props3 = this.props,
            navigation = _this$props3.navigation,
            renderScene = _this$props3.renderScene,
            lazy = _this$props3.lazy;
        var routes = navigation.state.routes;
        var loaded = this.state.loaded;
        return React.createElement(_reactNative.View, {
          style: styles.container,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 146
          }
        }, React.createElement(_reactNativeScreens.ScreenContainer, {
          style: styles.pages,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 147
          }
        }, routes.map(function (route, index) {
          if (lazy && !loaded.includes(index)) {
            return null;
          }

          var isFocused = navigation.state.index === index;
          return React.createElement(_ResourceSavingScene.default, {
            key: route.key,
            style: _reactNative.StyleSheet.absoluteFill,
            isVisible: isFocused,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 157
            }
          }, renderScene({
            route: route
          }));
        })), this._renderTabBar());
      }
    }], [{
      key: "getDerivedStateFromProps",
      value: function getDerivedStateFromProps(nextProps, prevState) {
        var index = nextProps.navigation.state.index;
        return {
          loaded: prevState.loaded.includes(index) ? prevState.loaded : [].concat((0, _toConsumableArray2.default)(prevState.loaded), [index])
        };
      }
    }]);
    return TabNavigationView;
  }(React.PureComponent);

  TabNavigationView.defaultProps = {
    lazy: true,
    getAccessibilityRole: function getAccessibilityRole() {
      return 'button';
    },
    getAccessibilityStates: function getAccessibilityStates(_ref2) {
      var focused = _ref2.focused;
      return focused ? ['selected'] : [];
    }
  };

  var styles = _reactNative.StyleSheet.create({
    container: {
      flex: 1,
      overflow: 'hidden'
    },
    pages: {
      flex: 1
    }
  });

  var _default = (0, _createTabNavigator.default)(TabNavigationView);

  exports.default = _default;
},531,[9,1,20,13,24,25,32,34,37,54,2,532,533,534,596],"node_modules/react-navigation-tabs/lib/module/navigators/createBottomTabNavigator.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _extends2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/extends"));

  var _objectWithoutProperties2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/objectWithoutProperties"));

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf3 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "@babel/runtime/helpers/inherits"));

  var _react = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "react"));

  var _reactNative = _$$_REQUIRE(_dependencyMap[9], "react-native");

  var _ReactNativeVersion = _$$_REQUIRE(_dependencyMap[10], "react-native/Libraries/Core/ReactNativeVersion");

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native-screens/src/screens.native.js";
  var USE_SCREENS = false;

  var getViewManagerConfigCompat = function getViewManagerConfigCompat(name) {
    return typeof _reactNative.UIManager.getViewManagerConfig !== 'undefined' ? _reactNative.UIManager.getViewManagerConfig(name) : _reactNative.UIManager[name];
  };

  function useScreens() {
    var shouldUseScreens = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
    USE_SCREENS = shouldUseScreens;

    if (USE_SCREENS && !getViewManagerConfigCompat('RNSScreen')) {
      console.error("Screen native module hasn't been linked. Please check the react-native-screens README for more details");
    }
  }

  function screensEnabled() {
    return USE_SCREENS;
  }

  var NativeScreenValue;
  var NativeScreenContainerValue;
  var AnimatedNativeScreen;
  var ScreensNativeModules = {
    get NativeScreen() {
      NativeScreenValue = NativeScreenValue || (0, _reactNative.requireNativeComponent)('RNSScreen', null);
      return NativeScreenValue;
    },

    get NativeScreenContainer() {
      NativeScreenContainerValue = NativeScreenContainerValue || (0, _reactNative.requireNativeComponent)('RNSScreenContainer', null);
      return NativeScreenContainerValue;
    }

  };

  var Screen = function (_React$Component) {
    (0, _inherits2.default)(Screen, _React$Component);

    function Screen() {
      var _getPrototypeOf2;

      var _this;

      (0, _classCallCheck2.default)(this, Screen);

      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
        args[_key] = arguments[_key];
      }

      _this = (0, _possibleConstructorReturn2.default)(this, (_getPrototypeOf2 = (0, _getPrototypeOf3.default)(Screen)).call.apply(_getPrototypeOf2, [this].concat(args)));

      _this.setRef = function (ref) {
        _this._ref = ref;
        _this.props.onComponentRef && _this.props.onComponentRef(ref);
      };

      return _this;
    }

    (0, _createClass2.default)(Screen, [{
      key: "setNativeProps",
      value: function setNativeProps(props) {
        this._ref.setNativeProps(props);
      }
    }, {
      key: "render",
      value: function render() {
        if (!USE_SCREENS) {
          var _this$props = this.props,
              active = _this$props.active,
              onComponentRef = _this$props.onComponentRef,
              props = (0, _objectWithoutProperties2.default)(_this$props, ["active", "onComponentRef"]);
          return _react.default.createElement(_reactNative.Animated.View, (0, _extends2.default)({}, props, {
            ref: this.setRef,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 71
            }
          }));
        } else {
          AnimatedNativeScreen = AnimatedNativeScreen || _reactNative.Animated.createAnimatedComponent(ScreensNativeModules.NativeScreen);

          if (_ReactNativeVersion.version.minor >= 57) {
            return _react.default.createElement(AnimatedNativeScreen, (0, _extends2.default)({}, this.props, {
              ref: this.setRef,
              __source: {
                fileName: _jsxFileName,
                lineNumber: 78
              }
            }));
          } else {
            var _this$props2 = this.props,
                style = _this$props2.style,
                children = _this$props2.children,
                rest = (0, _objectWithoutProperties2.default)(_this$props2, ["style", "children"]);
            return _react.default.createElement(AnimatedNativeScreen, (0, _extends2.default)({}, rest, {
              ref: this.setRef,
              style: _reactNative.StyleSheet.absoluteFill,
              __source: {
                fileName: _jsxFileName,
                lineNumber: 86
              }
            }), _react.default.createElement(_reactNative.Animated.View, {
              style: style,
              __source: {
                fileName: _jsxFileName,
                lineNumber: 90
              }
            }, children));
          }
        }
      }
    }]);
    return Screen;
  }(_react.default.Component);

  var ScreenContainer = function (_React$Component2) {
    (0, _inherits2.default)(ScreenContainer, _React$Component2);

    function ScreenContainer() {
      (0, _classCallCheck2.default)(this, ScreenContainer);
      return (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf3.default)(ScreenContainer).apply(this, arguments));
    }

    (0, _createClass2.default)(ScreenContainer, [{
      key: "render",
      value: function render() {
        if (!USE_SCREENS) {
          return _react.default.createElement(_reactNative.View, (0, _extends2.default)({}, this.props, {
            __source: {
              fileName: _jsxFileName,
              lineNumber: 101
            }
          }));
        } else {
          return _react.default.createElement(ScreensNativeModules.NativeScreenContainer, (0, _extends2.default)({}, this.props, {
            __source: {
              fileName: _jsxFileName,
              lineNumber: 103
            }
          }));
        }
      }
    }]);
    return ScreenContainer;
  }(_react.default.Component);

  module.exports = {
    ScreenContainer: ScreenContainer,
    Screen: Screen,

    get NativeScreen() {
      return ScreensNativeModules.NativeScreen;
    },

    get NativeScreenContainer() {
      return ScreensNativeModules.NativeScreenContainer;
    },

    useScreens: useScreens,
    screensEnabled: screensEnabled
  };
},532,[1,13,52,24,25,32,34,37,54,2,178],"node_modules/react-native-screens/src/screens.native.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireWildcard");

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = createTabNavigator;

  var _extends2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/extends"));

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf3 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "@babel/runtime/helpers/inherits"));

  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[8], "react"));

  var _reactNavigation = _$$_REQUIRE(_dependencyMap[9], "react-navigation");

  var _jsxFileName = "/Users/satya/Workspace/Callstack/react-navigation-tabs/src/utils/createTabNavigator.tsx";

  function createTabNavigator(TabView) {
    var NavigationView = function (_React$Component) {
      (0, _inherits2.default)(NavigationView, _React$Component);

      function NavigationView() {
        var _getPrototypeOf2;

        var _this;

        (0, _classCallCheck2.default)(this, NavigationView);

        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
          args[_key] = arguments[_key];
        }

        _this = (0, _possibleConstructorReturn2.default)(this, (_getPrototypeOf2 = (0, _getPrototypeOf3.default)(NavigationView)).call.apply(_getPrototypeOf2, [this].concat(args)));

        _this._renderScene = function (_ref) {
          var route = _ref.route;
          var _this$props = _this.props,
              screenProps = _this$props.screenProps,
              descriptors = _this$props.descriptors;
          var descriptor = descriptors[route.key];
          var TabComponent = descriptor.getComponent();
          return React.createElement(_reactNavigation.SceneView, {
            screenProps: screenProps,
            navigation: descriptor.navigation,
            component: TabComponent,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 67
            }
          });
        };

        _this._renderIcon = function (_ref2) {
          var route = _ref2.route,
              focused = _ref2.focused,
              tintColor = _ref2.tintColor,
              _ref2$horizontal = _ref2.horizontal,
              horizontal = _ref2$horizontal === void 0 ? false : _ref2$horizontal;
          var descriptors = _this.props.descriptors;
          var descriptor = descriptors[route.key];
          var options = descriptor.options;

          if (options.tabBarIcon) {
            return typeof options.tabBarIcon === 'function' ? options.tabBarIcon({
              focused: focused,
              tintColor: tintColor,
              horizontal: horizontal
            }) : options.tabBarIcon;
          }

          return null;
        };

        _this._getLabelText = function (_ref3) {
          var route = _ref3.route;
          var descriptors = _this.props.descriptors;
          var descriptor = descriptors[route.key];
          var options = descriptor.options;

          if (options.tabBarLabel) {
            return options.tabBarLabel;
          }

          if (typeof options.title === 'string') {
            return options.title;
          }

          return route.routeName;
        };

        _this._getAccessibilityLabel = function (_ref4) {
          var route = _ref4.route;
          var descriptors = _this.props.descriptors;
          var descriptor = descriptors[route.key];
          var options = descriptor.options;

          if (typeof options.tabBarAccessibilityLabel !== 'undefined') {
            return options.tabBarAccessibilityLabel;
          }

          var label = _this._getLabelText({
            route: route
          });

          if (typeof label === 'string') {
            var routes = _this.props.navigation.state.routes;
            return label + ", tab, " + (routes.indexOf(route) + 1) + " of " + routes.length;
          }

          return undefined;
        };

        _this._getTestID = function (_ref5) {
          var route = _ref5.route;
          var descriptors = _this.props.descriptors;
          var descriptor = descriptors[route.key];
          var options = descriptor.options;
          return options.tabBarTestID;
        };

        _this._makeDefaultHandler = function (_ref6) {
          var route = _ref6.route,
              navigation = _ref6.navigation;
          return function () {
            if (navigation.isFocused()) {
              if (route.hasOwnProperty('index') && route.index > 0) {
                navigation.dispatch(_reactNavigation.StackActions.popToTop({
                  key: route.key
                }));
              } else {
                navigation.emit('refocus');
              }
            } else {
              _this._jumpTo(route.routeName);
            }
          };
        };

        _this._handleTabPress = function (_ref7) {
          var route = _ref7.route;
          _this._isTabPress = true;
          Promise.resolve().then(function () {
            return _this._isTabPress = false;
          });
          var descriptors = _this.props.descriptors;
          var descriptor = descriptors[route.key];
          var navigation = descriptor.navigation,
              options = descriptor.options;

          var defaultHandler = _this._makeDefaultHandler({
            route: route,
            navigation: navigation
          });

          if (options.tabBarOnPress) {
            options.tabBarOnPress({
              navigation: navigation,
              defaultHandler: defaultHandler
            });
          } else {
            defaultHandler();
          }
        };

        _this._handleTabLongPress = function (_ref8) {
          var route = _ref8.route;
          var descriptors = _this.props.descriptors;
          var descriptor = descriptors[route.key];
          var navigation = descriptor.navigation,
              options = descriptor.options;

          var defaultHandler = _this._makeDefaultHandler({
            route: route,
            navigation: navigation
          });

          if (options.tabBarOnLongPress) {
            options.tabBarOnLongPress({
              navigation: navigation,
              defaultHandler: defaultHandler
            });
          } else {
            defaultHandler();
          }
        };

        _this._handleIndexChange = function (index) {
          if (_this._isTabPress) {
            _this._isTabPress = false;
            return;
          }

          _this._jumpTo(_this.props.navigation.state.routes[index].routeName);
        };

        _this._jumpTo = function (routeName) {
          var navigation = _this.props.navigation;
          navigation.dispatch(_reactNavigation.SwitchActions.jumpTo({
            routeName: routeName,
            key: navigation.state.key
          }));
        };

        _this._isTabPress = false;
        return _this;
      }

      (0, _createClass2.default)(NavigationView, [{
        key: "render",
        value: function render() {
          var _this$props2 = this.props,
              descriptors = _this$props2.descriptors,
              navigation = _this$props2.navigation,
              screenProps = _this$props2.screenProps,
              navigationConfig = _this$props2.navigationConfig;
          var state = navigation.state;
          var route = state.routes[state.index];
          var descriptor = descriptors[route.key];
          return React.createElement(TabView, (0, _extends2.default)({}, navigationConfig, descriptor.options, {
            getLabelText: this._getLabelText,
            getAccessibilityLabel: this._getAccessibilityLabel,
            getTestID: this._getTestID,
            renderIcon: this._renderIcon,
            renderScene: this._renderScene,
            onIndexChange: this._handleIndexChange,
            onTabPress: this._handleTabPress,
            onTabLongPress: this._handleTabLongPress,
            navigation: navigation,
            descriptors: descriptors,
            screenProps: screenProps,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 228
            }
          }));
        }
      }]);
      return NavigationView;
    }(React.Component);

    return function (routes) {
      var config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
      var router = (0, _reactNavigation.TabRouter)(routes, config);
      return (0, _reactNavigation.createNavigator)(NavigationView, router, config);
    };
  }
},533,[9,1,13,24,25,32,34,37,54,448],"node_modules/react-navigation-tabs/lib/module/utils/createTabNavigator.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _objectSpread2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/objectSpread"));

  var _extends2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/extends"));

  var _objectWithoutProperties2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/objectWithoutProperties"));

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf3 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "@babel/runtime/helpers/inherits"));

  var _react = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "react"));

  var _reactNative = _$$_REQUIRE(_dependencyMap[10], "react-native");

  var _reactNativeSafeAreaView = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[11], "react-native-safe-area-view"));

  var _reactNavigation = _$$_REQUIRE(_dependencyMap[12], "react-navigation");

  var _CrossFadeIcon = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[13], "./CrossFadeIcon"));

  var _withDimensions = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[14], "../utils/withDimensions"));

  var _jsxFileName = "/Users/satya/Workspace/Callstack/react-navigation-tabs/src/views/BottomTabBar.tsx";
  var majorVersion = parseInt(_reactNative.Platform.Version, 10);
  var isIos = _reactNative.Platform.OS === 'ios';
  var isIOS11 = majorVersion >= 11 && isIos;
  var DEFAULT_MAX_TAB_ITEM_WIDTH = 125;
  var DEFAULT_KEYBOARD_ANIMATION_CONFIG = {
    show: {
      animation: 'timing',
      config: {
        useNativeDriver: true,
        duration: 150
      }
    },
    hide: {
      animation: 'timing',
      config: {
        useNativeDriver: true,
        duration: 100
      }
    }
  };

  var TouchableWithoutFeedbackWrapper = function (_React$Component) {
    (0, _inherits2.default)(TouchableWithoutFeedbackWrapper, _React$Component);

    function TouchableWithoutFeedbackWrapper() {
      (0, _classCallCheck2.default)(this, TouchableWithoutFeedbackWrapper);
      return (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf3.default)(TouchableWithoutFeedbackWrapper).apply(this, arguments));
    }

    (0, _createClass2.default)(TouchableWithoutFeedbackWrapper, [{
      key: "render",
      value: function render() {
        var _this$props = this.props,
            route = _this$props.route,
            focused = _this$props.focused,
            onPress = _this$props.onPress,
            onLongPress = _this$props.onLongPress,
            testID = _this$props.testID,
            accessibilityLabel = _this$props.accessibilityLabel,
            accessibilityRole = _this$props.accessibilityRole,
            accessibilityStates = _this$props.accessibilityStates,
            rest = (0, _objectWithoutProperties2.default)(_this$props, ["route", "focused", "onPress", "onLongPress", "testID", "accessibilityLabel", "accessibilityRole", "accessibilityStates"]);
        return _react.default.createElement(_reactNative.TouchableWithoutFeedback, {
          onPress: onPress,
          onLongPress: onLongPress,
          testID: testID,
          hitSlop: {
            left: 15,
            right: 15,
            top: 0,
            bottom: 5
          },
          accessibilityLabel: accessibilityLabel,
          accessibilityRole: accessibilityRole,
          accessibilityStates: accessibilityStates,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 70
          }
        }, _react.default.createElement(_reactNative.View, (0, _extends2.default)({}, rest, {
          __source: {
            fileName: _jsxFileName,
            lineNumber: 79
          }
        })));
      }
    }]);
    return TouchableWithoutFeedbackWrapper;
  }(_react.default.Component);

  var TabBarBottom = function (_React$Component2) {
    (0, _inherits2.default)(TabBarBottom, _React$Component2);

    function TabBarBottom() {
      var _getPrototypeOf2;

      var _this;

      (0, _classCallCheck2.default)(this, TabBarBottom);

      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
        args[_key] = arguments[_key];
      }

      _this = (0, _possibleConstructorReturn2.default)(this, (_getPrototypeOf2 = (0, _getPrototypeOf3.default)(TabBarBottom)).call.apply(_getPrototypeOf2, [this].concat(args)));
      _this.state = {
        layout: {
          height: 0,
          width: 0
        },
        keyboard: false,
        visible: new _reactNative.Animated.Value(1)
      };

      _this._getKeyboardAnimationConfigByType = function (type) {
        var keyboardHidesTabBarAnimationConfig = _this.props.keyboardHidesTabBarAnimationConfig;
        var defaultKeyboardAnimationConfig = DEFAULT_KEYBOARD_ANIMATION_CONFIG[type];
        var keyboardAnimationConfig = keyboardHidesTabBarAnimationConfig && keyboardHidesTabBarAnimationConfig[type] || defaultKeyboardAnimationConfig;

        if (keyboardAnimationConfig && keyboardAnimationConfig.animation === 'timing') {
          return (0, _objectSpread2.default)({}, defaultKeyboardAnimationConfig, keyboardAnimationConfig, {
            config: (0, _objectSpread2.default)({}, defaultKeyboardAnimationConfig.config, keyboardAnimationConfig.config)
          });
        }

        return keyboardAnimationConfig;
      };

      _this._handleKeyboardShow = function () {
        _this.setState({
          keyboard: true
        }, function () {
          var _this$_getKeyboardAni = _this._getKeyboardAnimationConfigByType('show'),
              animation = _this$_getKeyboardAni.animation,
              config = _this$_getKeyboardAni.config;

          _reactNative.Animated[animation](_this.state.visible, (0, _objectSpread2.default)({
            toValue: 0
          }, config)).start();
        });
      };

      _this._handleKeyboardHide = function () {
        var _this$_getKeyboardAni2 = _this._getKeyboardAnimationConfigByType('hide'),
            animation = _this$_getKeyboardAni2.animation,
            config = _this$_getKeyboardAni2.config;

        _reactNative.Animated[animation](_this.state.visible, (0, _objectSpread2.default)({
          toValue: 1
        }, config)).start(function () {
          _this.setState({
            keyboard: false
          });
        });
      };

      _this._handleLayout = function (e) {
        var layout = _this.state.layout;
        var _e$nativeEvent$layout = e.nativeEvent.layout,
            height = _e$nativeEvent$layout.height,
            width = _e$nativeEvent$layout.width;

        if (height === layout.height && width === layout.width) {
          return;
        }

        _this.setState({
          layout: {
            height: height,
            width: width
          }
        });
      };

      _this._getActiveTintColor = function () {
        var activeTintColor = _this.props.activeTintColor;

        if (!activeTintColor) {
          return;
        } else if (typeof activeTintColor === 'string') {
          return activeTintColor;
        }

        return activeTintColor[_this.context];
      };

      _this._getInactiveTintColor = function () {
        var inactiveTintColor = _this.props.inactiveTintColor;

        if (!inactiveTintColor) {
          return;
        } else if (typeof inactiveTintColor === 'string') {
          return inactiveTintColor;
        }

        return inactiveTintColor[_this.context];
      };

      _this._getActiveBackgroundColor = function () {
        var activeBackgroundColor = _this.props.activeBackgroundColor;

        if (!activeBackgroundColor) {
          return;
        } else if (typeof activeBackgroundColor === 'string') {
          return activeBackgroundColor;
        }

        return activeBackgroundColor[_this.context];
      };

      _this._getInactiveBackgroundColor = function () {
        var inactiveBackgroundColor = _this.props.inactiveBackgroundColor;

        if (!inactiveBackgroundColor) {
          return;
        } else if (typeof inactiveBackgroundColor === 'string') {
          return inactiveBackgroundColor;
        }

        return inactiveBackgroundColor[_this.context];
      };

      _this._renderLabel = function (_ref) {
        var route = _ref.route,
            focused = _ref.focused;
        var _this$props2 = _this.props,
            labelStyle = _this$props2.labelStyle,
            showLabel = _this$props2.showLabel,
            showIcon = _this$props2.showIcon,
            allowFontScaling = _this$props2.allowFontScaling;

        if (showLabel === false) {
          return null;
        }

        var activeTintColor = _this._getActiveTintColor();

        var inactiveTintColor = _this._getInactiveTintColor();

        var label = _this.props.getLabelText({
          route: route
        });

        var tintColor = focused ? activeTintColor : inactiveTintColor;

        var horizontal = _this._shouldUseHorizontalLabels();

        if (typeof label === 'string') {
          return _react.default.createElement(_reactNative.Animated.Text, {
            numberOfLines: 1,
            style: [styles.label, {
              color: tintColor
            }, showIcon && horizontal ? styles.labelBeside : styles.labelBeneath, labelStyle],
            allowFontScaling: allowFontScaling,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 274
            }
          }, label);
        }

        if (typeof label === 'function') {
          return label({
            focused: focused,
            tintColor: tintColor,
            orientation: horizontal ? 'horizontal' : 'vertical'
          });
        }

        return label;
      };

      _this._renderIcon = function (_ref2) {
        var route = _ref2.route,
            focused = _ref2.focused;
        var _this$props3 = _this.props,
            renderIcon = _this$props3.renderIcon,
            showIcon = _this$props3.showIcon,
            showLabel = _this$props3.showLabel;

        if (showIcon === false) {
          return null;
        }

        var horizontal = _this._shouldUseHorizontalLabels();

        var activeTintColor = _this._getActiveTintColor();

        var inactiveTintColor = _this._getInactiveTintColor();

        var activeOpacity = focused ? 1 : 0;
        var inactiveOpacity = focused ? 0 : 1;
        return _react.default.createElement(_CrossFadeIcon.default, {
          route: route,
          horizontal: horizontal,
          activeOpacity: activeOpacity,
          inactiveOpacity: inactiveOpacity,
          activeTintColor: activeTintColor,
          inactiveTintColor: inactiveTintColor,
          renderIcon: renderIcon,
          style: [styles.iconWithExplicitHeight, showLabel === false && !horizontal && styles.iconWithoutLabel, showLabel !== false && !horizontal && styles.iconWithLabel],
          __source: {
            fileName: _jsxFileName,
            lineNumber: 321
          }
        });
      };

      _this._shouldUseHorizontalLabels = function () {
        var routes = _this.props.navigation.state.routes;
        var _this$props4 = _this.props,
            isLandscape = _this$props4.isLandscape,
            dimensions = _this$props4.dimensions,
            adaptive = _this$props4.adaptive,
            tabStyle = _this$props4.tabStyle,
            labelPosition = _this$props4.labelPosition;

        if (labelPosition) {
          var position;

          if (typeof labelPosition === 'string') {
            position = labelPosition;
          } else {
            position = labelPosition({
              deviceOrientation: isLandscape ? 'horizontal' : 'vertical'
            });
          }

          if (position) {
            return position === 'beside-icon';
          }
        }

        if (!adaptive) {
          return false;
        }

        if (_reactNative.Platform.isPad) {
          var maxTabItemWidth = DEFAULT_MAX_TAB_ITEM_WIDTH;

          var flattenedStyle = _reactNative.StyleSheet.flatten(tabStyle);

          if (flattenedStyle) {
            if (typeof flattenedStyle.width === 'number') {
              maxTabItemWidth = flattenedStyle.width;
            } else if (typeof flattenedStyle.maxWidth === 'number') {
              maxTabItemWidth = flattenedStyle.maxWidth;
            }
          }

          return routes.length * maxTabItemWidth <= dimensions.width;
        } else {
          return isLandscape;
        }
      };

      return _this;
    }

    (0, _createClass2.default)(TabBarBottom, [{
      key: "componentDidMount",
      value: function componentDidMount() {
        if (_reactNative.Platform.OS === 'ios') {
          _reactNative.Keyboard.addListener('keyboardWillShow', this._handleKeyboardShow);

          _reactNative.Keyboard.addListener('keyboardWillHide', this._handleKeyboardHide);
        } else {
          _reactNative.Keyboard.addListener('keyboardDidShow', this._handleKeyboardShow);

          _reactNative.Keyboard.addListener('keyboardDidHide', this._handleKeyboardHide);
        }
      }
    }, {
      key: "componentWillUnmount",
      value: function componentWillUnmount() {
        if (_reactNative.Platform.OS === 'ios') {
          _reactNative.Keyboard.removeListener('keyboardWillShow', this._handleKeyboardShow);

          _reactNative.Keyboard.removeListener('keyboardWillHide', this._handleKeyboardHide);
        } else {
          _reactNative.Keyboard.removeListener('keyboardDidShow', this._handleKeyboardShow);

          _reactNative.Keyboard.removeListener('keyboardDidHide', this._handleKeyboardHide);
        }
      }
    }, {
      key: "render",
      value: function render() {
        var _this2 = this;

        var _this$props5 = this.props,
            navigation = _this$props5.navigation,
            keyboardHidesTabBar = _this$props5.keyboardHidesTabBar,
            onTabPress = _this$props5.onTabPress,
            onTabLongPress = _this$props5.onTabLongPress,
            safeAreaInset = _this$props5.safeAreaInset,
            style = _this$props5.style,
            tabStyle = _this$props5.tabStyle;
        var routes = navigation.state.routes;
        var isDark = this.context === 'dark';

        var activeBackgroundColor = this._getActiveBackgroundColor();

        var inactiveBackgroundColor = this._getInactiveBackgroundColor();

        var _StyleSheet$flatten = _reactNative.StyleSheet.flatten(style || {}),
            position = _StyleSheet$flatten.position,
            top = _StyleSheet$flatten.top,
            _StyleSheet$flatten$l = _StyleSheet$flatten.left,
            left = _StyleSheet$flatten$l === void 0 ? 0 : _StyleSheet$flatten$l,
            _StyleSheet$flatten$b = _StyleSheet$flatten.bottom,
            bottom = _StyleSheet$flatten$b === void 0 ? 0 : _StyleSheet$flatten$b,
            _StyleSheet$flatten$r = _StyleSheet$flatten.right,
            right = _StyleSheet$flatten$r === void 0 ? 0 : _StyleSheet$flatten$r,
            margin = _StyleSheet$flatten.margin,
            marginTop = _StyleSheet$flatten.marginTop,
            marginLeft = _StyleSheet$flatten.marginLeft,
            marginBottom = _StyleSheet$flatten.marginBottom,
            marginRight = _StyleSheet$flatten.marginRight,
            marginHorizontal = _StyleSheet$flatten.marginHorizontal,
            marginVertical = _StyleSheet$flatten.marginVertical,
            innerStyle = (0, _objectWithoutProperties2.default)(_StyleSheet$flatten, ["position", "top", "left", "bottom", "right", "margin", "marginTop", "marginLeft", "marginBottom", "marginRight", "marginHorizontal", "marginVertical"]);

        var containerStyle = {
          position: position,
          top: top,
          left: left,
          bottom: bottom,
          right: right,
          margin: margin,
          marginTop: marginTop,
          marginLeft: marginLeft,
          marginBottom: marginBottom,
          marginRight: marginRight,
          marginHorizontal: marginHorizontal,
          marginVertical: marginVertical
        };
        var tabBarStyle = [styles.tabBar, isDark ? styles.tabBarDark : styles.tabBarLight, this._shouldUseHorizontalLabels() && !_reactNative.Platform.isPad ? styles.tabBarCompact : styles.tabBarRegular, innerStyle];
        return _react.default.createElement(_reactNative.Animated.View, {
          style: [styles.container, containerStyle, keyboardHidesTabBar ? {
            transform: [{
              translateY: this.state.visible.interpolate({
                inputRange: [0, 1],
                outputRange: [this.state.layout.height, 0]
              })
            }],
            position: this.state.keyboard ? 'absolute' : position
          } : null],
          pointerEvents: keyboardHidesTabBar && this.state.keyboard ? 'none' : 'auto',
          onLayout: this._handleLayout,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 446
          }
        }, _react.default.createElement(_reactNativeSafeAreaView.default, {
          style: tabBarStyle,
          forceInset: safeAreaInset,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 472
          }
        }, routes.map(function (route, index) {
          var focused = index === navigation.state.index;
          var scene = {
            route: route,
            focused: focused
          };

          var accessibilityLabel = _this2.props.getAccessibilityLabel({
            route: route
          });

          var accessibilityRole = _this2.props.getAccessibilityRole({
            route: route
          });

          var accessibilityStates = _this2.props.getAccessibilityStates(scene);

          var testID = _this2.props.getTestID({
            route: route
          });

          var backgroundColor = focused ? activeBackgroundColor : inactiveBackgroundColor;
          var ButtonComponent = _this2.props.getButtonComponent({
            route: route
          }) || TouchableWithoutFeedbackWrapper;
          return _react.default.createElement(ButtonComponent, {
            key: route.key,
            route: route,
            focused: focused,
            onPress: function onPress() {
              return onTabPress({
                route: route
              });
            },
            onLongPress: function onLongPress() {
              return onTabLongPress({
                route: route
              });
            },
            testID: testID,
            accessibilityLabel: accessibilityLabel,
            accessibilityRole: accessibilityRole,
            accessibilityStates: accessibilityStates,
            style: [styles.tab, {
              backgroundColor: backgroundColor
            }, _this2._shouldUseHorizontalLabels() ? styles.tabLandscape : styles.tabPortrait, tabStyle],
            __source: {
              fileName: _jsxFileName,
              lineNumber: 499
            }
          }, _this2._renderIcon(scene), _this2._renderLabel(scene));
        })));
      }
    }]);
    return TabBarBottom;
  }(_react.default.Component);

  TabBarBottom.defaultProps = {
    keyboardHidesTabBar: true,
    keyboardHidesTabBarAnimationConfig: DEFAULT_KEYBOARD_ANIMATION_CONFIG,
    activeTintColor: {
      light: '#007AFF',
      dark: '#fff'
    },
    inactiveTintColor: {
      light: '#8e8e93',
      dark: '#7f7f7f'
    },
    activeBackgroundColor: 'transparent',
    inactiveBackgroundColor: 'transparent',
    showLabel: true,
    showIcon: true,
    allowFontScaling: true,
    adaptive: isIOS11,
    safeAreaInset: {
      bottom: 'always',
      top: 'never'
    }
  };
  TabBarBottom.contextType = _reactNavigation.ThemeContext;
  var DEFAULT_HEIGHT = 49;
  var COMPACT_HEIGHT = 29;

  var styles = _reactNative.StyleSheet.create({
    tabBar: {
      borderTopWidth: _reactNative.StyleSheet.hairlineWidth,
      flexDirection: 'row'
    },
    tabBarLight: {
      backgroundColor: _reactNavigation.ThemeColors.light.header,
      borderTopColor: _reactNavigation.ThemeColors.light.headerBorder
    },
    tabBarDark: {
      backgroundColor: _reactNavigation.ThemeColors.dark.header,
      borderTopColor: _reactNavigation.ThemeColors.dark.headerBorder
    },
    container: {
      elevation: 8
    },
    tabBarCompact: {
      height: COMPACT_HEIGHT
    },
    tabBarRegular: {
      height: DEFAULT_HEIGHT
    },
    tab: {
      flex: 1,
      alignItems: isIos ? 'center' : 'stretch'
    },
    tabPortrait: {
      justifyContent: 'flex-end',
      flexDirection: 'column'
    },
    tabLandscape: {
      justifyContent: 'center',
      flexDirection: 'row'
    },
    iconWithoutLabel: {
      flex: 1
    },
    iconWithLabel: {
      flex: 1
    },
    iconWithExplicitHeight: {
      height: _reactNative.Platform.isPad ? DEFAULT_HEIGHT : COMPACT_HEIGHT
    },
    label: {
      textAlign: 'center',
      backgroundColor: 'transparent'
    },
    labelBeneath: {
      fontSize: 11,
      marginBottom: 1.5
    },
    labelBeside: {
      fontSize: 12,
      marginLeft: 20
    }
  });

  var _default = (0, _withDimensions.default)(TabBarBottom);

  exports.default = _default;
},534,[1,451,13,52,24,25,32,34,37,54,2,499,448,535,595],"node_modules/react-navigation-tabs/lib/module/views/BottomTabBar.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits"));

  var _react = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "react"));

  var _reactNative = _$$_REQUIRE(_dependencyMap[7], "react-native");

  var _reactNativeReanimated = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "react-native-reanimated"));

  var _jsxFileName = "/Users/satya/Workspace/Callstack/react-navigation-tabs/src/views/CrossFadeIcon.tsx";

  var TabBarIcon = function (_React$Component) {
    (0, _inherits2.default)(TabBarIcon, _React$Component);

    function TabBarIcon() {
      (0, _classCallCheck2.default)(this, TabBarIcon);
      return (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(TabBarIcon).apply(this, arguments));
    }

    (0, _createClass2.default)(TabBarIcon, [{
      key: "render",
      value: function render() {
        var _this$props = this.props,
            route = _this$props.route,
            activeOpacity = _this$props.activeOpacity,
            inactiveOpacity = _this$props.inactiveOpacity,
            activeTintColor = _this$props.activeTintColor,
            inactiveTintColor = _this$props.inactiveTintColor,
            renderIcon = _this$props.renderIcon,
            horizontal = _this$props.horizontal,
            style = _this$props.style;
        return _react.default.createElement(_reactNative.View, {
          style: style,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 38
          }
        }, _react.default.createElement(_reactNativeReanimated.default.View, {
          style: [styles.icon, {
            opacity: activeOpacity
          }],
          __source: {
            fileName: _jsxFileName,
            lineNumber: 39
          }
        }, renderIcon({
          route: route,
          focused: true,
          horizontal: horizontal,
          tintColor: activeTintColor
        })), _react.default.createElement(_reactNativeReanimated.default.View, {
          style: [styles.icon, {
            opacity: inactiveOpacity
          }],
          __source: {
            fileName: _jsxFileName,
            lineNumber: 47
          }
        }, renderIcon({
          route: route,
          focused: false,
          horizontal: horizontal,
          tintColor: inactiveTintColor
        })));
      }
    }]);
    return TabBarIcon;
  }(_react.default.Component);

  exports.default = TabBarIcon;

  var styles = _reactNative.StyleSheet.create({
    icon: {
      position: 'absolute',
      alignSelf: 'center',
      alignItems: 'center',
      justifyContent: 'center',
      height: '100%',
      width: '100%',
      minWidth: 25
    }
  });
},535,[1,24,25,32,34,37,54,2,536],"node_modules/react-navigation-tabs/lib/module/views/CrossFadeIcon.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireWildcard");

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  var _exportNames = {
    decay: true,
    timing: true,
    spring: true,
    Easing: true,
    Clock: true,
    Value: true,
    Node: true,
    Transition: true,
    Transitioning: true,
    createTransitioningComponent: true,
    SpringUtils: true
  };
  Object.defineProperty(exports, "Easing", {
    enumerable: true,
    get: function get() {
      return _Easing.default;
    }
  });
  Object.defineProperty(exports, "Clock", {
    enumerable: true,
    get: function get() {
      return _AnimatedClock.default;
    }
  });
  Object.defineProperty(exports, "Value", {
    enumerable: true,
    get: function get() {
      return _AnimatedValue.default;
    }
  });
  Object.defineProperty(exports, "Node", {
    enumerable: true,
    get: function get() {
      return _AnimatedNode.default;
    }
  });
  Object.defineProperty(exports, "Transition", {
    enumerable: true,
    get: function get() {
      return _Transitioning.Transition;
    }
  });
  Object.defineProperty(exports, "Transitioning", {
    enumerable: true,
    get: function get() {
      return _Transitioning.Transitioning;
    }
  });
  Object.defineProperty(exports, "createTransitioningComponent", {
    enumerable: true,
    get: function get() {
      return _Transitioning.createTransitioningComponent;
    }
  });
  Object.defineProperty(exports, "SpringUtils", {
    enumerable: true,
    get: function get() {
      return _SpringUtils.default;
    }
  });
  exports.spring = exports.timing = exports.decay = exports.default = void 0;

  var _defineProperty2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/defineProperty"));

  var _reactNative = _$$_REQUIRE(_dependencyMap[3], "react-native");

  var _Easing = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "./Easing"));

  var _AnimatedClock = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "./core/AnimatedClock"));

  var _AnimatedValue = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "./core/AnimatedValue"));

  var _AnimatedNode = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "./core/AnimatedNode"));

  var _AnimatedCode = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "./core/AnimatedCode"));

  var base = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[9], "./base"));

  Object.keys(base).forEach(function (key) {
    if (key === "default" || key === "__esModule") return;
    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
    Object.defineProperty(exports, key, {
      enumerable: true,
      get: function get() {
        return base[key];
      }
    });
  });

  var derived = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[10], "./derived"));

  Object.keys(derived).forEach(function (key) {
    if (key === "default" || key === "__esModule") return;
    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
    Object.defineProperty(exports, key, {
      enumerable: true,
      get: function get() {
        return derived[key];
      }
    });
  });

  var _createAnimatedComponent = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[11], "./createAnimatedComponent"));

  var _decay = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[12], "./animations/decay"));

  var _timing = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[13], "./animations/timing"));

  var _spring = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[14], "./animations/spring"));

  var _TimingAnimation = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[15], "./animations/TimingAnimation"));

  var _SpringAnimation = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[16], "./animations/SpringAnimation"));

  var _DecayAnimation = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[17], "./animations/DecayAnimation"));

  var _ConfigHelper = _$$_REQUIRE(_dependencyMap[18], "./ConfigHelper");

  var _backwardCompatibleAnimWrapper = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[19], "./animations/backwardCompatibleAnimWrapper"));

  var _Transitioning = _$$_REQUIRE(_dependencyMap[20], "./Transitioning");

  var _SpringUtils = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[21], "./animations/SpringUtils"));

  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

  var decayWrapper = (0, _backwardCompatibleAnimWrapper.default)(_decay.default, _DecayAnimation.default);
  exports.decay = decayWrapper;
  var timingWrapper = (0, _backwardCompatibleAnimWrapper.default)(_timing.default, _TimingAnimation.default);
  exports.timing = timingWrapper;
  var springWrapper = (0, _backwardCompatibleAnimWrapper.default)(_spring.default, _SpringAnimation.default);
  exports.spring = springWrapper;

  var Animated = _objectSpread({
    View: (0, _createAnimatedComponent.default)(_reactNative.View),
    Text: (0, _createAnimatedComponent.default)(_reactNative.Text),
    Image: (0, _createAnimatedComponent.default)(_reactNative.Image),
    ScrollView: (0, _createAnimatedComponent.default)(_reactNative.ScrollView),
    Code: _AnimatedCode.default,
    createAnimatedComponent: _createAnimatedComponent.default,
    Clock: _AnimatedClock.default,
    Value: _AnimatedValue.default,
    Node: _AnimatedNode.default
  }, base, {}, derived, {
    decay: decayWrapper,
    timing: timingWrapper,
    spring: springWrapper,
    SpringUtils: _SpringUtils.default,
    addWhitelistedNativeProps: _ConfigHelper.addWhitelistedNativeProps,
    addWhitelistedUIProps: _ConfigHelper.addWhitelistedUIProps
  });

  var _default = Animated;
  exports.default = _default;
},536,[9,1,46,2,537,547,555,542,566,538,567,579,583,584,585,586,588,590,591,592,593,594],"node_modules/react-native-reanimated/src/Animated.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));

  var _base = _$$_REQUIRE(_dependencyMap[3], "./base");

  var _AnimatedBezier = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "./core/AnimatedBezier"));

  var Easing = function () {
    function Easing() {
      (0, _classCallCheck2.default)(this, Easing);
    }

    (0, _createClass2.default)(Easing, null, [{
      key: "linear",
      value: function linear(t) {
        return t;
      }
    }, {
      key: "ease",
      value: function ease(t) {
        return new _AnimatedBezier.default(t, 0.42, 0, 1, 1);
      }
    }, {
      key: "quad",
      value: function quad(t) {
        return (0, _base.multiply)(t, t);
      }
    }, {
      key: "cubic",
      value: function cubic(t) {
        return (0, _base.multiply)(t, t, t);
      }
    }, {
      key: "poly",
      value: function poly(n) {
        return function (t) {
          return (0, _base.pow)(t, n);
        };
      }
    }, {
      key: "sin",
      value: function sin(t) {
        return (0, _base.sub)(1, (0, _base.cos)((0, _base.multiply)(t, Math.PI, 0.5)));
      }
    }, {
      key: "circle",
      value: function circle(t) {
        return (0, _base.sub)(1, (0, _base.sqrt)((0, _base.sub)(1, (0, _base.multiply)(t, t))));
      }
    }, {
      key: "exp",
      value: function exp(t) {
        return (0, _base.pow)(2, (0, _base.multiply)(10, (0, _base.sub)(t, 1)));
      }
    }, {
      key: "elastic",
      value: function elastic() {
        var bounciness = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1;
        var p = bounciness * Math.PI;
        return function (t) {
          return (0, _base.sub)(1, (0, _base.multiply)((0, _base.pow)((0, _base.cos)((0, _base.multiply)(t, Math.PI, 0.5)), 3), (0, _base.cos)((0, _base.multiply)(t, p))));
        };
      }
    }, {
      key: "back",
      value: function back(s) {
        if (s === undefined) {
          s = 1.70158;
        }

        return function (t) {
          return (0, _base.multiply)(t, t, (0, _base.sub)((0, _base.multiply)((0, _base.add)(s, 1), t), s));
        };
      }
    }, {
      key: "bounce",
      value: function bounce(t) {
        var sq = function sq(v) {
          return (0, _base.multiply)(7.5625, v, v);
        };

        return (0, _base.cond)((0, _base.lessThan)(t, 1 / 2.75), sq(t), (0, _base.cond)((0, _base.lessThan)(t, 2 / 2.75), (0, _base.add)(0.75, sq((0, _base.sub)(t, 1.5 / 2.75))), (0, _base.cond)((0, _base.lessThan)(t, 2.5 / 2.76), (0, _base.add)(0.9375, sq((0, _base.sub)(t, 2.25 / 2.75))), (0, _base.add)(0.984375, sq((0, _base.sub)(t, 2.625 / 2.75))))));
      }
    }, {
      key: "bezier",
      value: function bezier(x1, y1, x2, y2) {
        return function (t) {
          return new _AnimatedBezier.default(t, x1, y1, x2, y2);
        };
      }
    }, {
      key: "in",
      value: function _in(easing) {
        return easing;
      }
    }, {
      key: "out",
      value: function out(easing) {
        return function (t) {
          return (0, _base.sub)(1, easing((0, _base.sub)(1, t)));
        };
      }
    }, {
      key: "inOut",
      value: function inOut(easing) {
        return function (t) {
          return (0, _base.cond)((0, _base.lessThan)(t, 0.5), (0, _base.divide)(easing((0, _base.multiply)(t, 2)), 2), (0, _base.sub)(1, (0, _base.divide)(easing((0, _base.multiply)((0, _base.sub)(1, t), 2)), 2)));
        };
      }
    }]);
    return Easing;
  }();

  exports.default = Easing;
},537,[1,24,25,538,565],"node_modules/react-native-reanimated/src/Easing.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  var _exportNames = {
    cond: true,
    set: true,
    startClock: true,
    stopClock: true,
    clockRunning: true,
    debug: true,
    call: true,
    event: true,
    always: true,
    concat: true,
    block: true,
    adapt: true,
    proc: true
  };
  Object.defineProperty(exports, "cond", {
    enumerable: true,
    get: function get() {
      return _AnimatedCond.createAnimatedCond;
    }
  });
  Object.defineProperty(exports, "set", {
    enumerable: true,
    get: function get() {
      return _AnimatedSet.createAnimatedSet;
    }
  });
  Object.defineProperty(exports, "startClock", {
    enumerable: true,
    get: function get() {
      return _AnimatedStartClock.createAnimatedStartClock;
    }
  });
  Object.defineProperty(exports, "stopClock", {
    enumerable: true,
    get: function get() {
      return _AnimatedStopClock.createAnimatedStopClock;
    }
  });
  Object.defineProperty(exports, "clockRunning", {
    enumerable: true,
    get: function get() {
      return _AnimatedClockTest.createAnimatedClockTest;
    }
  });
  Object.defineProperty(exports, "debug", {
    enumerable: true,
    get: function get() {
      return _AnimatedDebug.createAnimatedDebug;
    }
  });
  Object.defineProperty(exports, "call", {
    enumerable: true,
    get: function get() {
      return _AnimatedCall.createAnimatedCall;
    }
  });
  Object.defineProperty(exports, "event", {
    enumerable: true,
    get: function get() {
      return _AnimatedEvent.createAnimatedEvent;
    }
  });
  Object.defineProperty(exports, "always", {
    enumerable: true,
    get: function get() {
      return _AnimatedAlways.createAnimatedAlways;
    }
  });
  Object.defineProperty(exports, "concat", {
    enumerable: true,
    get: function get() {
      return _AnimatedConcat.createAnimatedConcat;
    }
  });
  Object.defineProperty(exports, "block", {
    enumerable: true,
    get: function get() {
      return _AnimatedBlock.createAnimatedBlock;
    }
  });
  Object.defineProperty(exports, "adapt", {
    enumerable: true,
    get: function get() {
      return _AnimatedBlock.adapt;
    }
  });
  Object.defineProperty(exports, "proc", {
    enumerable: true,
    get: function get() {
      return _AnimatedFunction.createAnimatedFunction;
    }
  });

  var _AnimatedCond = _$$_REQUIRE(_dependencyMap[0], "./core/AnimatedCond");

  var _AnimatedSet = _$$_REQUIRE(_dependencyMap[1], "./core/AnimatedSet");

  var _AnimatedStartClock = _$$_REQUIRE(_dependencyMap[2], "./core/AnimatedStartClock");

  var _AnimatedStopClock = _$$_REQUIRE(_dependencyMap[3], "./core/AnimatedStopClock");

  var _AnimatedClockTest = _$$_REQUIRE(_dependencyMap[4], "./core/AnimatedClockTest");

  var _AnimatedDebug = _$$_REQUIRE(_dependencyMap[5], "./core/AnimatedDebug");

  var _AnimatedCall = _$$_REQUIRE(_dependencyMap[6], "./core/AnimatedCall");

  var _AnimatedEvent = _$$_REQUIRE(_dependencyMap[7], "./core/AnimatedEvent");

  var _AnimatedAlways = _$$_REQUIRE(_dependencyMap[8], "./core/AnimatedAlways");

  var _AnimatedConcat = _$$_REQUIRE(_dependencyMap[9], "./core/AnimatedConcat");

  var _AnimatedBlock = _$$_REQUIRE(_dependencyMap[10], "./core/AnimatedBlock");

  var _AnimatedFunction = _$$_REQUIRE(_dependencyMap[11], "./core/AnimatedFunction");

  var _operators = _$$_REQUIRE(_dependencyMap[12], "./operators");

  Object.keys(_operators).forEach(function (key) {
    if (key === "default" || key === "__esModule") return;
    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
    Object.defineProperty(exports, key, {
      enumerable: true,
      get: function get() {
        return _operators[key];
      }
    });
  });
},538,[539,545,546,549,550,551,552,554,562,564,540,559,557],"node_modules/react-native-reanimated/src/base.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.createAnimatedCond = createAnimatedCond;

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits"));

  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "fbjs/lib/invariant"));

  var _AnimatedBlock = _$$_REQUIRE(_dependencyMap[7], "../core/AnimatedBlock");

  var _val = _$$_REQUIRE(_dependencyMap[8], "../val");

  var _AnimatedNode2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "./AnimatedNode"));

  var AnimatedCond = function (_AnimatedNode) {
    (0, _inherits2.default)(AnimatedCond, _AnimatedNode);

    function AnimatedCond(condition, ifBlock, elseBlock) {
      var _this;

      (0, _classCallCheck2.default)(this, AnimatedCond);
      (0, _invariant.default)(condition instanceof _AnimatedNode2.default, "Reanimated: Animated.cond node first argument should be of type AnimatedNode but got " + condition);
      (0, _invariant.default)(ifBlock instanceof _AnimatedNode2.default, "Reanimated: Animated.cond node second argument should be of type AnimatedNode but got " + ifBlock);
      (0, _invariant.default)(elseBlock instanceof _AnimatedNode2.default || elseBlock === undefined, "Reanimated: Animated.cond node third argument should be of type AnimatedNode or should be undefined but got " + elseBlock);
      _this = (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(AnimatedCond).call(this, {
        type: 'cond',
        cond: condition,
        ifBlock: ifBlock,
        elseBlock: elseBlock
      }, [condition, ifBlock, elseBlock]));
      _this._condition = condition;
      _this._ifBlock = ifBlock;
      _this._elseBlock = elseBlock;
      return _this;
    }

    (0, _createClass2.default)(AnimatedCond, [{
      key: "toString",
      value: function toString() {
        return "AnimatedCond, id: " + this.__nodeID;
      }
    }, {
      key: "__onEvaluate",
      value: function __onEvaluate() {
        if ((0, _val.val)(this._condition)) {
          return (0, _val.val)(this._ifBlock);
        } else {
          return this._elseBlock !== undefined ? (0, _val.val)(this._elseBlock) : undefined;
        }
      }
    }]);
    return AnimatedCond;
  }(_AnimatedNode2.default);

  function createAnimatedCond(cond, ifBlock, elseBlock) {
    return new AnimatedCond((0, _AnimatedBlock.adapt)(cond), (0, _AnimatedBlock.adapt)(ifBlock), elseBlock === undefined ? undefined : (0, _AnimatedBlock.adapt)(elseBlock));
  }
},539,[1,24,25,32,34,37,248,540,541,542],"node_modules/react-native-reanimated/src/core/AnimatedCond.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.createAnimatedBlock = createAnimatedBlock;
  exports.adapt = adapt;

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits"));

  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "fbjs/lib/invariant"));

  var _val = _$$_REQUIRE(_dependencyMap[7], "../val");

  var _AnimatedNode2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "./AnimatedNode"));

  var _InternalAnimatedValue = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "./InternalAnimatedValue"));

  var AnimatedBlock = function (_AnimatedNode) {
    (0, _inherits2.default)(AnimatedBlock, _AnimatedNode);

    function AnimatedBlock(array) {
      var _this;

      (0, _classCallCheck2.default)(this, AnimatedBlock);
      (0, _invariant.default)(array.every(function (el) {
        return el instanceof _AnimatedNode2.default;
      }), "Reanimated: Animated.block node argument should be an array with elements of type AnimatedNode. One or more of them are not AnimatedNodes");
      _this = (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(AnimatedBlock).call(this, {
        type: 'block',
        block: array
      }, array));
      _this._array = array;
      return _this;
    }

    (0, _createClass2.default)(AnimatedBlock, [{
      key: "toString",
      value: function toString() {
        return "AnimatedBlock, id: " + this.__nodeID;
      }
    }, {
      key: "__onEvaluate",
      value: function __onEvaluate() {
        var result;

        this._array.forEach(function (node) {
          result = (0, _val.val)(node);
        });

        return result;
      }
    }]);
    return AnimatedBlock;
  }(_AnimatedNode2.default);

  function createAnimatedBlock(items) {
    return adapt(items);
  }

  function nodify(v) {
    if (typeof v === 'object' && v.__isProxy) {
      if (!v.__val) {
        v.__val = new _InternalAnimatedValue.default(0);
      }

      return v.__val;
    }

    return v instanceof _AnimatedNode2.default ? v : _InternalAnimatedValue.default.valueForConstant(v);
  }

  function adapt(v) {
    return Array.isArray(v) ? new AnimatedBlock(v.map(function (node) {
      return adapt(node);
    })) : nodify(v);
  }
},540,[1,24,25,32,34,37,248,541,542,544],"node_modules/react-native-reanimated/src/core/AnimatedBlock.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.val = val;

  function val(v) {
    return v && v.__getValue ? v.__getValue() : v || 0;
  }
},541,[],"node_modules/react-native-reanimated/src/val.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.getCallID = getCallID;
  exports.setCallID = setCallID;
  exports.default = void 0;

  var _defineProperty2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/defineProperty"));

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass"));

  var _ReanimatedModule = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "../ReanimatedModule"));

  var _reactNative = _$$_REQUIRE(_dependencyMap[5], "react-native");

  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

  var UPDATED_NODES = [];
  var loopID = 1;
  var propUpdatesEnqueued = null;
  var nodeCount = 0;
  var callID = "";

  function getCallID() {
    return callID;
  }

  function setCallID(nextCallID) {
    callID = nextCallID;
  }

  function sanitizeConfig(config) {
    if (_reactNative.Platform.OS === 'web' || ['undefined', 'string', 'function', 'boolean', 'number'].includes(typeof config)) {
      return config;
    } else if (Array.isArray(config)) {
      return config.map(sanitizeConfig);
    } else if (config instanceof AnimatedNode) {
      return config.__nodeID;
    } else if (typeof config === 'object') {
      var output = {};

      for (var property in config) {
        if (property in config) {
          output[property] = sanitizeConfig(config[property]);
        }
      }

      return output;
    }

    return config;
  }

  function runPropUpdates() {
    var visitedNodes = new Set();

    var findAndUpdateNodes = function findAndUpdateNodes(node) {
      if (!node) {
        console.warn('findAndUpdateNodes was passed a nullish node');
        return;
      }

      if (visitedNodes.has(node)) {
        return;
      } else {
        visitedNodes.add(node);
      }

      if (typeof node.update === 'function') {
        node.update();
      } else {
        var nodes = node.__getChildren();

        if (nodes) {
          for (var i = 0, l = nodes.length; i < l; i++) {
            findAndUpdateNodes(nodes[i]);
          }
        }
      }
    };

    for (var i = 0; i < UPDATED_NODES.length; i++) {
      var node = UPDATED_NODES[i];
      findAndUpdateNodes(node);
    }

    UPDATED_NODES.length = 0;
    propUpdatesEnqueued = null;
    loopID += 1;
  }

  var AnimatedNode = function () {
    function AnimatedNode(nodeConfig, inputNodes) {
      (0, _classCallCheck2.default)(this, AnimatedNode);
      this.__lastLoopID = {
        "": -1
      };
      this.__memoizedValue = {
        "": null
      };
      this.__children = [];
      this.__nodeID = ++nodeCount;
      this.__nodeConfig = sanitizeConfig(nodeConfig);
      this.__initialized = false;
      this.__inputNodes = inputNodes && inputNodes.filter(function (node) {
        return node instanceof AnimatedNode;
      });
    }

    (0, _createClass2.default)(AnimatedNode, [{
      key: "toString",
      value: function toString() {
        return "AnimatedNode, id: " + this.__nodeID;
      }
    }, {
      key: "__attach",
      value: function __attach() {
        this.__nativeInitialize();

        var nodes = this.__inputNodes;

        if (nodes) {
          for (var i = 0, l = nodes.length; i < l; i++) {
            nodes[i].__addChild(this);
          }
        }
      }
    }, {
      key: "__detach",
      value: function __detach() {
        var nodes = this.__inputNodes;

        if (nodes) {
          for (var i = 0, l = nodes.length; i < l; i++) {
            nodes[i].__removeChild(this);
          }
        }

        this.__nativeTearDown();
      }
    }, {
      key: "__getValue",
      value: function __getValue() {
        if (!(callID in this.__lastLoopID) || this.__lastLoopID[callID] < loopID) {
          this.__lastLoopID[callID] = loopID;

          var result = this.__onEvaluate();

          this.__memoizedValue[callID] = result;
          return result;
        }

        return this.__memoizedValue[callID];
      }
    }, {
      key: "__forceUpdateCache",
      value: function __forceUpdateCache(newValue) {
        this.__memoizedValue[callID] = newValue;

        this.__markUpdated();
      }
    }, {
      key: "__dangerouslyRescheduleEvaluate",
      value: function __dangerouslyRescheduleEvaluate() {
        this.__lastLoopID[callID] = -1;

        this.__markUpdated();
      }
    }, {
      key: "__markUpdated",
      value: function __markUpdated() {
        UPDATED_NODES.push(this);

        if (!propUpdatesEnqueued) {
          propUpdatesEnqueued = setImmediate(runPropUpdates);
        }
      }
    }, {
      key: "__nativeInitialize",
      value: function __nativeInitialize() {
        if (!this.__initialized) {
          _ReanimatedModule.default.createNode(this.__nodeID, _objectSpread({}, this.__nodeConfig));

          this.__initialized = true;
        }
      }
    }, {
      key: "__nativeTearDown",
      value: function __nativeTearDown() {
        if (this.__initialized) {
          _ReanimatedModule.default.dropNode(this.__nodeID);

          this.__initialized = false;
        }
      }
    }, {
      key: "isNativelyInitialized",
      value: function isNativelyInitialized() {
        return this.__initialized;
      }
    }, {
      key: "__onEvaluate",
      value: function __onEvaluate() {
        throw new Error('Missing implementation of onEvaluate');
      }
    }, {
      key: "__getProps",
      value: function __getProps() {
        return this.__getValue();
      }
    }, {
      key: "__getChildren",
      value: function __getChildren() {
        return this.__children;
      }
    }, {
      key: "__addChild",
      value: function __addChild(child) {
        if (this.__children.length === 0) {
          this.__attach();
        }

        this.__children.push(child);

        child.__nativeInitialize();

        if (_ReanimatedModule.default.connectNodes) {
          _ReanimatedModule.default.connectNodes(this.__nodeID, child.__nodeID);
        } else {
          child.__dangerouslyRescheduleEvaluate();
        }
      }
    }, {
      key: "__removeChild",
      value: function __removeChild(child) {
        var index = this.__children.indexOf(child);

        if (index === -1) {
          console.warn("Trying to remove a child that doesn't exist");
          return;
        }

        if (_ReanimatedModule.default.disconnectNodes) {
          _ReanimatedModule.default.disconnectNodes(this.__nodeID, child.__nodeID);
        }

        this.__children.splice(index, 1);

        if (this.__children.length === 0) {
          this.__detach();
        }
      }
    }, {
      key: "_connectAnimatedView",
      value: function _connectAnimatedView(nativeViewTag) {
        if (_ReanimatedModule.default.connectNodeToView) {
          _ReanimatedModule.default.connectNodeToView(this.__nodeID, nativeViewTag);
        } else {
          this.__dangerouslyRescheduleEvaluate();
        }
      }
    }, {
      key: "_disconnectAnimatedView",
      value: function _disconnectAnimatedView(nativeViewTag) {
        _ReanimatedModule.default.disconnectNodeFromView(this.__nodeID, nativeViewTag);
      }
    }]);
    return AnimatedNode;
  }();

  exports.default = AnimatedNode;
},542,[1,46,24,25,543,2],"node_modules/react-native-reanimated/src/core/AnimatedNode.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _reactNative = _$$_REQUIRE(_dependencyMap[0], "react-native");

  var ReanimatedModule = _reactNative.NativeModules.ReanimatedModule;
  var _default = ReanimatedModule;
  exports.default = _default;
},543,[2],"node_modules/react-native-reanimated/src/ReanimatedModule.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/getPrototypeOf"));

  var _get2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/get"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/createClass"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits"));

  var _AnimatedNode2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "./AnimatedNode"));

  var _val = _$$_REQUIRE(_dependencyMap[8], "../val");

  var _ReanimatedModule = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "../ReanimatedModule"));

  function sanitizeValue(value) {
    return value === null || value === undefined || typeof value === 'string' ? value : Number(value);
  }

  var CONSTANT_VALUES = new Map();

  function initializeConstantValues() {
    if (CONSTANT_VALUES.size !== 0) {
      return;
    }

    [0, -1, 1, -2, 2].forEach(function (v) {
      return CONSTANT_VALUES.set(v, new InternalAnimatedValue(v, true));
    });
  }

  var InternalAnimatedValue = function (_AnimatedNode) {
    (0, _inherits2.default)(InternalAnimatedValue, _AnimatedNode);
    (0, _createClass2.default)(InternalAnimatedValue, null, [{
      key: "valueForConstant",
      value: function valueForConstant(number) {
        initializeConstantValues();
        return CONSTANT_VALUES.get(number) || new InternalAnimatedValue(number, true);
      }
    }]);

    function InternalAnimatedValue(value) {
      var _this;

      var constant = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
      (0, _classCallCheck2.default)(this, InternalAnimatedValue);
      _this = (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(InternalAnimatedValue).call(this, {
        type: 'value',
        value: sanitizeValue(value)
      }));
      _this._startingValue = _this._value = value;
      _this._animation = null;
      _this._constant = constant;
      return _this;
    }

    (0, _createClass2.default)(InternalAnimatedValue, [{
      key: "__detach",
      value: function __detach() {
        var _this2 = this;

        if (!this._constant) {
          if (_ReanimatedModule.default.getValue) {
            _ReanimatedModule.default.getValue(this.__nodeID, function (val) {
              return _this2.__nodeConfig.value = val;
            });
          } else {
            this.__nodeConfig.value = this.__getValue();
          }
        }

        this.__detachAnimation(this._animation);

        (0, _get2.default)((0, _getPrototypeOf2.default)(InternalAnimatedValue.prototype), "__detach", this).call(this);
      }
    }, {
      key: "__detachAnimation",
      value: function __detachAnimation(animation) {
        animation && animation.__detach();

        if (this._animation === animation) {
          this._animation = null;
        }
      }
    }, {
      key: "__attachAnimation",
      value: function __attachAnimation(animation) {
        this.__detachAnimation(this._animation);

        this._animation = animation;
      }
    }, {
      key: "__onEvaluate",
      value: function __onEvaluate() {
        if (this.__inputNodes && this.__inputNodes.length) {
          this.__inputNodes.forEach(_val.val);
        }

        return this._value;
      }
    }, {
      key: "setValue",
      value: function setValue(value) {
        this.__detachAnimation(this._animation);

        this._updateValue(value);
      }
    }, {
      key: "_updateValue",
      value: function _updateValue(value) {
        this._value = value;

        this.__forceUpdateCache(value);
      }
    }]);
    return InternalAnimatedValue;
  }(_AnimatedNode2.default);

  exports.default = InternalAnimatedValue;
},544,[1,24,32,34,35,25,37,542,541,543],"node_modules/react-native-reanimated/src/core/InternalAnimatedValue.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.createAnimatedSet = createAnimatedSet;

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits"));

  var _AnimatedNode2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "./AnimatedNode"));

  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "fbjs/lib/invariant"));

  var _val = _$$_REQUIRE(_dependencyMap[8], "../val");

  var _AnimatedBlock = _$$_REQUIRE(_dependencyMap[9], "../core/AnimatedBlock");

  var AnimatedSet = function (_AnimatedNode) {
    (0, _inherits2.default)(AnimatedSet, _AnimatedNode);

    function AnimatedSet(what, value) {
      var _this;

      (0, _classCallCheck2.default)(this, AnimatedSet);
      (0, _invariant.default)(what instanceof _AnimatedNode2.default, "Reanimated: Animated.set first argument should be of type AnimatedNode but got " + what);
      (0, _invariant.default)(value instanceof _AnimatedNode2.default, "Reanimated: Animated.set second argument should be of type AnimatedNode, String or Number but got " + value);
      _this = (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(AnimatedSet).call(this, {
        type: 'set',
        what: what,
        value: value
      }, [value]));
      (0, _invariant.default)(!what._constant, 'Value to be set cannot be constant');
      _this._what = what;
      _this._value = value;
      return _this;
    }

    (0, _createClass2.default)(AnimatedSet, [{
      key: "toString",
      value: function toString() {
        return "AnimatedSet, id: " + this.__nodeID;
      }
    }, {
      key: "__onEvaluate",
      value: function __onEvaluate() {
        var newValue = (0, _val.val)(this._value);

        this._what.setValue(newValue);

        return newValue;
      }
    }]);
    return AnimatedSet;
  }(_AnimatedNode2.default);

  function createAnimatedSet(what, value) {
    return new AnimatedSet(what, (0, _AnimatedBlock.adapt)(value));
  }
},545,[1,24,25,32,34,37,542,248,541,540],"node_modules/react-native-reanimated/src/core/AnimatedSet.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.createAnimatedStartClock = createAnimatedStartClock;

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits"));

  var _AnimatedNode2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "./AnimatedNode"));

  var _AnimatedClock = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "./AnimatedClock"));

  var _AnimatedParam = _$$_REQUIRE(_dependencyMap[8], "./AnimatedParam");

  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "fbjs/lib/invariant"));

  var AnimatedStartClock = function (_AnimatedNode) {
    (0, _inherits2.default)(AnimatedStartClock, _AnimatedNode);

    function AnimatedStartClock(clockNode) {
      var _this;

      (0, _classCallCheck2.default)(this, AnimatedStartClock);
      (0, _invariant.default)(clockNode instanceof _AnimatedClock.default || clockNode instanceof _AnimatedParam.AnimatedParam, "Reanimated: Animated.startClock argument should be of type AnimatedClock but got " + clockNode);
      _this = (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(AnimatedStartClock).call(this, {
        type: 'clockStart',
        clock: clockNode
      }));
      _this._clockNode = clockNode;
      return _this;
    }

    (0, _createClass2.default)(AnimatedStartClock, [{
      key: "toString",
      value: function toString() {
        return "AnimatedStartClock, id: " + this.__nodeID;
      }
    }, {
      key: "__onEvaluate",
      value: function __onEvaluate() {
        this._clockNode.start();

        return 0;
      }
    }]);
    return AnimatedStartClock;
  }(_AnimatedNode2.default);

  function createAnimatedStartClock(clock) {
    return new AnimatedStartClock(clock);
  }
},546,[1,24,25,32,34,37,542,547,548,248],"node_modules/react-native-reanimated/src/core/AnimatedStartClock.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));

  var _get2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/get"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits"));

  var _InternalAnimatedValue = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "./InternalAnimatedValue"));

  var _AnimatedNode2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "./AnimatedNode"));

  var _val = _$$_REQUIRE(_dependencyMap[9], "../val");

  var AnimatedMainClock = function (_InternalAnimatedValu) {
    (0, _inherits2.default)(AnimatedMainClock, _InternalAnimatedValu);

    function AnimatedMainClock() {
      var _this;

      (0, _classCallCheck2.default)(this, AnimatedMainClock);
      _this = (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(AnimatedMainClock).call(this, {
        type: 'MAIN_CLOCK'
      }));

      _this._runFrame = function () {
        _this._updateValue(0);

        if (_this.__children.length > 0) {
          _this._frameCallback = requestAnimationFrame(_this._runFrame);
        }
      };

      return _this;
    }

    (0, _createClass2.default)(AnimatedMainClock, [{
      key: "__onEvaluate",
      value: function __onEvaluate() {
        return +new Date();
      }
    }, {
      key: "__attach",
      value: function __attach() {
        (0, _get2.default)((0, _getPrototypeOf2.default)(AnimatedMainClock.prototype), "__attach", this).call(this);

        if (!this._frameCallback) {
          this._frameCallback = requestAnimationFrame(this._runFrame);
        }
      }
    }, {
      key: "__detach",
      value: function __detach() {
        if (this._frameCallback) {
          cancelAnimationFrame(this._frameCallback);
          this._frameCallback = null;
        }

        (0, _get2.default)((0, _getPrototypeOf2.default)(AnimatedMainClock.prototype), "__detach", this).call(this);
      }
    }]);
    return AnimatedMainClock;
  }(_InternalAnimatedValue.default);

  var mainClock = new AnimatedMainClock();

  var AnimatedClock = function (_AnimatedNode) {
    (0, _inherits2.default)(AnimatedClock, _AnimatedNode);

    function AnimatedClock() {
      (0, _classCallCheck2.default)(this, AnimatedClock);
      return (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(AnimatedClock).call(this, {
        type: 'clock'
      }));
    }

    (0, _createClass2.default)(AnimatedClock, [{
      key: "toString",
      value: function toString() {
        return "AnimatedClock, id: " + this.__nodeID;
      }
    }, {
      key: "__onEvaluate",
      value: function __onEvaluate() {
        return (0, _val.val)(mainClock);
      }
    }, {
      key: "__attach",
      value: function __attach() {
        (0, _get2.default)((0, _getPrototypeOf2.default)(AnimatedClock.prototype), "__attach", this).call(this);

        if (this._started && !this._attached) {
          mainClock.__addChild(this);
        }

        this._attached = true;
      }
    }, {
      key: "__detach",
      value: function __detach() {
        if (this._started && this._attached) {
          mainClock.__removeChild(this);
        }

        this._attached = false;
        (0, _get2.default)((0, _getPrototypeOf2.default)(AnimatedClock.prototype), "__detach", this).call(this);
      }
    }, {
      key: "start",
      value: function start() {
        if (!this._started && this._attached) {
          mainClock.__addChild(this);
        }

        this._started = true;
      }
    }, {
      key: "stop",
      value: function stop() {
        if (this._started && this._attached) {
          mainClock.__removeChild(this);
        }

        this._started = false;
      }
    }, {
      key: "isStarted",
      value: function isStarted() {
        return this._started;
      }
    }]);
    return AnimatedClock;
  }(_AnimatedNode2.default);

  exports.default = AnimatedClock;
},547,[1,24,25,32,34,35,37,544,542,541],"node_modules/react-native-reanimated/src/core/AnimatedClock.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireWildcard");

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.createAnimatedParam = createAnimatedParam;
  exports.AnimatedParam = void 0;

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits"));

  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "fbjs/lib/invariant"));

  var _AnimatedNode2 = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[8], "./AnimatedNode"));

  var _AnimatedClock = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "./AnimatedClock"));

  var _val = _$$_REQUIRE(_dependencyMap[10], "../val");

  var AnimatedParam = function (_AnimatedNode) {
    (0, _inherits2.default)(AnimatedParam, _AnimatedNode);

    function AnimatedParam() {
      var _this;

      (0, _classCallCheck2.default)(this, AnimatedParam);
      _this = (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(AnimatedParam).call(this, {
        type: 'param'
      }, []));
      _this.argsStack = [];

      _this.__attach();

      return _this;
    }

    (0, _createClass2.default)(AnimatedParam, [{
      key: "beginContext",
      value: function beginContext(ref, prevCallID) {
        this._prevCallID = prevCallID;
        this.argsStack.push(ref);
      }
    }, {
      key: "endContext",
      value: function endContext() {
        this.argsStack.pop();
      }
    }, {
      key: "_getTopNode",
      value: function _getTopNode() {
        if (this.argsStack.length === 0) throw new Error("param: Invocation failed because argsStack is empty");
        var top = this.argsStack[this.argsStack.length - 1];
        return top;
      }
    }, {
      key: "setValue",
      value: function setValue(value) {
        var top = this._getTopNode();

        if (top.setValue) {
          var callID = (0, _AnimatedNode2.getCallID)();
          (0, _AnimatedNode2.setCallID)(this._prevCallID);
          top.setValue(value);
          (0, _AnimatedNode2.setCallID)(callID);
        } else {
          throw new Error("param: setValue(" + value + ") failed because the top element has no known method for updating it's current value.");
        }
      }
    }, {
      key: "__onEvaluate",
      value: function __onEvaluate() {
        var callID = (0, _AnimatedNode2.getCallID)();
        (0, _AnimatedNode2.setCallID)(this._prevCallID);

        var top = this._getTopNode();

        var value = (0, _val.val)(top);
        (0, _AnimatedNode2.setCallID)(callID);
        return value;
      }
    }, {
      key: "start",
      value: function start() {
        var node = this._getTopNode();

        (0, _invariant.default)(node instanceof _AnimatedClock.default || node instanceof AnimatedParam, "param: top node should be of type AnimatedClock but got " + node);
        node.start();
      }
    }, {
      key: "stop",
      value: function stop() {
        var node = this._getTopNode();

        (0, _invariant.default)(node instanceof _AnimatedClock.default || node instanceof AnimatedParam, "param: top node should be of type AnimatedClock but got " + node);
        node.stop();
      }
    }, {
      key: "isRunning",
      value: function isRunning() {
        var node = this._getTopNode();

        if (node instanceof AnimatedParam) {
          return node.isRunning();
        }

        (0, _invariant.default)(node instanceof _AnimatedClock.default, "param: top node should be of type AnimatedClock but got " + node);
        return node.isStarted();
      }
    }]);
    return AnimatedParam;
  }(_AnimatedNode2.default);

  exports.AnimatedParam = AnimatedParam;

  function createAnimatedParam() {
    return new AnimatedParam();
  }
},548,[9,1,24,25,32,34,37,248,542,547,541],"node_modules/react-native-reanimated/src/core/AnimatedParam.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.createAnimatedStopClock = createAnimatedStopClock;

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits"));

  var _AnimatedNode2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "./AnimatedNode"));

  var _AnimatedClock = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "./AnimatedClock"));

  var _AnimatedParam = _$$_REQUIRE(_dependencyMap[8], "./AnimatedParam");

  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "fbjs/lib/invariant"));

  var AnimatedStopClock = function (_AnimatedNode) {
    (0, _inherits2.default)(AnimatedStopClock, _AnimatedNode);

    function AnimatedStopClock(clockNode) {
      var _this;

      (0, _classCallCheck2.default)(this, AnimatedStopClock);
      (0, _invariant.default)(clockNode instanceof _AnimatedClock.default || clockNode instanceof _AnimatedParam.AnimatedParam, "Reanimated: Animated.stopClock argument should be of type AnimatedClock but got " + clockNode);
      _this = (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(AnimatedStopClock).call(this, {
        type: 'clockStop',
        clock: clockNode
      }));
      _this._clockNode = clockNode;
      return _this;
    }

    (0, _createClass2.default)(AnimatedStopClock, [{
      key: "toString",
      value: function toString() {
        return "AnimatedStopClock, id: " + this.__nodeID;
      }
    }, {
      key: "__onEvaluate",
      value: function __onEvaluate() {
        this._clockNode.stop();

        return 0;
      }
    }]);
    return AnimatedStopClock;
  }(_AnimatedNode2.default);

  function createAnimatedStopClock(clock) {
    return new AnimatedStopClock(clock);
  }
},549,[1,24,25,32,34,37,542,547,548,248],"node_modules/react-native-reanimated/src/core/AnimatedStopClock.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.createAnimatedClockTest = createAnimatedClockTest;

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits"));

  var _AnimatedNode2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "./AnimatedNode"));

  var AnimatedClockTest = function (_AnimatedNode) {
    (0, _inherits2.default)(AnimatedClockTest, _AnimatedNode);

    function AnimatedClockTest(clockNode) {
      var _this;

      (0, _classCallCheck2.default)(this, AnimatedClockTest);
      _this = (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(AnimatedClockTest).call(this, {
        type: 'clockTest',
        clock: clockNode
      }));
      _this._clockNode = clockNode;
      return _this;
    }

    (0, _createClass2.default)(AnimatedClockTest, [{
      key: "toString",
      value: function toString() {
        return "AnimatedClockTest, id: " + this.__nodeID;
      }
    }, {
      key: "__onEvaluate",
      value: function __onEvaluate() {
        return this._clockNode.isStarted() ? 1 : 0;
      }
    }]);
    return AnimatedClockTest;
  }(_AnimatedNode2.default);

  function createAnimatedClockTest(clock) {
    return new AnimatedClockTest(clock);
  }
},550,[1,24,25,32,34,37,542],"node_modules/react-native-reanimated/src/core/AnimatedClockTest.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.createAnimatedDebug = createAnimatedDebug;

  var _slicedToArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/slicedToArray"));

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits"));

  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "fbjs/lib/invariant"));

  var _val = _$$_REQUIRE(_dependencyMap[8], "../val");

  var _AnimatedBlock = _$$_REQUIRE(_dependencyMap[9], "./AnimatedBlock");

  var _AnimatedCall = _$$_REQUIRE(_dependencyMap[10], "./AnimatedCall");

  var _AnimatedNode2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[11], "./AnimatedNode"));

  var AnimatedDebug = function (_AnimatedNode) {
    (0, _inherits2.default)(AnimatedDebug, _AnimatedNode);

    function AnimatedDebug(message, value) {
      var _this;

      (0, _classCallCheck2.default)(this, AnimatedDebug);
      (0, _invariant.default)(typeof message === 'string', "Reanimated: Animated.debug node first argument should be of type string but got " + message);
      (0, _invariant.default)(value instanceof _AnimatedNode2.default, "Reanimated: Animated.debug node second argument should be of type AnimatedNode but got " + value);
      _this = (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(AnimatedDebug).call(this, {
        type: 'debug',
        message: message,
        value: value
      }, [value]));
      _this._message = message;
      _this._value = value;
      return _this;
    }

    (0, _createClass2.default)(AnimatedDebug, [{
      key: "toString",
      value: function toString() {
        return "AnimatedDebug, id: " + this.__nodeID;
      }
    }, {
      key: "__onEvaluate",
      value: function __onEvaluate() {
        var value = (0, _val.val)(this._value);
        console.log(this._message, value);
        return value;
      }
    }]);
    return AnimatedDebug;
  }(_AnimatedNode2.default);

  function createAnimatedDebug(message, value) {
    if (__DEV__) {
      var runningInRemoteDebugger = typeof atob !== 'undefined';
      var runningInExpoShell = global.Expo && global.Expo.Constants.appOwnership !== 'standalone';

      if (runningInRemoteDebugger || runningInExpoShell) {
        return (0, _AnimatedBlock.createAnimatedBlock)([(0, _AnimatedCall.createAnimatedCall)([value], function (_ref) {
          var _ref2 = (0, _slicedToArray2.default)(_ref, 1),
              a = _ref2[0];

          return console.log(message + " " + a);
        }), value]);
      } else {
        return new AnimatedDebug(message, (0, _AnimatedBlock.adapt)(value));
      }
    }

    return value;
  }
},551,[1,14,24,25,32,34,37,248,541,540,552,542],"node_modules/react-native-reanimated/src/core/AnimatedDebug.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.createAnimatedCall = createAnimatedCall;

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));

  var _get2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/get"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits"));

  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "fbjs/lib/invariant"));

  var _ReanimatedEventEmitter = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "../ReanimatedEventEmitter"));

  var _val = _$$_REQUIRE(_dependencyMap[9], "../val");

  var _AnimatedNode2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[10], "./AnimatedNode"));

  var NODE_MAPPING = new Map();

  function listener(data) {
    var node = NODE_MAPPING.get(data.id);
    node && node._callback(data.args);
  }

  var AnimatedCall = function (_AnimatedNode) {
    (0, _inherits2.default)(AnimatedCall, _AnimatedNode);

    function AnimatedCall(args, jsFunction) {
      var _this;

      (0, _classCallCheck2.default)(this, AnimatedCall);
      (0, _invariant.default)(args.every(function (el) {
        return el instanceof _AnimatedNode2.default;
      }), "Reanimated: Animated.call node args should be an array with elements of type AnimatedNode. One or more of them are not AnimatedNodes");
      _this = (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(AnimatedCall).call(this, {
        type: 'call',
        input: args
      }, args));
      _this._callback = jsFunction;
      _this._args = args;
      return _this;
    }

    (0, _createClass2.default)(AnimatedCall, [{
      key: "toString",
      value: function toString() {
        return "AnimatedCall, id: " + this.__nodeID;
      }
    }, {
      key: "__attach",
      value: function __attach() {
        (0, _get2.default)((0, _getPrototypeOf2.default)(AnimatedCall.prototype), "__attach", this).call(this);
        NODE_MAPPING.set(this.__nodeID, this);

        if (NODE_MAPPING.size === 1) {
          _ReanimatedEventEmitter.default.addListener('onReanimatedCall', listener);
        }
      }
    }, {
      key: "__detach",
      value: function __detach() {
        NODE_MAPPING.delete(this.__nodeID);

        if (NODE_MAPPING.size === 0) {
          _ReanimatedEventEmitter.default.removeAllListeners('onReanimatedCall');
        }

        (0, _get2.default)((0, _getPrototypeOf2.default)(AnimatedCall.prototype), "__detach", this).call(this);
      }
    }, {
      key: "__onEvaluate",
      value: function __onEvaluate() {
        this._callback(this._args.map(_val.val));

        return 0;
      }
    }]);
    return AnimatedCall;
  }(_AnimatedNode2.default);

  function createAnimatedCall(args, func) {
    return new AnimatedCall(args, func);
  }
},552,[1,24,25,32,34,35,37,248,553,541,542],"node_modules/react-native-reanimated/src/core/AnimatedCall.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _ReanimatedModule = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./ReanimatedModule"));

  var _reactNative = _$$_REQUIRE(_dependencyMap[2], "react-native");

  var _default = new _reactNative.NativeEventEmitter(_ReanimatedModule.default);

  exports.default = _default;
},553,[1,543,2],"node_modules/react-native-reanimated/src/ReanimatedEventEmitter.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.createAnimatedEvent = createAnimatedEvent;
  exports.default = void 0;

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits"));

  var _reactNative = _$$_REQUIRE(_dependencyMap[6], "react-native");

  var _ReanimatedModule = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "../ReanimatedModule"));

  var _AnimatedNode2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "./AnimatedNode"));

  var _AnimatedValue = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "./AnimatedValue"));

  var _AnimatedAlways = _$$_REQUIRE(_dependencyMap[10], "./AnimatedAlways");

  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[11], "fbjs/lib/invariant"));

  var _createEventObjectProxyPolyfill = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[12], "./createEventObjectProxyPolyfill"));

  function sanitizeArgMapping(argMapping) {
    var eventMappings = [];
    var alwaysNodes = [];

    var getNode = function getNode(node) {
      if (_reactNative.Platform.OS === 'web') {
        return node;
      }

      return node.__nodeID;
    };

    var traverse = function traverse(value, path) {
      if (value instanceof _AnimatedValue.default) {
        eventMappings.push(path.concat(getNode(value)));
      } else if (typeof value === 'object' && value.__val) {
        eventMappings.push(path.concat(getNode(value.__val)));
      } else if (typeof value === 'function') {
        var node = new _AnimatedValue.default(0);
        alwaysNodes.push((0, _AnimatedAlways.createAnimatedAlways)(value(node)));
        eventMappings.push(path.concat(getNode(node)));
      } else if (typeof value === 'object') {
        for (var key in value) {
          traverse(value[key], path.concat(key));
        }
      }
    };

    (0, _invariant.default)(argMapping[0] && argMapping[0].nativeEvent, 'Native driven events only support animated values contained inside `nativeEvent`.');
    var ev = argMapping[0].nativeEvent;

    if (typeof ev === 'object') {
      traverse(ev, []);
    } else if (typeof ev === 'function') {
      var proxyHandler = {
        get: function get(target, name) {
          if (name === '__isProxy') {
            return true;
          }

          if (!target[name] && name !== '__val') {
            target[name] = new Proxy({}, proxyHandler);
          }

          return target[name];
        },
        set: function set(target, prop, value) {
          if (prop === '__val') {
            target[prop] = value;
            return true;
          }

          return false;
        }
      };
      var proxy = typeof Proxy === 'function' ? new Proxy({}, proxyHandler) : (0, _createEventObjectProxyPolyfill.default)();
      alwaysNodes.push((0, _AnimatedAlways.createAnimatedAlways)(ev(proxy)));
      traverse(proxy, []);
    }

    return {
      eventMappings: eventMappings,
      alwaysNodes: alwaysNodes
    };
  }

  var AnimatedEvent = function (_AnimatedNode) {
    (0, _inherits2.default)(AnimatedEvent, _AnimatedNode);

    function AnimatedEvent(argMapping) {
      var _this;

      var config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
      (0, _classCallCheck2.default)(this, AnimatedEvent);

      var _sanitizeArgMapping = sanitizeArgMapping(argMapping),
          eventMappings = _sanitizeArgMapping.eventMappings,
          alwaysNodes = _sanitizeArgMapping.alwaysNodes;

      _this = (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(AnimatedEvent).call(this, {
        type: 'event',
        argMapping: eventMappings
      }));
      _this.__isNative = true;
      _this._alwaysNodes = alwaysNodes;
      return _this;
    }

    (0, _createClass2.default)(AnimatedEvent, [{
      key: "toString",
      value: function toString() {
        return "AnimatedEvent, id: " + this.__nodeID;
      }
    }, {
      key: "attachEvent",
      value: function attachEvent(viewRef, eventName) {
        for (var i = 0; i < this._alwaysNodes.length; i++) {
          this._alwaysNodes[i].__attach();
        }

        this.__attach();

        var viewTag = (0, _reactNative.findNodeHandle)(viewRef);

        _ReanimatedModule.default.attachEvent(viewTag, eventName, this.__nodeID);
      }
    }, {
      key: "__onEvaluate",
      value: function __onEvaluate() {
        return 0;
      }
    }, {
      key: "detachEvent",
      value: function detachEvent(viewRef, eventName) {
        for (var i = 0; i < this._alwaysNodes.length; i++) {
          this._alwaysNodes[i].isNativelyInitialized() && this._alwaysNodes[i].__detach();
        }

        var viewTag = (0, _reactNative.findNodeHandle)(viewRef);

        _ReanimatedModule.default.detachEvent(viewTag, eventName, this.__nodeID);

        this.__detach();
      }
    }]);
    return AnimatedEvent;
  }(_AnimatedNode2.default);

  exports.default = AnimatedEvent;

  function createAnimatedEvent(argMapping, config) {
    return new AnimatedEvent(argMapping, config);
  }
},554,[1,24,25,32,34,37,2,543,542,555,562,248,563],"node_modules/react-native-reanimated/src/core/AnimatedEvent.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits"));

  var _AnimatedSet = _$$_REQUIRE(_dependencyMap[6], "../core/AnimatedSet");

  var _interpolate2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "../derived/interpolate"));

  var _InternalAnimatedValue = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "./InternalAnimatedValue"));

  var _reactNative = _$$_REQUIRE(_dependencyMap[9], "react-native");

  var _evaluateOnce = _$$_REQUIRE(_dependencyMap[10], "../derived/evaluateOnce");

  var _ReanimatedModule = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[11], "../ReanimatedModule"));

  var AnimatedValue = function (_InternalAnimatedValu) {
    (0, _inherits2.default)(AnimatedValue, _InternalAnimatedValu);

    function AnimatedValue() {
      (0, _classCallCheck2.default)(this, AnimatedValue);
      return (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(AnimatedValue).apply(this, arguments));
    }

    (0, _createClass2.default)(AnimatedValue, [{
      key: "setValue",
      value: function setValue(value) {
        this.__detachAnimation(this._animation);

        if (_reactNative.Platform.OS === 'web') {
          this._updateValue(value);
        } else {
          if (_ReanimatedModule.default.setValue && typeof value === "number") {
            _ReanimatedModule.default.setValue(this.__nodeID, value);
          } else {
            (0, _evaluateOnce.evaluateOnce)((0, _AnimatedSet.createAnimatedSet)(this, value), this);
          }
        }
      }
    }, {
      key: "toString",
      value: function toString() {
        return "AnimatedValue, id: " + this.__nodeID;
      }
    }, {
      key: "interpolate",
      value: function interpolate(config) {
        return (0, _interpolate2.default)(this, config);
      }
    }]);
    return AnimatedValue;
  }(_InternalAnimatedValue.default);

  exports.default = AnimatedValue;
},555,[1,24,25,32,34,37,545,556,544,2,561,543],"node_modules/react-native-reanimated/src/core/AnimatedValue.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = interpolate;
  exports.Extrapolate = void 0;

  var _operators = _$$_REQUIRE(_dependencyMap[1], "../operators");

  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "fbjs/lib/invariant"));

  var _AnimatedNode = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../core/AnimatedNode"));

  var _AnimatedCond = _$$_REQUIRE(_dependencyMap[4], "../core/AnimatedCond");

  var _AnimatedFunction = _$$_REQUIRE(_dependencyMap[5], "../core/AnimatedFunction");

  var interpolateInternalSingleProc = (0, _AnimatedFunction.createAnimatedFunction)(function (value, inS, inE, outS, outE) {
    var progress = (0, _operators.divide)((0, _operators.sub)(value, inS), (0, _operators.sub)(inE, inS));
    var resultForNonZeroRange = (0, _operators.add)(outS, (0, _operators.multiply)(progress, (0, _operators.sub)(outE, outS)));
    var result = (0, _AnimatedCond.createAnimatedCond)((0, _operators.eq)(inS, inE), (0, _AnimatedCond.createAnimatedCond)((0, _operators.lessOrEq)(value, inS), outS, outE), resultForNonZeroRange);
    return result;
  });

  function interpolateInternalSingle(value, inputRange, outputRange, offset) {
    var inS = inputRange[offset];
    var inE = inputRange[offset + 1];
    var outS = outputRange[offset];
    var outE = outputRange[offset + 1];
    return interpolateInternalSingleProc(value, inS, inE, outS, outE);
  }

  function interpolateInternal(value, inputRange, outputRange) {
    var offset = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;

    if (inputRange.length - offset === 2) {
      return interpolateInternalSingle(value, inputRange, outputRange, offset);
    }

    return (0, _AnimatedCond.createAnimatedCond)((0, _operators.lessThan)(value, inputRange[offset + 1]), interpolateInternalSingle(value, inputRange, outputRange, offset), interpolateInternal(value, inputRange, outputRange, offset + 1));
  }

  var Extrapolate = {
    EXTEND: 'extend',
    CLAMP: 'clamp',
    IDENTITY: 'identity'
  };
  exports.Extrapolate = Extrapolate;

  function checkNonDecreasing(name, arr) {
    for (var i = 1; i < arr.length; ++i) {
      if (arr[i] instanceof _AnimatedNode.default || arr[i - 1] instanceof _AnimatedNode.default) continue;
      (0, _invariant.default)(arr[i] >= arr[i - 1], '%s must be monotonically non-decreasing. (%s)', name, arr);
    }
  }

  function checkMinElements(name, arr) {
    (0, _invariant.default)(arr.length >= 2, '%s must have at least 2 elements. (%s)', name, arr);
  }

  function checkValidNumbers(name, arr) {
    for (var i = 0; i < arr.length; i++) {
      if (arr[i] instanceof _AnimatedNode.default) continue;
      (0, _invariant.default)(Number.isFinite(arr[i]), '%s cannot include %s. (%s)', name, arr[i], arr);
    }
  }

  function interpolate(value, config) {
    var inputRange = config.inputRange,
        outputRange = config.outputRange,
        _config$extrapolate = config.extrapolate,
        extrapolate = _config$extrapolate === void 0 ? Extrapolate.EXTEND : _config$extrapolate,
        extrapolateLeft = config.extrapolateLeft,
        extrapolateRight = config.extrapolateRight;
    checkMinElements('inputRange', inputRange);
    checkValidNumbers('inputRange', inputRange);
    checkMinElements('outputRange', outputRange);
    checkValidNumbers('outputRange', outputRange);
    checkNonDecreasing('inputRange', inputRange);
    (0, _invariant.default)(inputRange.length === outputRange.length, 'inputRange and outputRange must be the same length.');
    var left = extrapolateLeft || extrapolate;
    var right = extrapolateRight || extrapolate;
    var output = interpolateInternal(value, inputRange, outputRange);

    if (left === Extrapolate.EXTEND) {} else if (left === Extrapolate.CLAMP) {
      output = (0, _AnimatedCond.createAnimatedCond)((0, _operators.lessThan)(value, inputRange[0]), outputRange[0], output);
    } else if (left === Extrapolate.IDENTITY) {
      output = (0, _AnimatedCond.createAnimatedCond)((0, _operators.lessThan)(value, inputRange[0]), value, output);
    }

    if (right === Extrapolate.EXTEND) {} else if (right === Extrapolate.CLAMP) {
      output = (0, _AnimatedCond.createAnimatedCond)((0, _operators.greaterThan)(value, inputRange[inputRange.length - 1]), outputRange[outputRange.length - 1], output);
    } else if (right === Extrapolate.IDENTITY) {
      output = (0, _AnimatedCond.createAnimatedCond)((0, _operators.greaterThan)(value, inputRange[inputRange.length - 1]), value, output);
    }

    return output;
  }
},556,[1,557,248,542,539,559],"node_modules/react-native-reanimated/src/derived/interpolate.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.atan = exports.asin = exports.acos = exports.tan = exports.not = exports.defined = exports.or = exports.and = exports.neq = exports.greaterOrEq = exports.lessOrEq = exports.greaterThan = exports.eq = exports.lessThan = exports.round = exports.exp = exports.cos = exports.sin = exports.log = exports.sqrt = exports.modulo = exports.pow = exports.divide = exports.multiply = exports.sub = exports.add = void 0;

  var _AnimatedOperator = _$$_REQUIRE(_dependencyMap[0], "./core/AnimatedOperator");

  var operator = _AnimatedOperator.createAnimatedOperator;
  var add = operator('add');
  exports.add = add;
  var sub = operator('sub');
  exports.sub = sub;
  var multiply = operator('multiply');
  exports.multiply = multiply;
  var divide = operator('divide');
  exports.divide = divide;
  var pow = operator('pow');
  exports.pow = pow;
  var modulo = operator('modulo');
  exports.modulo = modulo;
  var sqrt = operator('sqrt');
  exports.sqrt = sqrt;
  var log = operator('log');
  exports.log = log;
  var sin = operator('sin');
  exports.sin = sin;
  var cos = operator('cos');
  exports.cos = cos;
  var exp = operator('exp');
  exports.exp = exp;
  var round = operator('round');
  exports.round = round;
  var lessThan = operator('lessThan');
  exports.lessThan = lessThan;
  var eq = operator('eq');
  exports.eq = eq;
  var greaterThan = operator('greaterThan');
  exports.greaterThan = greaterThan;
  var lessOrEq = operator('lessOrEq');
  exports.lessOrEq = lessOrEq;
  var greaterOrEq = operator('greaterOrEq');
  exports.greaterOrEq = greaterOrEq;
  var neq = operator('neq');
  exports.neq = neq;
  var and = operator('and');
  exports.and = and;
  var or = operator('or');
  exports.or = or;
  var defined = operator('defined');
  exports.defined = defined;
  var not = operator('not');
  exports.not = not;
  var tan = operator('tan');
  exports.tan = tan;
  var acos = operator('acos');
  exports.acos = acos;
  var asin = operator('asin');
  exports.asin = asin;
  var atan = operator('atan');
  exports.atan = atan;
},557,[558],"node_modules/react-native-reanimated/src/operators.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.createAnimatedOperator = createAnimatedOperator;

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits"));

  var _AnimatedNode2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "./AnimatedNode"));

  var _val = _$$_REQUIRE(_dependencyMap[7], "../val");

  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "fbjs/lib/invariant"));

  var _AnimatedBlock = _$$_REQUIRE(_dependencyMap[9], "../core/AnimatedBlock");

  function reduce(fn) {
    return function (input) {
      return input.reduce(function (a, b) {
        return fn((0, _val.val)(a), (0, _val.val)(b));
      });
    };
  }

  function reduceFrom(fn, initialValue) {
    return function (input) {
      return input.reduce(function (a, b) {
        return fn((0, _val.val)(a), (0, _val.val)(b));
      }, initialValue);
    };
  }

  function infix(fn) {
    return function (input) {
      return fn((0, _val.val)(input[0]), (0, _val.val)(input[1]));
    };
  }

  function single(fn) {
    return function (input) {
      return fn((0, _val.val)(input[0]));
    };
  }

  var OPERATIONS = {
    add: reduce(function (a, b) {
      return a + b;
    }),
    sub: reduce(function (a, b) {
      return a - b;
    }),
    multiply: reduce(function (a, b) {
      return a * b;
    }),
    divide: reduce(function (a, b) {
      return a / b;
    }),
    pow: reduce(function (a, b) {
      return Math.pow(a, b);
    }),
    modulo: reduce(function (a, b) {
      return (a % b + b) % b;
    }),
    sqrt: single(function (a) {
      return Math.sqrt(a);
    }),
    log: single(function (a) {
      return Math.log(a);
    }),
    sin: single(function (a) {
      return Math.sin(a);
    }),
    cos: single(function (a) {
      return Math.cos(a);
    }),
    tan: single(function (a) {
      return Math.tan(a);
    }),
    acos: single(function (a) {
      return Math.acos(a);
    }),
    asin: single(function (a) {
      return Math.asin(a);
    }),
    atan: single(function (a) {
      return Math.atan(a);
    }),
    exp: single(function (a) {
      return Math.exp(a);
    }),
    round: single(function (a) {
      return Math.round(a);
    }),
    and: reduceFrom(function (a, b) {
      return a && b;
    }, true),
    or: reduceFrom(function (a, b) {
      return a || b;
    }, false),
    not: single(function (a) {
      return !a;
    }),
    defined: single(function (a) {
      return a !== null && a !== undefined && !isNaN(a);
    }),
    lessThan: infix(function (a, b) {
      return a < b;
    }),
    eq: infix(function (a, b) {
      return a == b;
    }),
    greaterThan: infix(function (a, b) {
      return a > b;
    }),
    lessOrEq: infix(function (a, b) {
      return a <= b;
    }),
    greaterOrEq: infix(function (a, b) {
      return a >= b;
    }),
    neq: infix(function (a, b) {
      return a != b;
    })
  };

  var AnimatedOperator = function (_AnimatedNode) {
    (0, _inherits2.default)(AnimatedOperator, _AnimatedNode);

    function AnimatedOperator(operator, input) {
      var _this;

      (0, _classCallCheck2.default)(this, AnimatedOperator);
      (0, _invariant.default)(typeof operator === 'string', "Reanimated: Animated.operator node first argument should be of type String, but got: " + operator);
      (0, _invariant.default)(input.every(function (el) {
        return el instanceof _AnimatedNode2.default || typeof el === 'string' || typeof el === 'number';
      }), "Reanimated: Animated.operator node second argument should be one or more of type AnimatedNode, String or Number but got " + input);
      _this = (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(AnimatedOperator).call(this, {
        type: 'op',
        op: operator,
        input: input
      }, input));
      _this._op = operator;
      _this._input = input;
      return _this;
    }

    (0, _createClass2.default)(AnimatedOperator, [{
      key: "toString",
      value: function toString() {
        return "AnimatedOperator, id: " + this.__nodeID;
      }
    }, {
      key: "__onEvaluate",
      value: function __onEvaluate() {
        if (!this._operation) {
          this._operation = OPERATIONS[this._op];
          (0, _invariant.default)(this._operation, "Illegal operator '%s'", this._op);
        }

        return this._operation(this._input);
      }
    }]);
    return AnimatedOperator;
  }(_AnimatedNode2.default);

  function createAnimatedOperator(name) {
    return function () {
      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
        args[_key] = arguments[_key];
      }

      return new AnimatedOperator(name, args.map(_AnimatedBlock.adapt));
    };
  }
},558,[1,24,25,32,34,37,542,541,248,540],"node_modules/react-native-reanimated/src/core/AnimatedOperator.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.createAnimatedFunction = createAnimatedFunction;

  var _construct2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/construct"));

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits"));

  var _AnimatedNode2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "./AnimatedNode"));

  var _AnimatedCallFunc = _$$_REQUIRE(_dependencyMap[8], "./AnimatedCallFunc");

  var _AnimatedParam = _$$_REQUIRE(_dependencyMap[9], "./AnimatedParam");

  var _val = _$$_REQUIRE(_dependencyMap[10], "../val");

  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[11], "fbjs/lib/invariant"));

  var AnimatedFunction = function (_AnimatedNode) {
    (0, _inherits2.default)(AnimatedFunction, _AnimatedNode);

    function AnimatedFunction(what) {
      var _this;

      (0, _classCallCheck2.default)(this, AnimatedFunction);
      (0, _invariant.default)(what instanceof _AnimatedNode2.default, "Reanimated: AnimatedCallFunc 'what' argument should be of type AnimatedNode but got " + what);

      for (var _len = arguments.length, params = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
        params[_key - 1] = arguments[_key];
      }

      _this = (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(AnimatedFunction).call(this, {
        type: 'func',
        what: what
      }, [what].concat(params)));
      _this._what = what;

      _this.__attach();

      return _this;
    }

    (0, _createClass2.default)(AnimatedFunction, [{
      key: "__onEvaluate",
      value: function __onEvaluate() {
        return (0, _val.val)(this._what);
      }
    }, {
      key: "toString",
      value: function toString() {
        return "AnimatedFunction, id: " + this.__nodeID;
      }
    }]);
    return AnimatedFunction;
  }(_AnimatedNode2.default);

  function createAnimatedFunction(cb) {
    var params = new Array(cb.length);

    for (var i = 0; i < params.length; i++) {
      params[i] = (0, _AnimatedParam.createAnimatedParam)();
    }

    var what = cb.apply(void 0, params);
    var func = (0, _construct2.default)(AnimatedFunction, [what].concat(params));
    return function () {
      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
        args[_key2] = arguments[_key2];
      }

      if (args.length !== params.length) {
        throw new Error('Parameter mismatch when calling reanimated function. Expected ' + params.length + ' parameters, got ' + args.length + '.');
      }

      return (0, _AnimatedCallFunc.createAnimatedCallFunc)(func, args, params);
    };
  }
},559,[1,98,24,25,32,34,37,542,560,548,541,248],"node_modules/react-native-reanimated/src/core/AnimatedFunction.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireWildcard");

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.createAnimatedCallFunc = createAnimatedCallFunc;

  var _toConsumableArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/toConsumableArray"));

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "@babel/runtime/helpers/inherits"));

  var _AnimatedNode2 = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[8], "./AnimatedNode"));

  var _AnimatedBlock = _$$_REQUIRE(_dependencyMap[9], "./AnimatedBlock");

  var _val = _$$_REQUIRE(_dependencyMap[10], "../val");

  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[11], "fbjs/lib/invariant"));

  var AnimatedCallFunc = function (_AnimatedNode) {
    (0, _inherits2.default)(AnimatedCallFunc, _AnimatedNode);

    function AnimatedCallFunc(what, args, params) {
      var _this;

      (0, _classCallCheck2.default)(this, AnimatedCallFunc);
      (0, _invariant.default)(what instanceof _AnimatedNode2.default, "Reanimated: AnimatedCallFunc 'what' argument should be of type AnimatedNode but got " + what);
      (0, _invariant.default)(args.every(function (el) {
        return el instanceof _AnimatedNode2.default;
      }), "Reanimated: every AnimatedCallFunc 'args' argument should be of type AnimatedNode but got " + args);
      (0, _invariant.default)(params.every(function (el) {
        return el instanceof _AnimatedNode2.default;
      }), "Reanimated: every AnimatedCallFunc 'params' argument should be of type AnimatedNode but got " + params);
      _this = (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(AnimatedCallFunc).call(this, {
        type: 'callfunc',
        what: what,
        args: args,
        params: params
      }, (0, _toConsumableArray2.default)(args)));
      _this._what = what;
      _this._args = args;
      _this._params = params;
      return _this;
    }

    (0, _createClass2.default)(AnimatedCallFunc, [{
      key: "toString",
      value: function toString() {
        return "AnimatedCallFunc, id: " + this.__nodeID;
      }
    }, {
      key: "beginContext",
      value: function beginContext() {
        var _this2 = this;

        this._previousCallID = (0, _AnimatedNode2.getCallID)();
        (0, _AnimatedNode2.setCallID)((0, _AnimatedNode2.getCallID)() + '/' + this.__nodeID);

        this._params.forEach(function (param, index) {
          param.beginContext(_this2._args[index], _this2._previousCallID);
        });
      }
    }, {
      key: "endContext",
      value: function endContext() {
        this._params.forEach(function (param, index) {
          param.endContext();
        });

        (0, _AnimatedNode2.setCallID)(this._previousCallID);
      }
    }, {
      key: "__onEvaluate",
      value: function __onEvaluate() {
        this.beginContext();
        var value = (0, _val.val)(this._what);
        this.endContext();
        return value;
      }
    }]);
    return AnimatedCallFunc;
  }(_AnimatedNode2.default);

  function createAnimatedCallFunc(proc, args, params) {
    return new AnimatedCallFunc(proc, args.map(function (p) {
      return (0, _AnimatedBlock.adapt)(p);
    }), params);
  }
},560,[9,1,20,24,25,32,34,37,542,540,541,248],"node_modules/react-native-reanimated/src/core/AnimatedCallFunc.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.evaluateOnce = evaluateOnce;

  var _InternalAnimatedValue = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "../core/InternalAnimatedValue"));

  var _AnimatedSet = _$$_REQUIRE(_dependencyMap[2], "../core/AnimatedSet");

  var _AnimatedCall = _$$_REQUIRE(_dependencyMap[3], "../core/AnimatedCall");

  var _AnimatedAlways = _$$_REQUIRE(_dependencyMap[4], "../core/AnimatedAlways");

  var _AnimatedCond = _$$_REQUIRE(_dependencyMap[5], "../core/AnimatedCond");

  function evaluateOnce(node) {
    var input = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
    var callback = arguments.length > 2 ? arguments[2] : undefined;

    if (!Array.isArray(input)) {
      input = [input];
    }

    var done = new _InternalAnimatedValue.default(0);
    var evalNode = (0, _AnimatedCond.createAnimatedCond)(done, 0, (0, _AnimatedCall.createAnimatedCall)([node, (0, _AnimatedSet.createAnimatedSet)(done, 1)], function () {
      callback && callback();

      for (var i = 0; i < input.length; i++) {
        input[i].__removeChild(alwaysNode);

        alwaysNode.__detach();
      }
    }));
    var alwaysNode = (0, _AnimatedAlways.createAnimatedAlways)(evalNode);

    for (var i = 0; i < input.length; i++) {
      input[i].__addChild(alwaysNode);

      alwaysNode.__attach();
    }
  }
},561,[1,544,545,552,562,539],"node_modules/react-native-reanimated/src/derived/evaluateOnce.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.createAnimatedAlways = createAnimatedAlways;

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits"));

  var _AnimatedNode2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "./AnimatedNode"));

  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "fbjs/lib/invariant"));

  var _val = _$$_REQUIRE(_dependencyMap[8], "../val");

  var AnimatedAlways = function (_AnimatedNode) {
    (0, _inherits2.default)(AnimatedAlways, _AnimatedNode);

    function AnimatedAlways(what) {
      var _this;

      (0, _classCallCheck2.default)(this, AnimatedAlways);
      (0, _invariant.default)(what instanceof _AnimatedNode2.default, "Reanimated: Animated.always node argument should be of type AnimatedNode but got " + what);
      _this = (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(AnimatedAlways).call(this, {
        type: 'always',
        what: what
      }, [what]));
      _this._what = what;
      return _this;
    }

    (0, _createClass2.default)(AnimatedAlways, [{
      key: "toString",
      value: function toString() {
        return "AnimatedAlways, id: " + this.__nodeID;
      }
    }, {
      key: "update",
      value: function update() {
        this.__getValue();
      }
    }, {
      key: "__onEvaluate",
      value: function __onEvaluate() {
        (0, _val.val)(this._what);
        return 0;
      }
    }]);
    return AnimatedAlways;
  }(_AnimatedNode2.default);

  function createAnimatedAlways(item) {
    return new AnimatedAlways(item);
  }
},562,[1,24,25,32,34,37,542,248,541],"node_modules/react-native-reanimated/src/core/AnimatedAlways.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = createEventObjectProxyPolyfill;

  function createEventObjectProxyPolyfill() {
    var nodesMap = {
      translationX: {},
      translationY: {},
      state: {},
      oldState: {},
      absoluteX: {},
      absoluteY: {},
      x: {},
      y: {},
      velocityX: {},
      velocityY: {},
      scale: {},
      focalX: {},
      focalY: {},
      rotation: {},
      anchorX: {},
      anchorY: {},
      velocity: {},
      numberOfPointers: {},
      layout: {
        x: {},
        y: {},
        width: {},
        height: {}
      },
      contentOffset: {
        y: {},
        x: {}
      },
      layoutMeasurement: {
        width: {},
        height: {}
      },
      contentSize: {
        width: {},
        height: {}
      },
      zoomScale: {},
      contentInset: {
        right: {},
        top: {},
        left: {},
        bottom: {}
      }
    };

    var traverse = function traverse(obj) {
      for (var key in obj) {
        obj[key].__isProxy = true;
        traverse(obj[key]);
      }
    };

    traverse(nodesMap);
    return nodesMap;
  }
},563,[],"node_modules/react-native-reanimated/src/core/createEventObjectProxyPolyfill.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.createAnimatedConcat = createAnimatedConcat;

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits"));

  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "fbjs/lib/invariant"));

  var _AnimatedBlock = _$$_REQUIRE(_dependencyMap[7], "../core/AnimatedBlock");

  var _AnimatedNode2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "./AnimatedNode"));

  var _val = _$$_REQUIRE(_dependencyMap[9], "../val");

  var AnimatedConcat = function (_AnimatedNode) {
    (0, _inherits2.default)(AnimatedConcat, _AnimatedNode);

    function AnimatedConcat(input) {
      var _this;

      (0, _classCallCheck2.default)(this, AnimatedConcat);
      (0, _invariant.default)(input.every(function (el) {
        return el instanceof _AnimatedNode2.default || typeof el === 'number' || typeof el === 'string';
      }), "Reanimated: Animated.concat node arguments should be of type AnimatedNode or String or Number. One or more of them are not of that type. Node: " + input);
      _this = (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(AnimatedConcat).call(this, {
        type: 'concat',
        input: input
      }, input));
      _this._input = input;
      return _this;
    }

    (0, _createClass2.default)(AnimatedConcat, [{
      key: "__onEvaluate",
      value: function __onEvaluate() {
        return this._input.reduce(function (prev, current) {
          return prev + (0, _val.val)(current);
        }, '');
      }
    }, {
      key: "toString",
      value: function toString() {
        return "AnimatedConcat, id: " + this.__nodeID;
      }
    }]);
    return AnimatedConcat;
  }(_AnimatedNode2.default);

  function createAnimatedConcat() {
    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
      args[_key] = arguments[_key];
    }

    return new AnimatedConcat(args.map(_AnimatedBlock.adapt));
  }
},564,[1,24,25,32,34,37,248,540,542,541],"node_modules/react-native-reanimated/src/core/AnimatedConcat.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits"));

  var _val = _$$_REQUIRE(_dependencyMap[6], "../val");

  var _AnimatedNode2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "./AnimatedNode"));

  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "fbjs/lib/invariant"));

  var NEWTON_ITERATIONS = 4;
  var NEWTON_MIN_SLOPE = 0.001;
  var SUBDIVISION_PRECISION = 0.0000001;
  var SUBDIVISION_MAX_ITERATIONS = 10;
  var kSplineTableSize = 11;
  var kSampleStepSize = 1.0 / (kSplineTableSize - 1.0);
  var float32ArraySupported = typeof Float32Array === 'function';

  function A(aA1, aA2) {
    return 1.0 - 3.0 * aA2 + 3.0 * aA1;
  }

  function B(aA1, aA2) {
    return 3.0 * aA2 - 6.0 * aA1;
  }

  function C(aA1) {
    return 3.0 * aA1;
  }

  function calcBezier(aT, aA1, aA2) {
    return ((A(aA1, aA2) * aT + B(aA1, aA2)) * aT + C(aA1)) * aT;
  }

  function getSlope(aT, aA1, aA2) {
    return 3.0 * A(aA1, aA2) * aT * aT + 2.0 * B(aA1, aA2) * aT + C(aA1);
  }

  function binarySubdivide(aX, aA, aB, mX1, mX2) {
    var currentX = 0;
    var currentT = 0;
    var i = 0;

    do {
      currentT = aA + (aB - aA) / 2.0;
      currentX = calcBezier(currentT, mX1, mX2) - aX;

      if (currentX > 0.0) {
        aB = currentT;
      } else {
        aA = currentT;
      }
    } while (Math.abs(currentX) > SUBDIVISION_PRECISION && ++i < SUBDIVISION_MAX_ITERATIONS);

    return currentT;
  }

  function newtonRaphsonIterate(aX, aGuessT, mX1, mX2) {
    for (var i = 0; i < NEWTON_ITERATIONS; ++i) {
      var currentSlope = getSlope(aGuessT, mX1, mX2);

      if (currentSlope === 0.0) {
        return aGuessT;
      }

      var currentX = calcBezier(aGuessT, mX1, mX2) - aX;
      aGuessT -= currentX / currentSlope;
    }

    return aGuessT;
  }

  function bezier(mX1, mY1, mX2, mY2) {
    var sampleValues = float32ArraySupported ? new Float32Array(kSplineTableSize) : new Array(kSplineTableSize);

    if (mX1 !== mY1 || mX2 !== mY2) {
      for (var i = 0; i < kSplineTableSize; ++i) {
        sampleValues[i] = calcBezier(i * kSampleStepSize, mX1, mX2);
      }
    }

    function getTForX(aX) {
      var intervalStart = 0.0;
      var currentSample = 1;
      var lastSample = kSplineTableSize - 1;

      for (; currentSample !== lastSample && sampleValues[currentSample] <= aX; ++currentSample) {
        intervalStart += kSampleStepSize;
      }

      --currentSample;
      var dist = (aX - sampleValues[currentSample]) / (sampleValues[currentSample + 1] - sampleValues[currentSample]);
      var guessForT = intervalStart + dist * kSampleStepSize;
      var initialSlope = getSlope(guessForT, mX1, mX2);

      if (initialSlope >= NEWTON_MIN_SLOPE) {
        return newtonRaphsonIterate(aX, guessForT, mX1, mX2);
      } else if (initialSlope === 0.0) {
        return guessForT;
      } else {
        return binarySubdivide(aX, intervalStart, intervalStart + kSampleStepSize, mX1, mX2);
      }
    }

    return function BezierEasing(x) {
      if (mX1 === mY1 && mX2 === mY2) {
        return x;
      }

      if (x === 0) {
        return 0;
      }

      if (x === 1) {
        return 1;
      }

      return calcBezier(getTForX(x), mY1, mY2);
    };
  }

  var AnimatedBezier = function (_AnimatedNode) {
    (0, _inherits2.default)(AnimatedBezier, _AnimatedNode);

    function AnimatedBezier(value, mX1, mY1, mX2, mY2) {
      var _this;

      (0, _classCallCheck2.default)(this, AnimatedBezier);
      (0, _invariant.default)(value instanceof _AnimatedNode2.default, "Reanimated: Bezier node argument should be of type AnimatedNode but got " + value);
      _this = (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(AnimatedBezier).call(this, {
        type: 'bezier',
        mX1: mX1,
        mY1: mY1,
        mX2: mX2,
        mY2: mY2,
        input: value
      }, [value]));
      _this._value = value;
      _this._bezier = bezier(mX1, mY1, mX2, mY2);
      return _this;
    }

    (0, _createClass2.default)(AnimatedBezier, [{
      key: "toString",
      value: function toString() {
        return "AnimatedBezier, id: " + this.__nodeID;
      }
    }, {
      key: "__onEvaluate",
      value: function __onEvaluate() {
        return this._bezier((0, _val.val)(this._value));
      }
    }]);
    return AnimatedBezier;
  }(_AnimatedNode2.default);

  exports.default = AnimatedBezier;
},565,[1,24,25,32,34,37,541,542,248],"node_modules/react-native-reanimated/src/core/AnimatedBezier.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits"));

  var _react = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "react"));

  var _AnimatedAlways = _$$_REQUIRE(_dependencyMap[7], "./AnimatedAlways");

  var _AnimatedNode = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "./AnimatedNode"));

  var Code = function (_React$PureComponent) {
    (0, _inherits2.default)(Code, _React$PureComponent);

    function Code() {
      (0, _classCallCheck2.default)(this, Code);
      return (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(Code).apply(this, arguments));
    }

    (0, _createClass2.default)(Code, [{
      key: "componentDidMount",
      value: function componentDidMount() {
        var _this$props = this.props,
            children = _this$props.children,
            exec = _this$props.exec;
        var nodeChildren = Code.resolveNode(children);
        var nodeExec = Code.resolveNode(exec);
        var cantResolveNode = nodeChildren === null && nodeExec === null;

        if (cantResolveNode) {
          var error = nodeChildren === null ? "Got \"" + typeof children + "\" type passed to children" : "Got \"" + typeof exec + "\" type passed to exec";
          throw new Error("<Animated.Code /> expects the 'exec' prop or children to be an animated node or a function returning an animated node. " + error);
        }

        this.always = (0, _AnimatedAlways.createAnimatedAlways)(nodeExec || nodeChildren);

        this.always.__attach();
      }
    }, {
      key: "componentWillUnmount",
      value: function componentWillUnmount() {
        this.always.__detach();
      }
    }, {
      key: "componentDidUpdate",
      value: function componentDidUpdate() {
        this.componentWillUnmount();
        this.componentDidMount();
      }
    }, {
      key: "render",
      value: function render() {
        return null;
      }
    }]);
    return Code;
  }(_react.default.PureComponent);

  Code.resolveNode = function (maybeNode) {
    if (typeof maybeNode === 'function') {
      return Code.resolveNode(maybeNode());
    }

    if (maybeNode instanceof _AnimatedNode.default) {
      return maybeNode;
    }

    return null;
  };

  var _default = Code;
  exports.default = _default;
},566,[1,24,25,32,34,37,54,562,542],"node_modules/react-native-reanimated/src/core/AnimatedCode.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireWildcard");

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  Object.defineProperty(exports, "abs", {
    enumerable: true,
    get: function get() {
      return _abs.default;
    }
  });
  Object.defineProperty(exports, "acc", {
    enumerable: true,
    get: function get() {
      return _acc.default;
    }
  });
  Object.defineProperty(exports, "color", {
    enumerable: true,
    get: function get() {
      return _color.default;
    }
  });
  Object.defineProperty(exports, "diff", {
    enumerable: true,
    get: function get() {
      return _diff.default;
    }
  });
  Object.defineProperty(exports, "diffClamp", {
    enumerable: true,
    get: function get() {
      return _diffClamp.default;
    }
  });
  Object.defineProperty(exports, "interpolate", {
    enumerable: true,
    get: function get() {
      return _interpolate.default;
    }
  });
  Object.defineProperty(exports, "Extrapolate", {
    enumerable: true,
    get: function get() {
      return _interpolate.Extrapolate;
    }
  });
  Object.defineProperty(exports, "max", {
    enumerable: true,
    get: function get() {
      return _max.default;
    }
  });
  Object.defineProperty(exports, "min", {
    enumerable: true,
    get: function get() {
      return _min.default;
    }
  });
  Object.defineProperty(exports, "onChange", {
    enumerable: true,
    get: function get() {
      return _onChange.default;
    }
  });
  Object.defineProperty(exports, "floor", {
    enumerable: true,
    get: function get() {
      return _floor.default;
    }
  });
  Object.defineProperty(exports, "ceil", {
    enumerable: true,
    get: function get() {
      return _ceil.default;
    }
  });
  Object.defineProperty(exports, "useCode", {
    enumerable: true,
    get: function get() {
      return _useCode.default;
    }
  });

  var _abs = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "./abs"));

  var _acc = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "./acc"));

  var _color = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "./color"));

  var _diff = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "./diff"));

  var _diffClamp = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "./diffClamp"));

  var _interpolate = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[7], "./interpolate"));

  var _max = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "./max"));

  var _min = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "./min"));

  var _onChange = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[10], "./onChange"));

  var _floor = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[11], "./floor"));

  var _ceil = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[12], "./ceil"));

  var _useCode = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[13], "./useCode"));
},567,[9,1,568,569,570,571,572,556,574,573,575,576,577,578],"node_modules/react-native-reanimated/src/derived/index.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _base = _$$_REQUIRE(_dependencyMap[0], "../base");

  var _default = (0, _base.proc)(function abs(a) {
    return (0, _base.cond)((0, _base.lessThan)(a, 0), (0, _base.multiply)(-1, a), a);
  });

  exports.default = _default;
},568,[538],"node_modules/react-native-reanimated/src/derived/abs.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = acc;

  var _base = _$$_REQUIRE(_dependencyMap[1], "../base");

  var _InternalAnimatedValue = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../core/InternalAnimatedValue"));

  var procAcc = (0, _base.proc)(function (v, acc) {
    return (0, _base.set)(acc, (0, _base.add)(acc, v));
  });

  function acc(v) {
    var acc = new _InternalAnimatedValue.default(0);
    return procAcc(v, acc);
  }
},569,[1,538,544],"node_modules/react-native-reanimated/src/derived/acc.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = color;

  var _reactNative = _$$_REQUIRE(_dependencyMap[1], "react-native");

  var _base = _$$_REQUIRE(_dependencyMap[2], "../base");

  var _AnimatedNode = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../core/AnimatedNode"));

  var procColor = (0, _base.proc)(function (r, g, b, a) {
    var color = (0, _base.add)((0, _base.multiply)(a, 1 << 24), (0, _base.multiply)(r, 1 << 16), (0, _base.multiply)(g, 1 << 8), b);

    if (_reactNative.Platform.OS === 'android') {
      return (0, _base.cond)((0, _base.lessThan)(color, 1 << 31 >>> 0), color, (0, _base.sub)(color, Math.pow(2, 32)));
    }

    return color;
  });

  function color(r, g, b) {
    var a = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 1;

    if (_reactNative.Platform.OS === 'web') {
      return (0, _base.concat)('rgba(', r, ',', g, ',', b, ',', a, ')');
    }

    if (a instanceof _AnimatedNode.default) {
      a = (0, _base.round)((0, _base.multiply)(a, 255));
    } else {
      a = Math.round(a * 255);
    }

    return procColor(r, g, b, a);
  }
},570,[1,2,538,542],"node_modules/react-native-reanimated/src/derived/color.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = diff;

  var _base = _$$_REQUIRE(_dependencyMap[1], "../base");

  var _InternalAnimatedValue = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../core/InternalAnimatedValue"));

  var procDiff = (0, _base.proc)(function (v, stash, prev) {
    return (0, _base.block)([(0, _base.set)(stash, (0, _base.cond)((0, _base.defined)(prev), (0, _base.sub)(v, prev), 0)), (0, _base.set)(prev, v), stash]);
  });

  function diff(v) {
    var stash = new _InternalAnimatedValue.default(0);
    var prev = new _InternalAnimatedValue.default();
    return procDiff(v, stash, prev);
  }
},571,[1,538,544],"node_modules/react-native-reanimated/src/derived/diff.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = diffClamp;

  var _base = _$$_REQUIRE(_dependencyMap[1], "../base");

  var _InternalAnimatedValue = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../core/InternalAnimatedValue"));

  var _min = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "./min"));

  var _max = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "./max"));

  var _diff = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "./diff"));

  var procAcc = (0, _base.proc)(function (a, minVal, maxVal, value) {
    return (0, _base.set)(value, (0, _min.default)((0, _max.default)((0, _base.add)((0, _base.cond)((0, _base.defined)(value), value, a), (0, _diff.default)(a)), minVal), maxVal));
  });

  function diffClamp(a, minVal, maxVal) {
    var value = new _InternalAnimatedValue.default();
    return procAcc(a, minVal, maxVal, value);
  }
},572,[1,538,544,573,574,571],"node_modules/react-native-reanimated/src/derived/diffClamp.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = min;

  var _base = _$$_REQUIRE(_dependencyMap[0], "../base");

  var _AnimatedBlock = _$$_REQUIRE(_dependencyMap[1], "../core/AnimatedBlock");

  function min(a, b) {
    a = (0, _AnimatedBlock.adapt)(a);
    b = (0, _AnimatedBlock.adapt)(b);
    return (0, _base.cond)((0, _base.lessThan)(a, b), a, b);
  }
},573,[538,540],"node_modules/react-native-reanimated/src/derived/min.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = max;

  var _base = _$$_REQUIRE(_dependencyMap[0], "../base");

  var _AnimatedBlock = _$$_REQUIRE(_dependencyMap[1], "../core/AnimatedBlock");

  function max(a, b) {
    a = (0, _AnimatedBlock.adapt)(a);
    b = (0, _AnimatedBlock.adapt)(b);
    return (0, _base.cond)((0, _base.lessThan)(a, b), b, a);
  }
},574,[538,540],"node_modules/react-native-reanimated/src/derived/max.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = onChange;

  var _base = _$$_REQUIRE(_dependencyMap[1], "../base");

  var _InternalAnimatedValue = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../core/InternalAnimatedValue"));

  var procOnChange = (0, _base.proc)(function (value, action, prevValue) {
    return (0, _base.block)([(0, _base.cond)((0, _base.not)((0, _base.defined)(prevValue)), (0, _base.set)(prevValue, value)), (0, _base.cond)((0, _base.neq)(value, prevValue), [(0, _base.set)(prevValue, value), action])]);
  });

  function onChange(value, action) {
    var prevValue = new _InternalAnimatedValue.default();
    return procOnChange(value, action, prevValue);
  }
},575,[1,538,544],"node_modules/react-native-reanimated/src/derived/onChange.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = floor;

  var _base = _$$_REQUIRE(_dependencyMap[0], "../base");

  function floor(a) {
    return (0, _base.round)((0, _base.sub)(a, 0.5 - 1e-8));
  }
},576,[538],"node_modules/react-native-reanimated/src/derived/floor.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _base = _$$_REQUIRE(_dependencyMap[0], "../base");

  var _default = (0, _base.proc)(function ceil(a) {
    return (0, _base.sub)(1, (0, _base.round)((0, _base.sub)(0.5, a)));
  });

  exports.default = _default;
},577,[538],"node_modules/react-native-reanimated/src/derived/ceil.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = useCode;

  var _react = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "react"));

  var _base = _$$_REQUIRE(_dependencyMap[2], "../base");

  function useCode(nodeFactory, dependencies) {
    if (!(_react.default.useEffect instanceof Function)) return;

    _react.default.useEffect(function () {
      if (!(nodeFactory instanceof Function)) {
        console.warn('useCode() first argument should be a function that returns an animation node.');
        var _node = nodeFactory;

        nodeFactory = function nodeFactory() {
          return _node;
        };
      }

      var node = nodeFactory();

      if (node) {
        if (node instanceof Array) node = (0, _base.block)(node);
        var animatedAlways = (0, _base.always)(node);

        animatedAlways.__attach();

        return function () {
          return animatedAlways.__detach();
        };
      }
    }, dependencies);
  }
},578,[1,54,538],"node_modules/react-native-reanimated/src/derived/useCode.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = createAnimatedComponent;

  var _extends2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/extends"));

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits"));

  var _react = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "react"));

  var _reactNative = _$$_REQUIRE(_dependencyMap[8], "react-native");

  var _ReanimatedEventEmitter = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "./ReanimatedEventEmitter"));

  var _AnimatedEvent = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[10], "./core/AnimatedEvent"));

  var _AnimatedNode = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[11], "./core/AnimatedNode"));

  var _AnimatedProps = _$$_REQUIRE(_dependencyMap[12], "./core/AnimatedProps");

  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[13], "fbjs/lib/invariant"));

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native-reanimated/src/createAnimatedComponent.js";
  var NODE_MAPPING = new Map();

  function listener(data) {
    var component = NODE_MAPPING.get(data.viewTag);
    component && component._updateFromNative(data.props);
  }

  function dummyListener() {}

  function createAnimatedComponent(Component) {
    (0, _invariant.default)(typeof Component !== 'function' || Component.prototype && Component.prototype.isReactComponent, '`createAnimatedComponent` does not support stateless functional components; ' + 'use a class component instead.');

    var AnimatedComponent = function (_React$Component) {
      (0, _inherits2.default)(AnimatedComponent, _React$Component);

      function AnimatedComponent(props) {
        var _this;

        (0, _classCallCheck2.default)(this, AnimatedComponent);
        _this = (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(AnimatedComponent).call(this, props));
        _this._invokeAnimatedPropsCallbackOnMount = false;

        _this._animatedPropsCallback = function () {
          if (_this._component == null) {
            _this._invokeAnimatedPropsCallbackOnMount = true;
          } else if (typeof _this._component.setNativeProps !== 'function') {
            _this.forceUpdate();
          } else {
            _this._component.setNativeProps(_this._propsAnimated.__getValue());
          }
        };

        _this._setComponentRef = function (c) {
          if (c !== _this._component) {
            _this._component = c;
          }
        };

        _this._attachProps(_this.props);

        return _this;
      }

      (0, _createClass2.default)(AnimatedComponent, [{
        key: "componentWillUnmount",
        value: function componentWillUnmount() {
          this._detachPropUpdater();

          this._propsAnimated && this._propsAnimated.__detach();

          this._detachNativeEvents();
        }
      }, {
        key: "setNativeProps",
        value: function setNativeProps(props) {
          this._component.setNativeProps(props);
        }
      }, {
        key: "componentDidMount",
        value: function componentDidMount() {
          if (this._invokeAnimatedPropsCallbackOnMount) {
            this._invokeAnimatedPropsCallbackOnMount = false;

            this._animatedPropsCallback();
          }

          this._propsAnimated.setNativeView(this._component);

          this._attachNativeEvents();

          this._attachPropUpdater();
        }
      }, {
        key: "_getEventViewRef",
        value: function _getEventViewRef() {
          return this._component.getScrollableNode ? this._component.getScrollableNode() : this._component;
        }
      }, {
        key: "_attachNativeEvents",
        value: function _attachNativeEvents() {
          var node = this._getEventViewRef();

          for (var key in this.props) {
            var prop = this.props[key];

            if (prop instanceof _AnimatedEvent.default) {
              prop.attachEvent(node, key);
            }
          }
        }
      }, {
        key: "_detachNativeEvents",
        value: function _detachNativeEvents() {
          var node = this._getEventViewRef();

          for (var key in this.props) {
            var prop = this.props[key];

            if (prop instanceof _AnimatedEvent.default) {
              prop.detachEvent(node, key);
            }
          }
        }
      }, {
        key: "_reattachNativeEvents",
        value: function _reattachNativeEvents(prevProps) {
          var node = this._getEventViewRef();

          var attached = new Set();
          var nextEvts = new Set();

          for (var key in this.props) {
            var prop = this.props[key];

            if (prop instanceof _AnimatedEvent.default) {
              nextEvts.add(prop.__nodeID);
            }
          }

          for (var _key in prevProps) {
            var _prop = this.props[_key];

            if (_prop instanceof _AnimatedEvent.default) {
              if (!nextEvts.has(_prop.__nodeID)) {
                _prop.detachEvent(node, _key);
              } else {
                attached.add(_prop.__nodeID);
              }
            }
          }

          for (var _key2 in this.props) {
            var _prop2 = this.props[_key2];

            if (_prop2 instanceof _AnimatedEvent.default && !attached.has(_prop2.__nodeID)) {
              _prop2.attachEvent(node, _key2);
            }
          }
        }
      }, {
        key: "_attachProps",
        value: function _attachProps(nextProps) {
          var oldPropsAnimated = this._propsAnimated;
          this._propsAnimated = (0, _AnimatedProps.createOrReusePropsNode)(nextProps, this._animatedPropsCallback, oldPropsAnimated);

          if (oldPropsAnimated !== this._propsAnimated) {
            oldPropsAnimated && oldPropsAnimated.__detach();
          }
        }
      }, {
        key: "_updateFromNative",
        value: function _updateFromNative(props) {
          this._component.setNativeProps(props);
        }
      }, {
        key: "_attachPropUpdater",
        value: function _attachPropUpdater() {
          var viewTag = (0, _reactNative.findNodeHandle)(this);
          NODE_MAPPING.set(viewTag, this);

          if (NODE_MAPPING.size === 1) {
            _ReanimatedEventEmitter.default.addListener('onReanimatedPropsChange', listener);
          }
        }
      }, {
        key: "_detachPropUpdater",
        value: function _detachPropUpdater() {
          var viewTag = (0, _reactNative.findNodeHandle)(this);
          NODE_MAPPING.delete(viewTag);

          if (NODE_MAPPING.size === 0) {
            _ReanimatedEventEmitter.default.removeAllListeners('onReanimatedPropsChange');
          }
        }
      }, {
        key: "componentDidUpdate",
        value: function componentDidUpdate(prevProps) {
          this._attachProps(this.props);

          this._reattachNativeEvents(prevProps);

          this._propsAnimated.setNativeView(this._component);
        }
      }, {
        key: "_filterNonAnimatedStyle",
        value: function _filterNonAnimatedStyle(inputStyle) {
          var style = {};

          for (var key in inputStyle) {
            var value = inputStyle[key];

            if (!(value instanceof _AnimatedNode.default) && key !== 'transform') {
              style[key] = value;
            }
          }

          return style;
        }
      }, {
        key: "_filterNonAnimatedProps",
        value: function _filterNonAnimatedProps(inputProps) {
          var props = {};

          for (var key in inputProps) {
            var value = inputProps[key];

            if (key === 'style') {
              props[key] = this._filterNonAnimatedStyle(_reactNative.StyleSheet.flatten(value));
            } else if (value instanceof _AnimatedEvent.default) {
              props[key] = dummyListener;
            } else if (!(value instanceof _AnimatedNode.default)) {
              props[key] = value;
            }
          }

          return props;
        }
      }, {
        key: "render",
        value: function render() {
          var props = this._filterNonAnimatedProps(this.props);

          var platformProps = _reactNative.Platform.select({
            web: {},
            default: {
              collapsable: false
            }
          });

          return _react.default.createElement(Component, (0, _extends2.default)({}, props, {
            ref: this._setComponentRef
          }, platformProps, {
            __source: {
              fileName: _jsxFileName,
              lineNumber: 233
            }
          }));
        }
      }, {
        key: "getNode",
        value: function getNode() {
          return this._component;
        }
      }]);
      return AnimatedComponent;
    }(_react.default.Component);

    AnimatedComponent.displayName = "AnimatedComponent(" + (Component.displayName || Component.name || 'Component') + ")";
    return AnimatedComponent;
  }
},579,[1,13,24,25,32,34,37,54,2,553,554,542,580,248],"node_modules/react-native-reanimated/src/createAnimatedComponent.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.createOrReusePropsNode = createOrReusePropsNode;

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));

  var _get2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/get"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits"));

  var _defineProperty2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "@babel/runtime/helpers/defineProperty"));

  var _reactNative = _$$_REQUIRE(_dependencyMap[8], "react-native");

  var _AnimatedNode2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "./AnimatedNode"));

  var _AnimatedEvent = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[10], "./AnimatedEvent"));

  var _AnimatedStyle = _$$_REQUIRE(_dependencyMap[11], "./AnimatedStyle");

  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[12], "fbjs/lib/invariant"));

  var _areEqual = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[13], "fbjs/lib/areEqual"));

  var _val = _$$_REQUIRE(_dependencyMap[14], "../val");

  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

  function sanitizeProps(inputProps) {
    var props = {};

    for (var key in inputProps) {
      var value = inputProps[key];

      if (value instanceof _AnimatedNode2.default && !(value instanceof _AnimatedEvent.default)) {
        props[key] = value.__nodeID;
      }
    }

    return props;
  }

  function createOrReusePropsNode(props, callback, oldNode) {
    if (props.style) {
      props = _objectSpread({}, props, {
        style: (0, _AnimatedStyle.createOrReuseStyleNode)(props.style, oldNode && oldNode._props.style)
      });
    }

    var config = sanitizeProps(props);

    if (oldNode && (0, _areEqual.default)(config, oldNode._config)) {
      return oldNode;
    }

    return new AnimatedProps(props, config, callback);
  }

  var AnimatedProps = function (_AnimatedNode) {
    (0, _inherits2.default)(AnimatedProps, _AnimatedNode);

    function AnimatedProps(props, config, callback) {
      var _this;

      (0, _classCallCheck2.default)(this, AnimatedProps);
      _this = (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(AnimatedProps).call(this, {
        type: 'props',
        props: config
      }, Object.values(props).filter(function (n) {
        return !(n instanceof _AnimatedEvent.default);
      })));
      _this._config = config;
      _this._props = props;
      _this._callback = callback;

      _this.__attach();

      return _this;
    }

    (0, _createClass2.default)(AnimatedProps, [{
      key: "toString",
      value: function toString() {
        return "AnimatedProps, id: " + this.__nodeID;
      }
    }, {
      key: "__onEvaluate",
      value: function __onEvaluate() {
        var props = {};

        for (var key in this._props) {
          var value = this._props[key];

          if (value instanceof _AnimatedNode2.default) {
            props[key] = value.__getValue();
          }
        }

        return props;
      }
    }, {
      key: "__detach",
      value: function __detach() {
        var nativeViewTag = (0, _reactNative.findNodeHandle)(this._animatedView);
        (0, _invariant.default)(nativeViewTag != null, 'Unable to locate attached view in the native tree');

        this._disconnectAnimatedView(nativeViewTag);

        (0, _get2.default)((0, _getPrototypeOf2.default)(AnimatedProps.prototype), "__detach", this).call(this);
      }
    }, {
      key: "update",
      value: function update() {
        this._callback();

        if (!this._animatedView) {
          return;
        }

        (0, _val.val)(this);
      }
    }, {
      key: "setNativeView",
      value: function setNativeView(animatedView) {
        if (this._animatedView === animatedView) {
          return;
        }

        this._animatedView = animatedView;
        var nativeViewTag = (0, _reactNative.findNodeHandle)(this._animatedView);
        (0, _invariant.default)(nativeViewTag != null, 'Unable to locate attached view in the native tree');

        this._connectAnimatedView(nativeViewTag);
      }
    }]);
    return AnimatedProps;
  }(_AnimatedNode2.default);
},580,[1,24,25,32,34,35,37,46,2,542,554,581,248,509,541],"node_modules/react-native-reanimated/src/core/AnimatedProps.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.createOrReuseStyleNode = createOrReuseStyleNode;
  exports.default = void 0;

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits"));

  var _defineProperty2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/defineProperty"));

  var _reactNative = _$$_REQUIRE(_dependencyMap[7], "react-native");

  var _AnimatedNode2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "./AnimatedNode"));

  var _AnimatedTransform = _$$_REQUIRE(_dependencyMap[9], "./AnimatedTransform");

  var _areEqual = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[10], "fbjs/lib/areEqual"));

  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

  function sanitizeStyle(inputStyle) {
    var style = {};

    for (var key in inputStyle) {
      var value = inputStyle[key];

      if (value instanceof _AnimatedNode2.default) {
        style[key] = value.__nodeID;
      }
    }

    return style;
  }

  function createOrReuseStyleNode(style, oldNode) {
    style = _reactNative.StyleSheet.flatten(style) || {};

    if (style.transform) {
      style = _objectSpread({}, style, {
        transform: (0, _AnimatedTransform.createOrReuseTransformNode)(style.transform, oldNode && oldNode._style.transform)
      });
    }

    var config = sanitizeStyle(style);

    if (oldNode && (0, _areEqual.default)(config, oldNode._config)) {
      return oldNode;
    }

    return new AnimatedStyle(style, config);
  }

  var AnimatedStyle = function (_AnimatedNode) {
    (0, _inherits2.default)(AnimatedStyle, _AnimatedNode);

    function AnimatedStyle(style, config) {
      var _this;

      (0, _classCallCheck2.default)(this, AnimatedStyle);
      _this = (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(AnimatedStyle).call(this, {
        type: 'style',
        style: config
      }, Object.values(style)));
      _this._config = config;
      _this._style = style;
      return _this;
    }

    (0, _createClass2.default)(AnimatedStyle, [{
      key: "toString",
      value: function toString() {
        return "AnimatedStyle, id: " + this.__nodeID;
      }
    }, {
      key: "_walkStyleAndGetAnimatedValues",
      value: function _walkStyleAndGetAnimatedValues(style) {
        var updatedStyle = {};

        for (var key in style) {
          var value = style[key];

          if (value instanceof _AnimatedNode2.default) {
            updatedStyle[key] = value.__getValue();
          } else if (value && !Array.isArray(value) && typeof value === 'object') {
            updatedStyle[key] = this._walkStyleAndGetAnimatedValues(value);
          }
        }

        return updatedStyle;
      }
    }, {
      key: "__onEvaluate",
      value: function __onEvaluate() {
        return this._walkStyleAndGetAnimatedValues(this._style);
      }
    }]);
    return AnimatedStyle;
  }(_AnimatedNode2.default);

  exports.default = AnimatedStyle;
},581,[1,24,25,32,34,37,46,2,542,582,509],"node_modules/react-native-reanimated/src/core/AnimatedStyle.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.createOrReuseTransformNode = createOrReuseTransformNode;

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits"));

  var _AnimatedNode2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "./AnimatedNode"));

  var _areEqual = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "fbjs/lib/areEqual"));

  function sanitizeTransform(inputTransform) {
    var outputTransform = [];
    inputTransform.forEach(function (transform) {
      for (var key in transform) {
        var value = transform[key];

        if (value instanceof _AnimatedNode2.default) {
          outputTransform.push({
            property: key,
            nodeID: value.__nodeID
          });
        } else {
          outputTransform.push({
            property: key,
            value: value
          });
        }
      }
    });
    return outputTransform;
  }

  function extractAnimatedParentNodes(transform) {
    var parents = [];
    transform.forEach(function (transform) {
      for (var key in transform) {
        var value = transform[key];

        if (value instanceof _AnimatedNode2.default) {
          parents.push(value);
        }
      }
    });
    return parents;
  }

  function createOrReuseTransformNode(transform, oldNode) {
    var config = sanitizeTransform(transform);

    if (oldNode && (0, _areEqual.default)(config, oldNode._config)) {
      return oldNode;
    }

    return new AnimatedTransform(transform, config);
  }

  var AnimatedTransform = function (_AnimatedNode) {
    (0, _inherits2.default)(AnimatedTransform, _AnimatedNode);

    function AnimatedTransform(transform, config) {
      var _this;

      (0, _classCallCheck2.default)(this, AnimatedTransform);
      _this = (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(AnimatedTransform).call(this, {
        type: 'transform',
        transform: config
      }, extractAnimatedParentNodes(transform)));
      _this._config = config;
      _this._transform = transform;
      return _this;
    }

    (0, _createClass2.default)(AnimatedTransform, [{
      key: "toString",
      value: function toString() {
        return "AnimatedTransform, id: " + this.__nodeID;
      }
    }, {
      key: "__onEvaluate",
      value: function __onEvaluate() {
        return this._transform.map(function (transform) {
          var result = {};

          for (var key in transform) {
            var value = transform[key];

            if (value instanceof _AnimatedNode2.default) {
              result[key] = value.__getValue();
            }
          }

          return result;
        });
      }
    }]);
    return AnimatedTransform;
  }(_AnimatedNode2.default);
},582,[1,24,25,32,34,37,542,509],"node_modules/react-native-reanimated/src/core/AnimatedTransform.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _base = _$$_REQUIRE(_dependencyMap[0], "../base");

  var _derived = _$$_REQUIRE(_dependencyMap[1], "../derived");

  var VELOCITY_EPS = 5;

  function decay(clock, state, config) {
    var lastTime = (0, _base.cond)(state.time, state.time, clock);
    var deltaTime = (0, _base.sub)(clock, lastTime);
    var kv = (0, _base.pow)(config.deceleration, deltaTime);
    var kx = (0, _base.divide)((0, _base.multiply)(config.deceleration, (0, _base.sub)(1, kv)), (0, _base.sub)(1, config.deceleration));
    var v0 = (0, _base.divide)(state.velocity, 1000);
    var v = (0, _base.multiply)(v0, kv, 1000);
    var x = (0, _base.add)(state.position, (0, _base.multiply)(v0, kx));
    return (0, _base.block)([(0, _base.set)(state.position, x), (0, _base.set)(state.velocity, v), (0, _base.set)(state.time, clock), (0, _base.cond)((0, _base.lessThan)((0, _derived.abs)(v), VELOCITY_EPS), (0, _base.set)(state.finished, 1))]);
  }

  var procDecay = (0, _base.proc)(function (clock, time, velocity, position, finished, deceleration) {
    return decay(clock, {
      time: time,
      velocity: velocity,
      position: position,
      finished: finished
    }, {
      deceleration: deceleration
    });
  });

  var _default = function _default(clock, _ref, _ref2) {
    var time = _ref.time,
        velocity = _ref.velocity,
        position = _ref.position,
        finished = _ref.finished;
    var deceleration = _ref2.deceleration;
    return procDecay(clock, time, velocity, position, finished, deceleration);
  };

  exports.default = _default;
},583,[538,567],"node_modules/react-native-reanimated/src/animations/decay.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = _default;

  var _base = _$$_REQUIRE(_dependencyMap[0], "../base");

  var internalTiming = (0, _base.proc)(function (clock, time, frameTime, position, finished, toValue, duration, nextProgress, progress, newFrameTime) {
    var state = {
      time: time,
      finished: finished,
      frameTime: frameTime,
      position: position
    };
    var config = {
      duration: duration,
      toValue: toValue
    };
    var distanceLeft = (0, _base.sub)(config.toValue, state.position);
    var fullDistance = (0, _base.divide)(distanceLeft, (0, _base.sub)(1, progress));
    var startPosition = (0, _base.sub)(config.toValue, fullDistance);
    var nextPosition = (0, _base.add)(startPosition, (0, _base.multiply)(fullDistance, nextProgress));
    return (0, _base.block)([(0, _base.cond)((0, _base.greaterOrEq)(newFrameTime, config.duration), [(0, _base.set)(state.position, config.toValue), (0, _base.set)(state.finished, 1)], (0, _base.set)(state.position, nextPosition)), (0, _base.set)(state.frameTime, newFrameTime), (0, _base.set)(state.time, clock)]);
  });

  function _default(clock, state, config) {
    var lastTime = (0, _base.cond)(state.time, state.time, clock);
    var newFrameTime = (0, _base.add)(state.frameTime, (0, _base.sub)(clock, lastTime));
    var nextProgress = config.easing((0, _base.divide)(newFrameTime, config.duration));
    var progress = config.easing((0, _base.divide)(state.frameTime, config.duration));
    return internalTiming(clock, state.time, state.frameTime, state.position, state.finished, config.toValue, config.duration, nextProgress, progress, newFrameTime);
  }
},584,[538],"node_modules/react-native-reanimated/src/animations/timing.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _base = _$$_REQUIRE(_dependencyMap[1], "../base");

  var _derived = _$$_REQUIRE(_dependencyMap[2], "../derived");

  var _InternalAnimatedValue = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "../core/InternalAnimatedValue"));

  var MAX_STEPS_MS = 64;

  function spring(clock, state, config) {
    var lastTime = (0, _base.cond)(state.time, state.time, clock);
    var deltaTime = (0, _derived.min)((0, _base.sub)(clock, lastTime), MAX_STEPS_MS);
    var c = config.damping;
    var m = config.mass;
    var k = config.stiffness;
    var v0 = (0, _base.multiply)(-1, state.velocity);
    var x0 = (0, _base.sub)(config.toValue, state.position);
    var zeta = (0, _base.divide)(c, (0, _base.multiply)(2, (0, _base.sqrt)((0, _base.multiply)(k, m))));
    var omega0 = (0, _base.sqrt)((0, _base.divide)(k, m));
    var omega1 = (0, _base.multiply)(omega0, (0, _base.sqrt)((0, _base.sub)(1, (0, _base.multiply)(zeta, zeta))));
    var t = (0, _base.divide)(deltaTime, 1000);
    var sin1 = (0, _base.sin)((0, _base.multiply)(omega1, t));
    var cos1 = (0, _base.cos)((0, _base.multiply)(omega1, t));
    var underDampedEnvelope = (0, _base.exp)((0, _base.multiply)(-1, zeta, omega0, t));
    var underDampedFrag1 = (0, _base.multiply)(underDampedEnvelope, (0, _base.add)((0, _base.multiply)(sin1, (0, _base.divide)((0, _base.add)(v0, (0, _base.multiply)(zeta, omega0, x0)), omega1)), (0, _base.multiply)(x0, cos1)));
    var underDampedPosition = (0, _base.sub)(config.toValue, underDampedFrag1);
    var underDampedVelocity = (0, _base.sub)((0, _base.multiply)(zeta, omega0, underDampedFrag1), (0, _base.multiply)(underDampedEnvelope, (0, _base.sub)((0, _base.multiply)(cos1, (0, _base.add)(v0, (0, _base.multiply)(zeta, omega0, x0))), (0, _base.multiply)(omega1, x0, sin1))));
    var criticallyDampedEnvelope = (0, _base.exp)((0, _base.multiply)(-1, omega0, t));
    var criticallyDampedPosition = (0, _base.sub)(config.toValue, (0, _base.multiply)(criticallyDampedEnvelope, (0, _base.add)(x0, (0, _base.multiply)((0, _base.add)(v0, (0, _base.multiply)(omega0, x0)), t))));
    var criticallyDampedVelocity = (0, _base.multiply)(criticallyDampedEnvelope, (0, _base.add)((0, _base.multiply)(v0, (0, _base.sub)((0, _base.multiply)(t, omega0), 1)), (0, _base.multiply)(t, x0, omega0, omega0)));
    var prevPosition = state.prevPosition ? state.prevPosition : new _InternalAnimatedValue.default(0);
    var isOvershooting = (0, _base.cond)((0, _base.and)(config.overshootClamping, (0, _base.neq)(config.stiffness, 0)), (0, _base.cond)((0, _base.lessThan)(prevPosition, config.toValue), (0, _base.greaterThan)(state.position, config.toValue), (0, _base.lessThan)(state.position, config.toValue)));
    var isVelocity = (0, _base.lessThan)((0, _derived.abs)(state.velocity), config.restSpeedThreshold);
    var isDisplacement = (0, _base.or)((0, _base.eq)(config.stiffness, 0), (0, _base.lessThan)((0, _derived.abs)((0, _base.sub)(config.toValue, state.position)), config.restDisplacementThreshold));
    return (0, _base.block)([(0, _base.set)(prevPosition, state.position), (0, _base.cond)((0, _base.lessThan)(zeta, 1), [(0, _base.set)(state.position, underDampedPosition), (0, _base.set)(state.velocity, underDampedVelocity)], [(0, _base.set)(state.position, criticallyDampedPosition), (0, _base.set)(state.velocity, criticallyDampedVelocity)]), (0, _base.set)(state.time, clock), (0, _base.cond)((0, _base.or)(isOvershooting, (0, _base.and)(isVelocity, isDisplacement)), [(0, _base.cond)((0, _base.neq)(config.stiffness, 0), [(0, _base.set)(state.velocity, 0), (0, _base.set)(state.position, config.toValue)]), (0, _base.set)(state.finished, 1)])]);
  }

  var procSpring = (0, _base.proc)(function (finished, velocity, position, time, prevPosition, toValue, damping, mass, stiffness, overshootClamping, restSpeedThreshold, restDisplacementThreshold, clock) {
    return spring(clock, {
      finished: finished,
      velocity: velocity,
      position: position,
      time: time,
      prevPosition: prevPosition
    }, {
      toValue: toValue,
      damping: damping,
      mass: mass,
      stiffness: stiffness,
      overshootClamping: overshootClamping,
      restDisplacementThreshold: restDisplacementThreshold,
      restSpeedThreshold: restSpeedThreshold
    });
  });

  var _default = function _default(clock, _ref, _ref2) {
    var finished = _ref.finished,
        velocity = _ref.velocity,
        position = _ref.position,
        time = _ref.time,
        prevPosition = _ref.prevPosition;
    var toValue = _ref2.toValue,
        damping = _ref2.damping,
        mass = _ref2.mass,
        stiffness = _ref2.stiffness,
        overshootClamping = _ref2.overshootClamping,
        restDisplacementThreshold = _ref2.restDisplacementThreshold,
        restSpeedThreshold = _ref2.restSpeedThreshold;
    return procSpring(finished, velocity, position, time, prevPosition, toValue, damping, mass, stiffness, overshootClamping, restSpeedThreshold, restDisplacementThreshold, clock);
  };

  exports.default = _default;
},585,[1,538,567,544],"node_modules/react-native-reanimated/src/animations/spring.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits"));

  var _InternalAnimatedValue = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "../core/InternalAnimatedValue"));

  var _timing = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "./timing"));

  var _base = _$$_REQUIRE(_dependencyMap[8], "../base");

  var _AnimatedClock = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "../core/AnimatedClock"));

  var _Easing = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[10], "../Easing"));

  var _Animation2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[11], "./Animation"));

  var easeInOut = _Easing.default.inOut(_Easing.default.ease);

  var TimingAnimation = function (_Animation) {
    (0, _inherits2.default)(TimingAnimation, _Animation);

    function TimingAnimation(config) {
      var _this;

      (0, _classCallCheck2.default)(this, TimingAnimation);
      _this = (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(TimingAnimation).call(this));
      _this._toValue = config.toValue;
      _this._easing = config.easing !== undefined ? config.easing : easeInOut;
      _this._duration = config.duration !== undefined ? config.duration : 500;
      return _this;
    }

    (0, _createClass2.default)(TimingAnimation, [{
      key: "start",
      value: function start(value) {
        this._clock = new _AnimatedClock.default();
        var state = {
          finished: new _InternalAnimatedValue.default(0),
          position: value,
          time: new _InternalAnimatedValue.default(0),
          frameTime: new _InternalAnimatedValue.default(0)
        };
        var config = {
          duration: this._duration,
          toValue: this._toValue,
          easing: this._easing
        };
        return (0, _base.block)([(0, _base.cond)((0, _base.clockRunning)(this._clock), 0, [(0, _base.startClock)(this._clock)]), (0, _timing.default)(this._clock, state, config), (0, _base.cond)(state.finished, (0, _base.stopClock)(this._clock))]);
      }
    }, {
      key: "stop",
      value: function stop() {}
    }], [{
      key: "getDefaultState",
      value: function getDefaultState() {
        return {
          position: new _InternalAnimatedValue.default(0),
          finished: new _InternalAnimatedValue.default(0),
          time: new _InternalAnimatedValue.default(0),
          frameTime: new _InternalAnimatedValue.default(0)
        };
      }
    }]);
    return TimingAnimation;
  }(_Animation2.default);

  exports.default = TimingAnimation;
},586,[1,24,25,32,34,37,544,584,538,547,537,587],"node_modules/react-native-reanimated/src/animations/TimingAnimation.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));

  var Animation = function () {
    function Animation() {
      (0, _classCallCheck2.default)(this, Animation);
    }

    (0, _createClass2.default)(Animation, [{
      key: "start",
      value: function start(fromValue, onUpdate, onEnd, previousAnimation, animatedValue) {}
    }, {
      key: "stop",
      value: function stop() {}
    }]);
    return Animation;
  }();

  var _default = Animation;
  exports.default = _default;
},587,[1,24,25],"node_modules/react-native-reanimated/src/animations/Animation.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits"));

  var _InternalAnimatedValue = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "../core/InternalAnimatedValue"));

  var _Animation2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "./Animation"));

  var _SpringConfig = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "../SpringConfig"));

  var _spring = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "./spring"));

  var _base = _$$_REQUIRE(_dependencyMap[10], "../base");

  var _AnimatedClock = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[11], "../core/AnimatedClock"));

  var _invariant = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[12], "fbjs/lib/invariant"));

  function withDefault(value, defaultValue) {
    if (value === undefined || value === null) {
      return defaultValue;
    }

    return value;
  }

  var SpringAnimation = function (_Animation) {
    (0, _inherits2.default)(SpringAnimation, _Animation);

    function SpringAnimation(config) {
      var _this;

      (0, _classCallCheck2.default)(this, SpringAnimation);
      _this = (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(SpringAnimation).call(this));
      _this._overshootClamping = withDefault(config.overshootClamping, false);
      _this._restDisplacementThreshold = withDefault(config.restDisplacementThreshold, 0.001);
      _this._restSpeedThreshold = withDefault(config.restSpeedThreshold, 0.001);
      _this._initialVelocity = withDefault(config.velocity, 0);
      _this._lastVelocity = withDefault(config.velocity, 0);
      _this._toValue = config.toValue;
      _this._delay = withDefault(config.delay, 0);

      if (config.stiffness !== undefined || config.damping !== undefined || config.mass !== undefined) {
        (0, _invariant.default)(config.bounciness === undefined && config.speed === undefined && config.tension === undefined && config.friction === undefined, 'You can define one of bounciness/speed, tension/friction, or stiffness/damping/mass, but not more than one');
        _this._stiffness = withDefault(config.stiffness, 100);
        _this._damping = withDefault(config.damping, 10);
        _this._mass = withDefault(config.mass, 1);
      } else if (config.bounciness !== undefined || config.speed !== undefined) {
        (0, _invariant.default)(config.tension === undefined && config.friction === undefined && config.stiffness === undefined && config.damping === undefined && config.mass === undefined, 'You can define one of bounciness/speed, tension/friction, or stiffness/damping/mass, but not more than one');

        var springConfig = _SpringConfig.default.fromBouncinessAndSpeed(withDefault(config.bounciness, 8), withDefault(config.speed, 12));

        _this._stiffness = springConfig.stiffness;
        _this._damping = springConfig.damping;
        _this._mass = 1;
      } else {
        var _springConfig = _SpringConfig.default.fromOrigamiTensionAndFriction(withDefault(config.tension, 40), withDefault(config.friction, 7));

        _this._stiffness = _springConfig.stiffness;
        _this._damping = _springConfig.damping;
        _this._mass = 1;
      }

      (0, _invariant.default)(_this._stiffness > 0, 'Stiffness value must be greater than 0');
      (0, _invariant.default)(_this._damping > 0, 'Damping value must be greater than 0');
      (0, _invariant.default)(_this._mass > 0, 'Mass value must be greater than 0');
      return _this;
    }

    (0, _createClass2.default)(SpringAnimation, [{
      key: "start",
      value: function start(value) {
        this._clock = new _AnimatedClock.default();
        var state = {
          finished: new _InternalAnimatedValue.default(0),
          velocity: new _InternalAnimatedValue.default(this._initialVelocity),
          position: value,
          time: new _InternalAnimatedValue.default(0)
        };
        var config = {
          damping: this._damping,
          mass: this._mass,
          stiffness: this._stiffness,
          toValue: this._toValue,
          overshootClamping: this._overshootClamping,
          restSpeedThreshold: this._restSpeedThreshold,
          restDisplacementThreshold: this._restDisplacementThreshold
        };
        return (0, _base.block)([(0, _base.cond)((0, _base.clockRunning)(this._clock), 0, [(0, _base.startClock)(this._clock)]), (0, _spring.default)(this._clock, state, config), (0, _base.cond)(state.finished, (0, _base.stopClock)(this._clock))]);
      }
    }, {
      key: "stop",
      value: function stop() {}
    }], [{
      key: "getDefaultState",
      value: function getDefaultState() {
        return {
          position: new _InternalAnimatedValue.default(0),
          finished: new _InternalAnimatedValue.default(0),
          velocity: new _InternalAnimatedValue.default(0),
          time: new _InternalAnimatedValue.default(0)
        };
      }
    }]);
    return SpringAnimation;
  }(_Animation2.default);

  exports.default = SpringAnimation;
},588,[1,24,25,32,34,37,544,587,589,585,538,547,248],"node_modules/react-native-reanimated/src/animations/SpringAnimation.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  function stiffnessFromOrigamiValue(oValue) {
    return (oValue - 30) * 3.62 + 194;
  }

  function dampingFromOrigamiValue(oValue) {
    return (oValue - 8) * 3 + 25;
  }

  function fromOrigamiTensionAndFriction(tension, friction) {
    return {
      stiffness: stiffnessFromOrigamiValue(tension),
      damping: dampingFromOrigamiValue(friction)
    };
  }

  function fromBouncinessAndSpeed(bounciness, speed) {
    function normalize(value, startValue, endValue) {
      return (value - startValue) / (endValue - startValue);
    }

    function projectNormal(n, start, end) {
      return start + n * (end - start);
    }

    function linearInterpolation(t, start, end) {
      return t * end + (1 - t) * start;
    }

    function quadraticOutInterpolation(t, start, end) {
      return linearInterpolation(2 * t - t * t, start, end);
    }

    function b3Friction1(x) {
      return 0.0007 * Math.pow(x, 3) - 0.031 * Math.pow(x, 2) + 0.64 * x + 1.28;
    }

    function b3Friction2(x) {
      return 0.000044 * Math.pow(x, 3) - 0.006 * Math.pow(x, 2) + 0.36 * x + 2;
    }

    function b3Friction3(x) {
      return 0.00000045 * Math.pow(x, 3) - 0.000332 * Math.pow(x, 2) + 0.1078 * x + 5.84;
    }

    function b3Nobounce(tension) {
      if (tension <= 18) {
        return b3Friction1(tension);
      } else if (tension > 18 && tension <= 44) {
        return b3Friction2(tension);
      } else {
        return b3Friction3(tension);
      }
    }

    var b = normalize(bounciness / 1.7, 0, 20);
    b = projectNormal(b, 0, 0.8);
    var s = normalize(speed / 1.7, 0, 20);
    var bouncyTension = projectNormal(s, 0.5, 200);
    var bouncyFriction = quadraticOutInterpolation(b, b3Nobounce(bouncyTension), 0.01);
    return {
      stiffness: stiffnessFromOrigamiValue(bouncyTension),
      damping: dampingFromOrigamiValue(bouncyFriction)
    };
  }

  module.exports = {
    fromOrigamiTensionAndFriction: fromOrigamiTensionAndFriction,
    fromBouncinessAndSpeed: fromBouncinessAndSpeed
  };
},589,[],"node_modules/react-native-reanimated/src/SpringConfig.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits"));

  var _Animation2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "./Animation"));

  var _decay = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "./decay"));

  var _base = _$$_REQUIRE(_dependencyMap[8], "../base");

  var _AnimatedClock = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "../core/AnimatedClock"));

  var _InternalAnimatedValue = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[10], "../core/InternalAnimatedValue"));

  var DecayAnimation = function (_Animation) {
    (0, _inherits2.default)(DecayAnimation, _Animation);

    function DecayAnimation(config) {
      var _this;

      (0, _classCallCheck2.default)(this, DecayAnimation);
      _this = (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(DecayAnimation).call(this));
      _this._deceleration = config.deceleration !== undefined ? config.deceleration : 0.998;
      _this._velocity = config.velocity;
      return _this;
    }

    (0, _createClass2.default)(DecayAnimation, [{
      key: "start",
      value: function start(value) {
        this._clock = new _AnimatedClock.default();
        var state = {
          finished: new _InternalAnimatedValue.default(0),
          velocity: new _InternalAnimatedValue.default(this._velocity),
          position: value,
          time: new _InternalAnimatedValue.default(0)
        };
        var config = {
          deceleration: this._deceleration
        };
        return (0, _base.block)([(0, _base.cond)((0, _base.clockRunning)(this._clock), 0, [(0, _base.startClock)(this._clock)]), (0, _decay.default)(this._clock, state, config), (0, _base.cond)(state.finished, (0, _base.stopClock)(this._clock))]);
      }
    }, {
      key: "stop",
      value: function stop() {}
    }], [{
      key: "getDefaultState",
      value: function getDefaultState() {
        return {
          position: new _InternalAnimatedValue.default(0),
          finished: new _InternalAnimatedValue.default(0),
          time: new _InternalAnimatedValue.default(0),
          velocity: new _InternalAnimatedValue.default(0)
        };
      }
    }]);
    return DecayAnimation;
  }(_Animation2.default);

  var _default = DecayAnimation;
  exports.default = _default;
},590,[1,24,25,32,34,37,587,583,538,547,544],"node_modules/react-native-reanimated/src/animations/DecayAnimation.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.addWhitelistedNativeProps = addWhitelistedNativeProps;
  exports.addWhitelistedUIProps = addWhitelistedUIProps;

  var _defineProperty2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/defineProperty"));

  var _ReanimatedModule = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "./ReanimatedModule"));

  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

  var UI_THREAD_PROPS_WHITELIST = {
    opacity: true,
    transform: true,
    backgroundColor: true,
    borderRightColor: true,
    borderBottomColor: true,
    borderColor: true,
    borderEndColor: true,
    borderLeftColor: true,
    borderStartColor: true,
    borderTopColor: true,
    shadowOpacity: true,
    shadowRadius: true,
    scaleX: true,
    scaleY: true,
    translateX: true,
    translateY: true
  };
  var NATIVE_THREAD_PROPS_WHITELIST = {
    borderBottomWidth: true,
    borderEndWidth: true,
    borderLeftWidth: true,
    borderRightWidth: true,
    borderStartWidth: true,
    borderTopWidth: true,
    borderWidth: true,
    bottom: true,
    flex: true,
    flexGrow: true,
    flexShrink: true,
    height: true,
    left: true,
    margin: true,
    marginBottom: true,
    marginEnd: true,
    marginHorizontal: true,
    marginLeft: true,
    marginRight: true,
    marginStart: true,
    marginTop: true,
    marginVertical: true,
    maxHeight: true,
    maxWidth: true,
    minHeight: true,
    minWidth: true,
    padding: true,
    paddingBottom: true,
    paddingEnd: true,
    paddingHorizontal: true,
    paddingLeft: true,
    paddingRight: true,
    paddingStart: true,
    paddingTop: true,
    paddingVertical: true,
    right: true,
    start: true,
    top: true,
    width: true,
    zIndex: true,
    borderBottomEndRadius: true,
    borderBottomLeftRadius: true,
    borderBottomRightRadius: true,
    borderBottomStartRadius: true,
    borderRadius: true,
    borderTopEndRadius: true,
    borderTopLeftRadius: true,
    borderTopRightRadius: true,
    borderTopStartRadius: true,
    opacity: true,
    elevation: true,
    fontSize: true,
    lineHeight: true,
    textShadowRadius: true,
    letterSpacing: true,
    display: true,
    backfaceVisibility: true,
    overflow: true,
    resizeMode: true,
    fontStyle: true,
    fontWeight: true,
    textAlign: true,
    textDecorationLine: true,
    fontFamily: true,
    textAlignVertical: true,
    fontVariant: true,
    textDecorationStyle: true,
    textTransform: true,
    writingDirection: true,
    color: true
  };

  function configureProps() {
    _ReanimatedModule.default.configureProps(Object.keys(NATIVE_THREAD_PROPS_WHITELIST), Object.keys(UI_THREAD_PROPS_WHITELIST));
  }

  function addWhitelistedNativeProps(props) {
    NATIVE_THREAD_PROPS_WHITELIST = _objectSpread({}, NATIVE_THREAD_PROPS_WHITELIST, {}, props);
    configureProps();
  }

  function addWhitelistedUIProps(props) {
    UI_THREAD_PROPS_WHITELIST = _objectSpread({}, UI_THREAD_PROPS_WHITELIST, {}, props);
    configureProps();
  }

  configureProps();
},591,[1,46,543],"node_modules/react-native-reanimated/src/ConfigHelper.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = backwardsCompatibleAnimWrapper;

  var _base = _$$_REQUIRE(_dependencyMap[1], "../base");

  var _AnimatedClock = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "../core/AnimatedClock"));

  var _evaluateOnce = _$$_REQUIRE(_dependencyMap[3], "../derived/evaluateOnce");

  function createOldAnimationObject(node, AnimationClass, value, config) {
    var newClock = new _AnimatedClock.default();
    var currentState = AnimationClass.getDefaultState();
    var alwaysNode;
    var isStarted = false;
    var isDone = false;
    var wasStopped = false;
    var animationCallback;
    var animation = {
      start: function start(currentAnimationCallback) {
        animationCallback = currentAnimationCallback;

        if (isStarted) {
          animationCallback && animationCallback({
            finished: false
          });
          return;
        }

        if (isDone) {
          console.warn('Animation has been finished before');
          return;
        }

        if (!value.isNativelyInitialized()) {
          return;
        }

        isStarted = true;
        (0, _evaluateOnce.evaluateOnce)((0, _base.set)(currentState.position, value), currentState.position, function () {
          alwaysNode = (0, _base.always)((0, _base.set)(value, (0, _base.block)([(0, _base.cond)((0, _base.clockRunning)(newClock), 0, (0, _base.startClock)(newClock)), node(newClock, currentState, config), (0, _base.cond)(currentState.finished, [(0, _base.call)([], function () {
            isStarted = false;

            if (!wasStopped) {
              isDone = true;
            }

            value.__detachAnimation(animation);

            isDone = true;

            if (!wasStopped) {
              wasStopped = false;
            }
          }), (0, _base.stopClock)(newClock)]), currentState.position])));

          value.__attachAnimation(animation);

          alwaysNode.__addChild(value);
        });
      },
      __detach: function __detach() {
        animationCallback && animationCallback({
          finished: isDone
        });
        animationCallback = null;

        alwaysNode.__removeChild(value);
      },
      stop: function stop() {
        if (isDone) {
          console.warn('Calling stop has no effect as the animation has already completed');
          return;
        }

        if (!isStarted) {
          console.warn("Calling stop has no effect as the animation hasn't been started");
          return;
        }

        wasStopped = true;
        (0, _evaluateOnce.evaluateOnce)((0, _base.set)(currentState.finished, 1), currentState.finished);
      },
      __stopImmediately_testOnly: function __stopImmediately_testOnly(result) {
        animation.stop();
        isDone = result;

        value.__detachAnimation(animation);
      }
    };
    return animation;
  }

  function backwardsCompatibleAnimWrapper(node, AnimationClass) {
    return function (clock, state, config) {
      if (config !== undefined) {
        return node(clock, state, config);
      }

      return createOldAnimationObject(node, AnimationClass, clock, state);
    };
  }
},592,[1,538,547,561],"node_modules/react-native-reanimated/src/animations/backwardCompatibleAnimWrapper.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.createTransitioningComponent = createTransitioningComponent;
  exports.Transition = exports.Transitioning = void 0;

  var _objectWithoutProperties2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/objectWithoutProperties"));

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf5 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits"));

  var _extends2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "@babel/runtime/helpers/extends"));

  var _react = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "react"));

  var _reactNative = _$$_REQUIRE(_dependencyMap[9], "react-native");

  var _ReanimatedModule = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[10], "./ReanimatedModule"));

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native-reanimated/src/Transitioning.js";

  var TransitioningContext = _react.default.createContext();

  function configFromProps(type, props) {
    var config = {
      type: type
    };

    if ('durationMs' in props) {
      config.durationMs = props.durationMs;
    }

    if ('interpolation' in props) {
      config.interpolation = props.interpolation;
    }

    if ('type' in props) {
      config.animation = props.type;
    }

    if ('delayMs' in props) {
      config.delayMs = props.delayMs;
    }

    if ('propagation' in props) {
      config.propagation = props.propagation;
    }

    return config;
  }

  function wrapTransitioningContext(Comp) {
    return function (props) {
      return _react.default.createElement(TransitioningContext.Consumer, {
        __source: {
          fileName: _jsxFileName,
          lineNumber: 36
        }
      }, function (context) {
        return _react.default.createElement(Comp, (0, _extends2.default)({
          context: context
        }, props, {
          __source: {
            fileName: _jsxFileName,
            lineNumber: 37
          }
        }));
      });
    };
  }

  var In = function (_React$Component) {
    (0, _inherits2.default)(In, _React$Component);

    function In() {
      (0, _classCallCheck2.default)(this, In);
      return (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf5.default)(In).apply(this, arguments));
    }

    (0, _createClass2.default)(In, [{
      key: "componentDidMount",
      value: function componentDidMount() {
        this.props.context.push(configFromProps('in', this.props));
      }
    }, {
      key: "render",
      value: function render() {
        return this.props.children || null;
      }
    }]);
    return In;
  }(_react.default.Component);

  var Change = function (_React$Component2) {
    (0, _inherits2.default)(Change, _React$Component2);

    function Change() {
      (0, _classCallCheck2.default)(this, Change);
      return (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf5.default)(Change).apply(this, arguments));
    }

    (0, _createClass2.default)(Change, [{
      key: "componentDidMount",
      value: function componentDidMount() {
        this.props.context.push(configFromProps('change', this.props));
      }
    }, {
      key: "render",
      value: function render() {
        return this.props.children || null;
      }
    }]);
    return Change;
  }(_react.default.Component);

  var Out = function (_React$Component3) {
    (0, _inherits2.default)(Out, _React$Component3);

    function Out() {
      (0, _classCallCheck2.default)(this, Out);
      return (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf5.default)(Out).apply(this, arguments));
    }

    (0, _createClass2.default)(Out, [{
      key: "componentDidMount",
      value: function componentDidMount() {
        this.props.context.push(configFromProps('out', this.props));
      }
    }, {
      key: "render",
      value: function render() {
        return this.props.children || null;
      }
    }]);
    return Out;
  }(_react.default.Component);

  var Together = function (_React$Component4) {
    (0, _inherits2.default)(Together, _React$Component4);

    function Together() {
      var _getPrototypeOf2;

      var _this;

      (0, _classCallCheck2.default)(this, Together);

      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
        args[_key] = arguments[_key];
      }

      _this = (0, _possibleConstructorReturn2.default)(this, (_getPrototypeOf2 = (0, _getPrototypeOf5.default)(Together)).call.apply(_getPrototypeOf2, [this].concat(args)));
      _this.transitions = [];
      return _this;
    }

    (0, _createClass2.default)(Together, [{
      key: "componentDidMount",
      value: function componentDidMount() {
        var config = configFromProps('group', this.props);
        config.transitions = this.transitions;
        this.props.context.push(config);
      }
    }, {
      key: "render",
      value: function render() {
        return _react.default.createElement(TransitioningContext.Provider, {
          value: this.transitions,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 83
          }
        }, this.props.children);
      }
    }]);
    return Together;
  }(_react.default.Component);

  var Sequence = function (_React$Component5) {
    (0, _inherits2.default)(Sequence, _React$Component5);

    function Sequence() {
      var _getPrototypeOf3;

      var _this2;

      (0, _classCallCheck2.default)(this, Sequence);

      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
        args[_key2] = arguments[_key2];
      }

      _this2 = (0, _possibleConstructorReturn2.default)(this, (_getPrototypeOf3 = (0, _getPrototypeOf5.default)(Sequence)).call.apply(_getPrototypeOf3, [this].concat(args)));
      _this2.transitions = [];
      return _this2;
    }

    (0, _createClass2.default)(Sequence, [{
      key: "componentDidMount",
      value: function componentDidMount() {
        var config = configFromProps('group', this.props);
        config.sequence = true;
        config.transitions = this.transitions;
        this.props.context.push(config);
      }
    }, {
      key: "render",
      value: function render() {
        return _react.default.createElement(TransitioningContext.Provider, {
          value: this.transitions,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 101
          }
        }, this.props.children);
      }
    }]);
    return Sequence;
  }(_react.default.Component);

  function createTransitioningComponent(Component) {
    var Wrapped = function (_React$Component6) {
      (0, _inherits2.default)(Wrapped, _React$Component6);

      function Wrapped() {
        var _getPrototypeOf4;

        var _this3;

        (0, _classCallCheck2.default)(this, Wrapped);

        for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
          args[_key3] = arguments[_key3];
        }

        _this3 = (0, _possibleConstructorReturn2.default)(this, (_getPrototypeOf4 = (0, _getPrototypeOf5.default)(Wrapped)).call.apply(_getPrototypeOf4, [this].concat(args)));
        _this3.propTypes = Component.propTypes;
        _this3.transitions = [];
        _this3.viewRef = _react.default.createRef();
        return _this3;
      }

      (0, _createClass2.default)(Wrapped, [{
        key: "componentDidMount",
        value: function componentDidMount() {
          if (this.props.animateMount) {
            this.animateNextTransition();
          }
        }
      }, {
        key: "setNativeProps",
        value: function setNativeProps(props) {
          this.viewRef.current.setNativeProps(props);
        }
      }, {
        key: "animateNextTransition",
        value: function animateNextTransition() {
          var viewTag = (0, _reactNative.findNodeHandle)(this.viewRef.current);

          _ReanimatedModule.default.animateNextTransition(viewTag, {
            transitions: this.transitions
          });
        }
      }, {
        key: "render",
        value: function render() {
          var _this$props = this.props,
              transition = _this$props.transition,
              rest = (0, _objectWithoutProperties2.default)(_this$props, ["transition"]);
          return _react.default.createElement(_react.default.Fragment, {
            __source: {
              fileName: _jsxFileName,
              lineNumber: 134
            }
          }, _react.default.createElement(TransitioningContext.Provider, {
            value: this.transitions,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 135
            }
          }, transition), _react.default.createElement(Component, (0, _extends2.default)({}, rest, {
            ref: this.viewRef,
            collapsable: false,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 138
            }
          })));
        }
      }]);
      return Wrapped;
    }(_react.default.Component);

    return Wrapped;
  }

  var Transitioning = {
    View: createTransitioningComponent(_reactNative.View)
  };
  exports.Transitioning = Transitioning;
  var Transition = {
    Sequence: wrapTransitioningContext(Sequence),
    Together: wrapTransitioningContext(Together),
    In: wrapTransitioningContext(In),
    Out: wrapTransitioningContext(Out),
    Change: wrapTransitioningContext(Change)
  };
  exports.Transition = Transition;
},593,[1,52,24,25,32,34,37,13,54,2,543],"node_modules/react-native-reanimated/src/Transitioning.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _defineProperty2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/defineProperty"));

  var _objectWithoutProperties2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/objectWithoutProperties"));

  var _base = _$$_REQUIRE(_dependencyMap[3], "./../base");

  var _InternalAnimatedValue = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "./../core/InternalAnimatedValue"));

  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

  function stiffnessFromOrigamiValue(oValue) {
    return (oValue - 30) * 3.62 + 194;
  }

  function dampingFromOrigamiValue(oValue) {
    return (oValue - 8) * 3 + 25;
  }

  function stiffnessFromOrigamiNode(oValue) {
    return (0, _base.add)((0, _base.multiply)((0, _base.sub)(oValue, 30), 3.62), 194);
  }

  function dampingFromOrigamiNode(oValue) {
    return (0, _base.add)((0, _base.multiply)((0, _base.sub)(oValue, 8), 3), 25);
  }

  function makeConfigFromOrigamiTensionAndFriction(prevConfig) {
    var tension = prevConfig.tension,
        friction = prevConfig.friction,
        rest = (0, _objectWithoutProperties2.default)(prevConfig, ["tension", "friction"]);
    return _objectSpread({}, rest, {
      stiffness: typeof tension === 'number' ? stiffnessFromOrigamiValue(tension) : stiffnessFromOrigamiNode(tension),
      damping: typeof friction === 'number' ? dampingFromOrigamiValue(friction) : dampingFromOrigamiNode(friction)
    });
  }

  function makeConfigFromBouncinessAndSpeed(prevConfig) {
    var bounciness = prevConfig.bounciness,
        speed = prevConfig.speed,
        rest = (0, _objectWithoutProperties2.default)(prevConfig, ["bounciness", "speed"]);

    if (typeof bounciness === 'number' && typeof speed === 'number') {
      return fromBouncinessAndSpeedNumbers(bounciness, speed, rest);
    }

    return fromBouncinessAndSpeedNodes(bounciness, speed, rest);
  }

  function fromBouncinessAndSpeedNodes(bounciness, speed, rest) {
    function normalize(value, startValue, endValue) {
      return (0, _base.divide)((0, _base.sub)(value, startValue), (0, _base.sub)(endValue, startValue));
    }

    function projectNormal(n, start, end) {
      return (0, _base.add)(start, (0, _base.multiply)(n, (0, _base.sub)(end, start)));
    }

    function linearInterpolation(t, start, end) {
      return (0, _base.add)((0, _base.multiply)(t, end), (0, _base.multiply)((0, _base.sub)(1, t), start));
    }

    function quadraticOutInterpolation(t, start, end) {
      return linearInterpolation((0, _base.sub)((0, _base.multiply)(2, t), (0, _base.multiply)(t, t)), start, end);
    }

    function b3Friction1(x) {
      return (0, _base.add)((0, _base.sub)((0, _base.multiply)(0.0007, (0, _base.pow)(x, 3)), (0, _base.multiply)(0.031, (0, _base.pow)(x, 2))), (0, _base.multiply)(0.64, x), 1.28);
    }

    function b3Friction2(x) {
      return (0, _base.add)((0, _base.sub)((0, _base.multiply)(0.000044, (0, _base.pow)(x, 3)), (0, _base.multiply)(0.006, (0, _base.pow)(x, 2))), (0, _base.multiply)(0.36, x), 2);
    }

    function b3Friction3(x) {
      return (0, _base.add)((0, _base.sub)((0, _base.multiply)(0.00000045, (0, _base.pow)(x, 3)), (0, _base.multiply)(0.000332, (0, _base.pow)(x, 2))), (0, _base.multiply)(0.1078, x), 5.84);
    }

    function b3Nobounce(tension) {
      return (0, _base.cond)((0, _base.lessOrEq)(tension, 18), b3Friction1(tension), (0, _base.cond)((0, _base.and)((0, _base.greaterThan)(tension, 18), (0, _base.lessOrEq)(tension, 44)), b3Friction2(tension), b3Friction3(tension)));
    }

    var b = normalize((0, _base.divide)(bounciness, 1.7), 0, 20);
    b = projectNormal(b, 0, 0.8);
    var s = normalize((0, _base.divide)(speed, 1.7), 0, 20);
    var bouncyTension = projectNormal(s, 0.5, 200);
    var bouncyFriction = quadraticOutInterpolation(b, b3Nobounce(bouncyTension), 0.01);
    return _objectSpread({}, rest, {
      stiffness: stiffnessFromOrigamiNode(bouncyTension),
      damping: dampingFromOrigamiNode(bouncyFriction)
    });
  }

  function fromBouncinessAndSpeedNumbers(bounciness, speed, rest) {
    function normalize(value, startValue, endValue) {
      return (value - startValue) / (endValue - startValue);
    }

    function projectNormal(n, start, end) {
      return start + n * (end - start);
    }

    function linearInterpolation(t, start, end) {
      return t * end + (1 - t) * start;
    }

    function quadraticOutInterpolation(t, start, end) {
      return linearInterpolation(2 * t - t * t, start, end);
    }

    function b3Friction1(x) {
      return 0.0007 * Math.pow(x, 3) - 0.031 * Math.pow(x, 2) + 0.64 * x + 1.28;
    }

    function b3Friction2(x) {
      return 0.000044 * Math.pow(x, 3) - 0.006 * Math.pow(x, 2) + 0.36 * x + 2;
    }

    function b3Friction3(x) {
      return 0.00000045 * Math.pow(x, 3) - 0.000332 * Math.pow(x, 2) + 0.1078 * x + 5.84;
    }

    function b3Nobounce(tension) {
      if (tension <= 18) {
        return b3Friction1(tension);
      } else if (tension > 18 && tension <= 44) {
        return b3Friction2(tension);
      } else {
        return b3Friction3(tension);
      }
    }

    var b = normalize(bounciness / 1.7, 0, 20);
    b = projectNormal(b, 0, 0.8);
    var s = normalize(speed / 1.7, 0, 20);
    var bouncyTension = projectNormal(s, 0.5, 200);
    var bouncyFriction = quadraticOutInterpolation(b, b3Nobounce(bouncyTension), 0.01);
    return _objectSpread({}, rest, {
      stiffness: stiffnessFromOrigamiValue(bouncyTension),
      damping: dampingFromOrigamiValue(bouncyFriction)
    });
  }

  function makeDefaultConfig() {
    return {
      stiffness: new _InternalAnimatedValue.default(100),
      mass: new _InternalAnimatedValue.default(1),
      damping: new _InternalAnimatedValue.default(10),
      overshootClamping: false,
      restSpeedThreshold: 0.001,
      restDisplacementThreshold: 0.001,
      toValue: new _InternalAnimatedValue.default(0)
    };
  }

  var _default = {
    makeDefaultConfig: makeDefaultConfig,
    makeConfigFromBouncinessAndSpeed: makeConfigFromBouncinessAndSpeed,
    makeConfigFromOrigamiTensionAndFriction: makeConfigFromOrigamiTensionAndFriction
  };
  exports.default = _default;
},594,[1,46,52,538,544],"node_modules/react-native-reanimated/src/animations/SpringUtils.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireWildcard");

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = withDimensions;
  exports.isOrientationLandscape = void 0;

  var _extends2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/extends"));

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "@babel/runtime/helpers/inherits"));

  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[8], "react"));

  var _reactNative = _$$_REQUIRE(_dependencyMap[9], "react-native");

  var _hoistNonReactStatics = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[10], "hoist-non-react-statics"));

  var _jsxFileName = "/Users/satya/Workspace/Callstack/react-navigation-tabs/src/utils/withDimensions.tsx";

  var isOrientationLandscape = function isOrientationLandscape(_ref) {
    var width = _ref.width,
        height = _ref.height;
    return width > height;
  };

  exports.isOrientationLandscape = isOrientationLandscape;

  function withDimensions(WrappedComponent) {
    var EnhancedComponent = function (_React$Component) {
      (0, _inherits2.default)(EnhancedComponent, _React$Component);

      function EnhancedComponent(props) {
        var _this;

        (0, _classCallCheck2.default)(this, EnhancedComponent);
        _this = (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(EnhancedComponent).call(this, props));

        _this.handleOrientationChange = function (_ref2) {
          var window = _ref2.window;
          var width = window.width,
              height = window.height;

          _this.setState({
            dimensions: {
              width: width,
              height: height
            },
            isLandscape: isOrientationLandscape({
              width: width,
              height: height
            })
          });
        };

        var _Dimensions$get = _reactNative.Dimensions.get('window'),
            _width = _Dimensions$get.width,
            _height = _Dimensions$get.height;

        _this.state = {
          dimensions: {
            width: _width,
            height: _height
          },
          isLandscape: isOrientationLandscape({
            width: _width,
            height: _height
          })
        };
        return _this;
      }

      (0, _createClass2.default)(EnhancedComponent, [{
        key: "componentDidMount",
        value: function componentDidMount() {
          _reactNative.Dimensions.addEventListener('change', this.handleOrientationChange);
        }
      }, {
        key: "componentWillUnmount",
        value: function componentWillUnmount() {
          _reactNative.Dimensions.removeEventListener('change', this.handleOrientationChange);
        }
      }, {
        key: "render",
        value: function render() {
          return React.createElement(WrappedComponent, (0, _extends2.default)({}, this.props, this.state, {
            __source: {
              fileName: _jsxFileName,
              lineNumber: 52
            }
          }));
        }
      }]);
      return EnhancedComponent;
    }(React.Component);

    EnhancedComponent.displayName = "withDimensions(" + WrappedComponent.displayName + ")";
    return (0, _hoistNonReactStatics.default)(EnhancedComponent, WrappedComponent);
  }
},595,[9,1,13,24,25,32,34,37,54,2,489],"node_modules/react-navigation-tabs/lib/module/utils/withDimensions.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireWildcard");

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _extends2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/extends"));

  var _objectWithoutProperties2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/objectWithoutProperties"));

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "@babel/runtime/helpers/inherits"));

  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[9], "react"));

  var _reactNative = _$$_REQUIRE(_dependencyMap[10], "react-native");

  var _reactNativeScreens = _$$_REQUIRE(_dependencyMap[11], "react-native-screens");

  var _jsxFileName = "/Users/satya/Workspace/Callstack/react-navigation-tabs/src/views/ResourceSavingScene.tsx";
  var FAR_FAR_AWAY = 3000;

  var ResourceSavingScene = function (_React$Component) {
    (0, _inherits2.default)(ResourceSavingScene, _React$Component);

    function ResourceSavingScene() {
      (0, _classCallCheck2.default)(this, ResourceSavingScene);
      return (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(ResourceSavingScene).apply(this, arguments));
    }

    (0, _createClass2.default)(ResourceSavingScene, [{
      key: "render",
      value: function render() {
        if (_reactNativeScreens.screensEnabled && (0, _reactNativeScreens.screensEnabled)()) {
          var _this$props = this.props,
              _isVisible = _this$props.isVisible,
              _rest = (0, _objectWithoutProperties2.default)(_this$props, ["isVisible"]);

          return React.createElement(_reactNativeScreens.Screen, (0, _extends2.default)({
            active: _isVisible ? 1 : 0
          }, _rest, {
            __source: {
              fileName: _jsxFileName,
              lineNumber: 20
            }
          }));
        }

        var _this$props2 = this.props,
            isVisible = _this$props2.isVisible,
            children = _this$props2.children,
            style = _this$props2.style,
            rest = (0, _objectWithoutProperties2.default)(_this$props2, ["isVisible", "children", "style"]);
        return React.createElement(_reactNative.View, (0, _extends2.default)({
          style: [styles.container, style, {
            opacity: isVisible ? 1 : 0
          }],
          collapsable: false,
          removeClippedSubviews: _reactNative.Platform.OS === 'ios' ? !isVisible : true,
          pointerEvents: isVisible ? 'auto' : 'none'
        }, rest, {
          __source: {
            fileName: _jsxFileName,
            lineNumber: 26
          }
        }), React.createElement(_reactNative.View, {
          style: isVisible ? styles.attached : styles.detached,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 37
          }
        }, children));
      }
    }]);
    return ResourceSavingScene;
  }(React.Component);

  exports.default = ResourceSavingScene;

  var styles = _reactNative.StyleSheet.create({
    container: {
      flex: 1,
      overflow: 'hidden'
    },
    attached: {
      flex: 1
    },
    detached: {
      flex: 1,
      top: FAR_FAR_AWAY
    }
  });
},596,[9,1,13,52,24,25,32,34,37,54,2,532],"node_modules/react-navigation-tabs/lib/module/views/ResourceSavingScene.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireWildcard");

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _objectWithoutProperties2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/objectWithoutProperties"));

  var _extends2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/extends"));

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf3 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "@babel/runtime/helpers/inherits"));

  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[9], "react"));

  var _reactNativeTabView = _$$_REQUIRE(_dependencyMap[10], "react-native-tab-view");

  var _createTabNavigator = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[11], "../utils/createTabNavigator"));

  var _MaterialTopTabBar = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[12], "../views/MaterialTopTabBar"));

  var _jsxFileName = "/Users/satya/Workspace/Callstack/react-navigation-tabs/src/navigators/createMaterialTopTabNavigator.tsx";

  var MaterialTabView = function (_React$PureComponent) {
    (0, _inherits2.default)(MaterialTabView, _React$PureComponent);

    function MaterialTabView() {
      var _getPrototypeOf2;

      var _this;

      (0, _classCallCheck2.default)(this, MaterialTabView);

      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
        args[_key] = arguments[_key];
      }

      _this = (0, _possibleConstructorReturn2.default)(this, (_getPrototypeOf2 = (0, _getPrototypeOf3.default)(MaterialTabView)).call.apply(_getPrototypeOf2, [this].concat(args)));

      _this.renderTabBar = function (props) {
        var state = _this.props.navigation.state;
        var route = state.routes[state.index];
        var descriptors = _this.props.descriptors;
        var descriptor = descriptors[route.key];
        var options = descriptor.options;
        var tabBarVisible = options.tabBarVisible == null ? true : options.tabBarVisible;
        var _this$props = _this.props,
            navigation = _this$props.navigation,
            getLabelText = _this$props.getLabelText,
            getAccessibilityLabel = _this$props.getAccessibilityLabel,
            getTestID = _this$props.getTestID,
            renderIcon = _this$props.renderIcon,
            onTabPress = _this$props.onTabPress,
            onTabLongPress = _this$props.onTabLongPress,
            _this$props$tabBarCom = _this$props.tabBarComponent,
            TabBarComponent = _this$props$tabBarCom === void 0 ? _MaterialTopTabBar.default : _this$props$tabBarCom,
            tabBarPosition = _this$props.tabBarPosition,
            tabBarOptions = _this$props.tabBarOptions,
            screenProps = _this$props.screenProps;

        if (TabBarComponent === null || !tabBarVisible) {
          return null;
        }

        return React.createElement(TabBarComponent, (0, _extends2.default)({}, tabBarOptions, props, {
          tabBarPosition: tabBarPosition,
          screenProps: screenProps,
          navigation: navigation,
          getLabelText: getLabelText,
          getAccessibilityLabel: getAccessibilityLabel,
          getTestID: getTestID,
          renderIcon: renderIcon,
          onTabPress: onTabPress,
          onTabLongPress: onTabLongPress,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 77
          }
        }));
      };

      return _this;
    }

    (0, _createClass2.default)(MaterialTabView, [{
      key: "render",
      value: function render() {
        var _this$props2 = this.props,
            getLabelText = _this$props2.getLabelText,
            getAccessibilityLabel = _this$props2.getAccessibilityLabel,
            getTestID = _this$props2.getTestID,
            renderIcon = _this$props2.renderIcon,
            onTabPress = _this$props2.onTabPress,
            onTabLongPress = _this$props2.onTabLongPress,
            screenProps = _this$props2.screenProps,
            tabBarComponent = _this$props2.tabBarComponent,
            tabBarOptions = _this$props2.tabBarOptions,
            lazyPlaceholderComponent = _this$props2.lazyPlaceholderComponent,
            pagerComponent = _this$props2.pagerComponent,
            navigation = _this$props2.navigation,
            descriptors = _this$props2.descriptors,
            rest = (0, _objectWithoutProperties2.default)(_this$props2, ["getLabelText", "getAccessibilityLabel", "getTestID", "renderIcon", "onTabPress", "onTabLongPress", "screenProps", "tabBarComponent", "tabBarOptions", "lazyPlaceholderComponent", "pagerComponent", "navigation", "descriptors"]);
        var state = navigation.state;
        var route = state.routes[state.index];
        var descriptor = descriptors[route.key];
        var options = descriptor.options;
        var swipeEnabled = options.swipeEnabled == null ? this.props.swipeEnabled : options.swipeEnabled;

        if (typeof swipeEnabled === 'function') {
          swipeEnabled = swipeEnabled(state);
        }

        return React.createElement(_reactNativeTabView.TabView, (0, _extends2.default)({}, rest, {
          navigationState: navigation.state,
          swipeEnabled: swipeEnabled,
          renderTabBar: this.renderTabBar,
          renderLazyPlaceholder: lazyPlaceholderComponent !== undefined ? function (props) {
            return React.createElement(lazyPlaceholderComponent, props);
          } : undefined,
          renderPager: pagerComponent !== undefined ? function (props) {
            return React.createElement(pagerComponent, props);
          } : undefined,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 130
          }
        }));
      }
    }]);
    return MaterialTabView;
  }(React.PureComponent);

  var _default = (0, _createTabNavigator.default)(MaterialTabView);

  exports.default = _default;
},597,[9,1,52,13,24,25,32,34,37,54,598,533,609],"node_modules/react-navigation-tabs/lib/module/navigators/createMaterialTopTabNavigator.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  Object.defineProperty(exports, "TabView", {
    enumerable: true,
    get: function get() {
      return _TabView.default;
    }
  });
  Object.defineProperty(exports, "TabBar", {
    enumerable: true,
    get: function get() {
      return _TabBar.default;
    }
  });
  Object.defineProperty(exports, "SceneMap", {
    enumerable: true,
    get: function get() {
      return _SceneMap.default;
    }
  });
  Object.defineProperty(exports, "Route", {
    enumerable: true,
    get: function get() {
      return _types.Route;
    }
  });
  Object.defineProperty(exports, "NavigationState", {
    enumerable: true,
    get: function get() {
      return _types.NavigationState;
    }
  });
  Object.defineProperty(exports, "SceneRendererProps", {
    enumerable: true,
    get: function get() {
      return _types.SceneRendererProps;
    }
  });

  var _TabView = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./TabView"));

  var _TabBar = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "./TabBar"));

  var _SceneMap = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "./SceneMap"));

  var _types = _$$_REQUIRE(_dependencyMap[4], "./types");
},598,[1,599,600,607,608],"node_modules/react-native-tab-view/lib/module/index.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireWildcard");

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _extends2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/extends"));

  var _defineProperty2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/defineProperty"));

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf3 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "@babel/runtime/helpers/inherits"));

  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[9], "react"));

  var _reactNative = _$$_REQUIRE(_dependencyMap[10], "react-native");

  var _reactNativeReanimated = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[11], "react-native-reanimated"));

  var _TabBar = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[12], "./TabBar"));

  var _SceneView = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[13], "./SceneView"));

  var _Pager = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[14], "./Pager"));

  var _jsxFileName = "/Users/osdnk/work/react-native-tab-view/src/TabView.tsx";

  function ownKeys(object, enumerableOnly) {
    var keys = Object.keys(object);

    if (Object.getOwnPropertySymbols) {
      var symbols = Object.getOwnPropertySymbols(object);
      if (enumerableOnly) symbols = symbols.filter(function (sym) {
        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
      });
      keys.push.apply(keys, symbols);
    }

    return keys;
  }

  function _objectSpread(target) {
    for (var i = 1; i < arguments.length; i++) {
      var source = arguments[i] != null ? arguments[i] : {};

      if (i % 2) {
        ownKeys(source, true).forEach(function (key) {
          (0, _defineProperty2.default)(target, key, source[key]);
        });
      } else if (Object.getOwnPropertyDescriptors) {
        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
      } else {
        ownKeys(source).forEach(function (key) {
          Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
        });
      }
    }

    return target;
  }

  var TabView = function (_React$Component) {
    (0, _inherits2.default)(TabView, _React$Component);

    function TabView() {
      var _getPrototypeOf2;

      var _this;

      (0, _classCallCheck2.default)(this, TabView);

      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
        args[_key] = arguments[_key];
      }

      _this = (0, _possibleConstructorReturn2.default)(this, (_getPrototypeOf2 = (0, _getPrototypeOf3.default)(TabView)).call.apply(_getPrototypeOf2, [this].concat(args)));
      _this.state = {
        layout: _objectSpread({
          width: 0,
          height: 0
        }, _this.props.initialLayout)
      };

      _this.jumpToIndex = function (index) {
        if (index !== _this.props.navigationState.index) {
          _this.props.onIndexChange(index);
        }
      };

      _this.handleLayout = function (e) {
        var _e$nativeEvent$layout = e.nativeEvent.layout,
            height = _e$nativeEvent$layout.height,
            width = _e$nativeEvent$layout.width;

        if (_this.state.layout.width === width && _this.state.layout.height === height) {
          return;
        }

        _this.setState({
          layout: {
            height: height,
            width: width
          }
        });
      };

      return _this;
    }

    (0, _createClass2.default)(TabView, [{
      key: "render",
      value: function render() {
        var _this$props = this.props,
            positionListener = _this$props.position,
            onSwipeStart = _this$props.onSwipeStart,
            onSwipeEnd = _this$props.onSwipeEnd,
            navigationState = _this$props.navigationState,
            lazy = _this$props.lazy,
            lazyPreloadDistance = _this$props.lazyPreloadDistance,
            removeClippedSubviews = _this$props.removeClippedSubviews,
            keyboardDismissMode = _this$props.keyboardDismissMode,
            swipeEnabled = _this$props.swipeEnabled,
            swipeVelocityImpact = _this$props.swipeVelocityImpact,
            timingConfig = _this$props.timingConfig,
            springConfig = _this$props.springConfig,
            tabBarPosition = _this$props.tabBarPosition,
            renderTabBar = _this$props.renderTabBar,
            renderScene = _this$props.renderScene,
            renderLazyPlaceholder = _this$props.renderLazyPlaceholder,
            sceneContainerStyle = _this$props.sceneContainerStyle,
            style = _this$props.style,
            gestureHandlerProps = _this$props.gestureHandlerProps,
            springVelocityScale = _this$props.springVelocityScale,
            renderPager = _this$props.renderPager;
        var layout = this.state.layout;
        return React.createElement(_reactNative.View, {
          onLayout: this.handleLayout,
          style: [styles.pager, style],
          __source: {
            fileName: _jsxFileName,
            lineNumber: 128
          }
        }, renderPager({
          navigationState: navigationState,
          layout: layout,
          keyboardDismissMode: keyboardDismissMode,
          swipeEnabled: swipeEnabled,
          swipeVelocityImpact: swipeVelocityImpact,
          timingConfig: timingConfig,
          springConfig: springConfig,
          onSwipeStart: onSwipeStart,
          onSwipeEnd: onSwipeEnd,
          onIndexChange: this.jumpToIndex,
          springVelocityScale: springVelocityScale,
          removeClippedSubviews: removeClippedSubviews,
          gestureHandlerProps: gestureHandlerProps,
          children: function children(_ref) {
            var position = _ref.position,
                render = _ref.render,
                addListener = _ref.addListener,
                removeListener = _ref.removeListener,
                jumpTo = _ref.jumpTo;
            var sceneRendererProps = {
              position: position,
              layout: layout,
              jumpTo: jumpTo
            };
            return React.createElement(React.Fragment, {
              __source: {
                fileName: _jsxFileName,
                lineNumber: 159
              }
            }, positionListener ? React.createElement(_reactNativeReanimated.default.Code, {
              exec: _reactNativeReanimated.default.set(positionListener, position),
              __source: {
                fileName: _jsxFileName,
                lineNumber: 161
              }
            }) : null, tabBarPosition === 'top' && renderTabBar(_objectSpread({}, sceneRendererProps, {
              navigationState: navigationState
            })), render(navigationState.routes.map(function (route, i) {
              return React.createElement(_SceneView.default, (0, _extends2.default)({}, sceneRendererProps, {
                addListener: addListener,
                removeListener: removeListener,
                key: route.key,
                index: i,
                lazy: lazy,
                lazyPreloadDistance: lazyPreloadDistance,
                navigationState: navigationState,
                style: sceneContainerStyle,
                __source: {
                  fileName: _jsxFileName,
                  lineNumber: 173
                }
              }), function (_ref2) {
                var loading = _ref2.loading;
                return loading ? renderLazyPlaceholder({
                  route: route
                }) : renderScene(_objectSpread({}, sceneRendererProps, {
                  route: route
                }));
              });
            })), tabBarPosition === 'bottom' && renderTabBar(_objectSpread({}, sceneRendererProps, {
              navigationState: navigationState
            })));
          }
        }));
      }
    }]);
    return TabView;
  }(React.Component);

  exports.default = TabView;
  TabView.defaultProps = {
    tabBarPosition: 'top',
    renderTabBar: function renderTabBar(props) {
      return React.createElement(_TabBar.default, (0, _extends2.default)({}, props, {
        __source: {
          fileName: _jsxFileName,
          lineNumber: 59
        }
      }));
    },
    renderLazyPlaceholder: function renderLazyPlaceholder() {
      return null;
    },
    keyboardDismissMode: 'auto',
    swipeEnabled: true,
    lazy: false,
    lazyPreloadDistance: 0,
    removeClippedSubviews: false,
    springConfig: {},
    timingConfig: {},
    gestureHandlerProps: {},
    renderPager: function renderPager(props) {
      return React.createElement(_Pager.default, (0, _extends2.default)({}, props, {
        __source: {
          fileName: _jsxFileName,
          lineNumber: 70
        }
      }));
    }
  };

  var styles = _reactNative.StyleSheet.create({
    pager: {
      flex: 1,
      overflow: 'hidden'
    }
  });
},599,[9,1,13,46,24,25,32,34,37,54,2,536,600,605,606],"node_modules/react-native-tab-view/lib/module/TabView.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireWildcard");

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _extends2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/extends"));

  var _defineProperty2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/defineProperty"));

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf3 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "@babel/runtime/helpers/inherits"));

  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[9], "react"));

  var _reactNative = _$$_REQUIRE(_dependencyMap[10], "react-native");

  var _reactNativeReanimated = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[11], "react-native-reanimated"));

  var _TabBarItem = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[12], "./TabBarItem"));

  var _TabBarIndicator = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[13], "./TabBarIndicator"));

  var _memoize = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[14], "./memoize"));

  var _jsxFileName = "/Users/osdnk/work/react-native-tab-view/src/TabBar.tsx";

  function ownKeys(object, enumerableOnly) {
    var keys = Object.keys(object);

    if (Object.getOwnPropertySymbols) {
      var symbols = Object.getOwnPropertySymbols(object);
      if (enumerableOnly) symbols = symbols.filter(function (sym) {
        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
      });
      keys.push.apply(keys, symbols);
    }

    return keys;
  }

  function _objectSpread(target) {
    for (var i = 1; i < arguments.length; i++) {
      var source = arguments[i] != null ? arguments[i] : {};

      if (i % 2) {
        ownKeys(source, true).forEach(function (key) {
          (0, _defineProperty2.default)(target, key, source[key]);
        });
      } else if (Object.getOwnPropertyDescriptors) {
        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
      } else {
        ownKeys(source).forEach(function (key) {
          Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
        });
      }
    }

    return target;
  }

  var TabBar = function (_React$Component) {
    (0, _inherits2.default)(TabBar, _React$Component);

    function TabBar() {
      var _getPrototypeOf2;

      var _this;

      (0, _classCallCheck2.default)(this, TabBar);

      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
        args[_key] = arguments[_key];
      }

      _this = (0, _possibleConstructorReturn2.default)(this, (_getPrototypeOf2 = (0, _getPrototypeOf3.default)(TabBar)).call.apply(_getPrototypeOf2, [this].concat(args)));
      _this.state = {
        layout: {
          width: 0,
          height: 0
        },
        tabWidths: {}
      };
      _this.measuredTabWidths = {};
      _this.scrollAmount = new _reactNativeReanimated.default.Value(0);

      _this.getFlattenedTabWidth = function (style) {
        var tabStyle = _reactNative.StyleSheet.flatten(style);

        return tabStyle ? tabStyle.width : undefined;
      };

      _this.getComputedTabWidth = function (index, layout, routes, scrollEnabled, tabWidths, flattenedWidth) {
        if (flattenedWidth === 'auto') {
          return tabWidths[routes[index].key] || 0;
        }

        switch (typeof flattenedWidth) {
          case 'number':
            return flattenedWidth;

          case 'string':
            if (flattenedWidth.endsWith('%')) {
              var width = parseFloat(flattenedWidth);

              if (Number.isFinite(width)) {
                return layout.width * (width / 100);
              }
            }

        }

        if (scrollEnabled) {
          return layout.width / 5 * 2;
        }

        return layout.width / routes.length;
      };

      _this.getMemoizedTabWidthGettter = (0, _memoize.default)(function (layout, routes, scrollEnabled, tabWidths, flattenedWidth) {
        return function (i) {
          return _this.getComputedTabWidth(i, layout, routes, scrollEnabled, tabWidths, flattenedWidth);
        };
      });

      _this.getMaxScrollDistance = function (tabBarWidth, layoutWidth) {
        return tabBarWidth - layoutWidth;
      };

      _this.getTabBarWidth = function (props, state) {
        var layout = state.layout,
            tabWidths = state.tabWidths;
        var scrollEnabled = props.scrollEnabled,
            tabStyle = props.tabStyle;
        var routes = props.navigationState.routes;
        return routes.reduce(function (acc, _, i) {
          return acc + _this.getComputedTabWidth(i, layout, routes, scrollEnabled, tabWidths, _this.getFlattenedTabWidth(tabStyle));
        }, 0);
      };

      _this.normalizeScrollValue = function (props, state, value) {
        var layout = state.layout;

        var tabBarWidth = _this.getTabBarWidth(props, state);

        var maxDistance = _this.getMaxScrollDistance(tabBarWidth, layout.width);

        var scrollValue = Math.max(Math.min(value, maxDistance), 0);

        if (_reactNative.Platform.OS === 'android' && _reactNative.I18nManager.isRTL) {
          return maxDistance - scrollValue;
        }

        return scrollValue;
      };

      _this.getScrollAmount = function (props, state, index) {
        var layout = state.layout,
            tabWidths = state.tabWidths;
        var scrollEnabled = props.scrollEnabled,
            tabStyle = props.tabStyle;
        var routes = props.navigationState.routes;
        var centerDistance = Array.from({
          length: index + 1
        }).reduce(function (total, _, i) {
          var tabWidth = _this.getComputedTabWidth(i, layout, routes, scrollEnabled, tabWidths, _this.getFlattenedTabWidth(tabStyle));

          return total + (index === i ? tabWidth / 2 : tabWidth);
        }, 0);
        var scrollAmount = centerDistance - layout.width / 2;
        return _this.normalizeScrollValue(props, state, scrollAmount);
      };

      _this.resetScroll = function (index) {
        if (_this.props.scrollEnabled) {
          _this.scrollView && _this.scrollView.scrollTo({
            x: _this.getScrollAmount(_this.props, _this.state, index),
            animated: true
          });
        }
      };

      _this.handleLayout = function (e) {
        var _e$nativeEvent$layout = e.nativeEvent.layout,
            height = _e$nativeEvent$layout.height,
            width = _e$nativeEvent$layout.width;

        if (_this.state.layout.width === width && _this.state.layout.height === height) {
          return;
        }

        requestAnimationFrame(function () {
          return requestAnimationFrame(function () {
            return _this.setState({
              layout: {
                height: height,
                width: width
              }
            });
          });
        });
      };

      _this.getTranslateX = (0, _memoize.default)(function (scrollAmount, maxScrollDistance) {
        return _reactNativeReanimated.default.multiply(_reactNative.Platform.OS === 'android' && _reactNative.I18nManager.isRTL ? _reactNativeReanimated.default.sub(maxScrollDistance, scrollAmount) : scrollAmount, _reactNative.I18nManager.isRTL ? 1 : -1);
      });
      return _this;
    }

    (0, _createClass2.default)(TabBar, [{
      key: "componentDidUpdate",
      value: function componentDidUpdate(prevProps, prevState) {
        var navigationState = this.props.navigationState;
        var _this$state = this.state,
            layout = _this$state.layout,
            tabWidths = _this$state.tabWidths;

        if (prevProps.navigationState.routes.length !== navigationState.routes.length || prevProps.navigationState.index !== navigationState.index || prevState.layout.width !== layout.width || prevState.tabWidths !== tabWidths) {
          if (this.getFlattenedTabWidth(this.props.tabStyle) === 'auto' && !(layout.width && navigationState.routes.every(function (r) {
            return typeof tabWidths[r.key] === 'number';
          }))) {
            return;
          }

          this.resetScroll(navigationState.index);
        }
      }
    }, {
      key: "render",
      value: function render() {
        var _this2 = this;

        var _this$props = this.props,
            position = _this$props.position,
            navigationState = _this$props.navigationState,
            jumpTo = _this$props.jumpTo,
            scrollEnabled = _this$props.scrollEnabled,
            bounces = _this$props.bounces,
            getAccessibilityLabel = _this$props.getAccessibilityLabel,
            getAccessible = _this$props.getAccessible,
            getLabelText = _this$props.getLabelText,
            getTestID = _this$props.getTestID,
            renderBadge = _this$props.renderBadge,
            renderIcon = _this$props.renderIcon,
            renderLabel = _this$props.renderLabel,
            activeColor = _this$props.activeColor,
            inactiveColor = _this$props.inactiveColor,
            pressColor = _this$props.pressColor,
            pressOpacity = _this$props.pressOpacity,
            onTabPress = _this$props.onTabPress,
            onTabLongPress = _this$props.onTabLongPress,
            tabStyle = _this$props.tabStyle,
            labelStyle = _this$props.labelStyle,
            indicatorStyle = _this$props.indicatorStyle,
            contentContainerStyle = _this$props.contentContainerStyle,
            style = _this$props.style,
            indicatorContainerStyle = _this$props.indicatorContainerStyle;
        var _this$state2 = this.state,
            layout = _this$state2.layout,
            tabWidths = _this$state2.tabWidths;
        var routes = navigationState.routes;
        var isWidthDynamic = this.getFlattenedTabWidth(tabStyle) === 'auto';
        var tabBarWidth = this.getTabBarWidth(this.props, this.state);
        var tabBarWidthPercent = routes.length * 40 + "%";
        var translateX = this.getTranslateX(this.scrollAmount, this.getMaxScrollDistance(tabBarWidth, layout.width));
        return React.createElement(_reactNativeReanimated.default.View, {
          onLayout: this.handleLayout,
          style: [styles.tabBar, style],
          __source: {
            fileName: _jsxFileName,
            lineNumber: 338
          }
        }, React.createElement(_reactNativeReanimated.default.View, {
          pointerEvents: "none",
          style: [styles.indicatorContainer, scrollEnabled ? {
            transform: [{
              translateX: translateX
            }]
          } : null, tabBarWidth ? {
            width: tabBarWidth
          } : scrollEnabled ? {
            width: tabBarWidthPercent
          } : null, indicatorContainerStyle],
          __source: {
            fileName: _jsxFileName,
            lineNumber: 342
          }
        }, this.props.renderIndicator({
          position: position,
          layout: layout,
          navigationState: navigationState,
          jumpTo: jumpTo,
          width: isWidthDynamic ? 'auto' : 100 / routes.length + "%",
          style: indicatorStyle,
          getTabWidth: this.getMemoizedTabWidthGettter(layout, routes, scrollEnabled, tabWidths, this.getFlattenedTabWidth(tabStyle))
        })), React.createElement(_reactNative.View, {
          style: styles.scroll,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 371
          }
        }, React.createElement(_reactNativeReanimated.default.ScrollView, {
          horizontal: true,
          keyboardShouldPersistTaps: "handled",
          scrollEnabled: scrollEnabled,
          bounces: bounces,
          alwaysBounceHorizontal: false,
          scrollsToTop: false,
          showsHorizontalScrollIndicator: false,
          automaticallyAdjustContentInsets: false,
          overScrollMode: "never",
          contentContainerStyle: [styles.tabContent, scrollEnabled ? {
            width: tabBarWidth || tabBarWidthPercent
          } : styles.container, contentContainerStyle],
          scrollEventThrottle: 16,
          onScroll: _reactNativeReanimated.default.event([{
            nativeEvent: {
              contentOffset: {
                x: this.scrollAmount
              }
            }
          }]),
          ref: function ref(el) {
            _this2.scrollView = el && el.getNode();
          },
          __source: {
            fileName: _jsxFileName,
            lineNumber: 372
          }
        }, routes.map(function (route) {
          return React.createElement(_TabBarItem.default, {
            onLayout: isWidthDynamic ? function (e) {
              _this2.measuredTabWidths[route.key] = e.nativeEvent.layout.width;

              if (routes.every(function (r) {
                return typeof _this2.measuredTabWidths[r.key] === 'number';
              })) {
                _this2.setState({
                  tabWidths: _objectSpread({}, _this2.measuredTabWidths)
                });
              }
            } : undefined,
            key: route.key,
            position: position,
            route: route,
            navigationState: navigationState,
            getAccessibilityLabel: getAccessibilityLabel,
            getAccessible: getAccessible,
            getLabelText: getLabelText,
            getTestID: getTestID,
            renderBadge: renderBadge,
            renderIcon: renderIcon,
            renderLabel: renderLabel,
            activeColor: activeColor,
            inactiveColor: inactiveColor,
            pressColor: pressColor,
            pressOpacity: pressOpacity,
            onPress: function onPress() {
              var event = {
                route: route,
                defaultPrevented: false,
                preventDefault: function preventDefault() {
                  event.defaultPrevented = true;
                }
              };
              onTabPress && onTabPress(event);

              if (event.defaultPrevented) {
                return;
              }

              _this2.props.jumpTo(route.key);
            },
            onLongPress: function onLongPress() {
              return onTabLongPress && onTabLongPress({
                route: route
              });
            },
            labelStyle: labelStyle,
            style: tabStyle,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 403
            }
          });
        }))));
      }
    }]);
    return TabBar;
  }(React.Component);

  exports.default = TabBar;
  TabBar.defaultProps = {
    getLabelText: function getLabelText(_ref) {
      var route = _ref.route;
      return typeof route.title === 'string' ? route.title.toUpperCase() : route.title;
    },
    getAccessible: function getAccessible(_ref2) {
      var route = _ref2.route;
      return typeof route.accessible !== 'undefined' ? route.accessible : true;
    },
    getAccessibilityLabel: function getAccessibilityLabel(_ref3) {
      var route = _ref3.route;
      return typeof route.accessibilityLabel === 'string' ? route.accessibilityLabel : typeof route.title === 'string' ? route.title : undefined;
    },
    getTestID: function getTestID(_ref4) {
      var route = _ref4.route;
      return route.testID;
    },
    renderIndicator: function renderIndicator(props) {
      return React.createElement(_TabBarIndicator.default, (0, _extends2.default)({}, props, {
        __source: {
          fileName: _jsxFileName,
          lineNumber: 84
        }
      }));
    }
  };

  var styles = _reactNative.StyleSheet.create({
    container: {
      flex: 1
    },
    scroll: {
      overflow: 'scroll'
    },
    tabBar: {
      backgroundColor: '#2196f3',
      elevation: 4,
      shadowColor: 'black',
      shadowOpacity: 0.1,
      shadowRadius: _reactNative.StyleSheet.hairlineWidth,
      shadowOffset: {
        height: _reactNative.StyleSheet.hairlineWidth,
        width: 0
      },
      zIndex: 1
    },
    tabContent: {
      flexDirection: 'row',
      flexWrap: 'nowrap'
    },
    indicatorContainer: {
      position: 'absolute',
      top: 0,
      left: 0,
      right: 0,
      bottom: 0
    }
  });
},600,[9,1,13,46,24,25,32,34,37,54,2,536,601,604,603],"node_modules/react-native-tab-view/lib/module/TabBar.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireWildcard");

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf3 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits"));

  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[7], "react"));

  var _reactNative = _$$_REQUIRE(_dependencyMap[8], "react-native");

  var _TouchableItem = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "./TouchableItem"));

  var _reactNativeReanimated = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[10], "react-native-reanimated"));

  var _memoize = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[11], "./memoize"));

  var _jsxFileName = "/Users/osdnk/work/react-native-tab-view/src/TabBarItem.tsx";
  var DEFAULT_ACTIVE_COLOR = 'rgba(255, 255, 255, 1)';
  var DEFAULT_INACTIVE_COLOR = 'rgba(255, 255, 255, 0.7)';

  var TabBarItem = function (_React$Component) {
    (0, _inherits2.default)(TabBarItem, _React$Component);

    function TabBarItem() {
      var _getPrototypeOf2;

      var _this;

      (0, _classCallCheck2.default)(this, TabBarItem);

      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
        args[_key] = arguments[_key];
      }

      _this = (0, _possibleConstructorReturn2.default)(this, (_getPrototypeOf2 = (0, _getPrototypeOf3.default)(TabBarItem)).call.apply(_getPrototypeOf2, [this].concat(args)));
      _this.getActiveOpacity = (0, _memoize.default)(function (position, routes, tabIndex) {
        if (routes.length > 1) {
          var inputRange = routes.map(function (_, i) {
            return i;
          });
          return _reactNativeReanimated.default.interpolate(position, {
            inputRange: inputRange,
            outputRange: inputRange.map(function (i) {
              return i === tabIndex ? 1 : 0;
            })
          });
        } else {
          return 1;
        }
      });
      _this.getInactiveOpacity = (0, _memoize.default)(function (position, routes, tabIndex) {
        if (routes.length > 1) {
          var inputRange = routes.map(function (_, i) {
            return i;
          });
          return _reactNativeReanimated.default.interpolate(position, {
            inputRange: inputRange,
            outputRange: inputRange.map(function (i) {
              return i === tabIndex ? 0 : 1;
            })
          });
        } else {
          return 0;
        }
      });
      return _this;
    }

    (0, _createClass2.default)(TabBarItem, [{
      key: "render",
      value: function render() {
        var _this$props = this.props,
            route = _this$props.route,
            position = _this$props.position,
            navigationState = _this$props.navigationState,
            renderLabelPassed = _this$props.renderLabel,
            renderIcon = _this$props.renderIcon,
            renderBadge = _this$props.renderBadge,
            getLabelText = _this$props.getLabelText,
            getTestID = _this$props.getTestID,
            getAccessibilityLabel = _this$props.getAccessibilityLabel,
            getAccessible = _this$props.getAccessible,
            _this$props$activeCol = _this$props.activeColor,
            activeColor = _this$props$activeCol === void 0 ? DEFAULT_ACTIVE_COLOR : _this$props$activeCol,
            _this$props$inactiveC = _this$props.inactiveColor,
            inactiveColor = _this$props$inactiveC === void 0 ? DEFAULT_INACTIVE_COLOR : _this$props$inactiveC,
            pressColor = _this$props.pressColor,
            pressOpacity = _this$props.pressOpacity,
            labelStyle = _this$props.labelStyle,
            style = _this$props.style,
            onLayout = _this$props.onLayout,
            onPress = _this$props.onPress,
            onLongPress = _this$props.onLongPress;
        var tabIndex = navigationState.routes.indexOf(route);
        var isFocused = navigationState.index === tabIndex;
        var activeOpacity = this.getActiveOpacity(position, navigationState.routes, tabIndex);
        var inactiveOpacity = this.getInactiveOpacity(position, navigationState.routes, tabIndex);
        var icon = null;
        var label = null;

        if (renderIcon) {
          var activeIcon = renderIcon({
            route: route,
            focused: true,
            color: activeColor
          });
          var inactiveIcon = renderIcon({
            route: route,
            focused: false,
            color: inactiveColor
          });

          if (inactiveIcon != null && activeIcon != null) {
            icon = React.createElement(_reactNative.View, {
              style: styles.icon,
              __source: {
                fileName: _jsxFileName,
                lineNumber: 133
              }
            }, React.createElement(_reactNativeReanimated.default.View, {
              style: {
                opacity: inactiveOpacity
              },
              __source: {
                fileName: _jsxFileName,
                lineNumber: 134
              }
            }, inactiveIcon), React.createElement(_reactNativeReanimated.default.View, {
              style: [_reactNative.StyleSheet.absoluteFill, {
                opacity: activeOpacity
              }],
              __source: {
                fileName: _jsxFileName,
                lineNumber: 137
              }
            }, activeIcon));
          }
        }

        var renderLabel = renderLabelPassed !== undefined ? renderLabelPassed : function (_ref) {
          var route = _ref.route,
              color = _ref.color;
          var labelText = getLabelText({
            route: route
          });

          if (typeof labelText === 'string') {
            return React.createElement(_reactNativeReanimated.default.Text, {
              style: [styles.label, icon ? {
                marginTop: 0
              } : null, {
                color: color
              }, labelStyle],
              __source: {
                fileName: _jsxFileName,
                lineNumber: 155
              }
            }, labelText);
          }

          return labelText;
        };

        if (renderLabel) {
          var activeLabel = renderLabel({
            route: route,
            focused: true,
            color: activeColor
          });
          var inactiveLabel = renderLabel({
            route: route,
            focused: false,
            color: inactiveColor
          });
          label = React.createElement(_reactNative.View, {
            __source: {
              fileName: _jsxFileName,
              lineNumber: 184
            }
          }, React.createElement(_reactNativeReanimated.default.View, {
            style: {
              opacity: inactiveOpacity
            },
            __source: {
              fileName: _jsxFileName,
              lineNumber: 185
            }
          }, inactiveLabel), React.createElement(_reactNativeReanimated.default.View, {
            style: [_reactNative.StyleSheet.absoluteFill, {
              opacity: activeOpacity
            }],
            __source: {
              fileName: _jsxFileName,
              lineNumber: 188
            }
          }, activeLabel));
        }

        var tabStyle = _reactNative.StyleSheet.flatten(style);

        var isWidthSet = tabStyle && tabStyle.width !== undefined;
        var tabContainerStyle = isWidthSet ? null : {
          flex: 1
        };
        var scene = {
          route: route
        };
        var accessibilityLabel = getAccessibilityLabel(scene);
        accessibilityLabel = typeof accessibilityLabel !== 'undefined' ? accessibilityLabel : getLabelText(scene);
        var badge = renderBadge ? renderBadge(scene) : null;
        return React.createElement(_TouchableItem.default, {
          borderless: true,
          testID: getTestID(scene),
          accessible: getAccessible(scene),
          accessibilityLabel: accessibilityLabel,
          accessibilityTraits: isFocused ? ['button', 'selected'] : 'button',
          accessibilityComponentType: "button",
          accessibilityRole: "button",
          accessibilityStates: isFocused ? ['selected'] : [],
          pressColor: pressColor,
          pressOpacity: pressOpacity,
          delayPressIn: 0,
          onLayout: onLayout,
          onPress: onPress,
          onLongPress: onLongPress,
          style: tabContainerStyle,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 213
          }
        }, React.createElement(_reactNative.View, {
          pointerEvents: "none",
          style: [styles.item, tabStyle],
          __source: {
            fileName: _jsxFileName,
            lineNumber: 230
          }
        }, icon, label, badge != null ? React.createElement(_reactNative.View, {
          style: styles.badge,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 233
          }
        }, badge) : null));
      }
    }]);
    return TabBarItem;
  }(React.Component);

  exports.default = TabBarItem;

  var styles = _reactNative.StyleSheet.create({
    label: {
      margin: 4,
      backgroundColor: 'transparent'
    },
    icon: {
      margin: 2
    },
    item: {
      flex: 1,
      alignItems: 'center',
      justifyContent: 'center',
      padding: 10,
      minHeight: 48
    },
    badge: {
      position: 'absolute',
      top: 0,
      right: 0
    }
  });
},601,[9,1,24,25,32,34,37,54,2,602,536,603],"node_modules/react-native-tab-view/lib/module/TabBarItem.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireWildcard");

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _extends2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/extends"));

  var _objectWithoutProperties2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/objectWithoutProperties"));

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "@babel/runtime/helpers/inherits"));

  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[9], "react"));

  var _reactNative = _$$_REQUIRE(_dependencyMap[10], "react-native");

  var _jsxFileName = "/Users/osdnk/work/react-native-tab-view/src/TouchableItem.tsx";
  var LOLLIPOP = 21;

  var TouchableItem = function (_React$Component) {
    (0, _inherits2.default)(TouchableItem, _React$Component);

    function TouchableItem() {
      (0, _classCallCheck2.default)(this, TouchableItem);
      return (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(TouchableItem).apply(this, arguments));
    }

    (0, _createClass2.default)(TouchableItem, [{
      key: "render",
      value: function render() {
        var _this$props = this.props,
            style = _this$props.style,
            pressOpacity = _this$props.pressOpacity,
            pressColor = _this$props.pressColor,
            borderless = _this$props.borderless,
            children = _this$props.children,
            rest = (0, _objectWithoutProperties2.default)(_this$props, ["style", "pressOpacity", "pressColor", "borderless", "children"]);

        if (_reactNative.Platform.OS === 'android' && _reactNative.Platform.Version >= LOLLIPOP) {
          return React.createElement(_reactNative.TouchableNativeFeedback, (0, _extends2.default)({}, rest, {
            background: _reactNative.TouchableNativeFeedback.Ripple(pressColor, borderless),
            __source: {
              fileName: _jsxFileName,
              lineNumber: 42
            }
          }), React.createElement(_reactNative.View, {
            style: style,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 46
            }
          }, React.Children.only(children)));
        } else {
          return React.createElement(_reactNative.TouchableOpacity, (0, _extends2.default)({}, rest, {
            style: style,
            activeOpacity: pressOpacity,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 51
            }
          }), children);
        }
      }
    }]);
    return TouchableItem;
  }(React.Component);

  exports.default = TouchableItem;
  TouchableItem.defaultProps = {
    pressColor: 'rgba(255, 255, 255, .4)'
  };
},602,[9,1,13,52,24,25,32,34,37,54,2],"node_modules/react-native-tab-view/lib/module/TouchableItem.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = memoize;

  function memoize(callback) {
    var previous;
    var result;
    return function () {
      var hasChanged = false;

      for (var _len = arguments.length, dependencies = new Array(_len), _key = 0; _key < _len; _key++) {
        dependencies[_key] = arguments[_key];
      }

      if (previous) {
        if (previous.length !== dependencies.length) {
          hasChanged = true;
        } else {
          for (var i = 0; i < previous.length; i++) {
            if (previous[i] !== dependencies[i]) {
              hasChanged = true;
              break;
            }
          }
        }
      } else {
        hasChanged = true;
      }

      previous = dependencies;

      if (hasChanged || result === undefined) {
        result = callback.apply(void 0, dependencies);
      }

      return result;
    };
  }
},603,[],"node_modules/react-native-tab-view/lib/module/memoize.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireWildcard");

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _toConsumableArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/toConsumableArray"));

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf3 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "@babel/runtime/helpers/inherits"));

  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[8], "react"));

  var _reactNative = _$$_REQUIRE(_dependencyMap[9], "react-native");

  var _reactNativeReanimated = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[10], "react-native-reanimated"));

  var _memoize = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[11], "./memoize"));

  var _jsxFileName = "/Users/osdnk/work/react-native-tab-view/src/TabBarIndicator.tsx";
  var interpolate = _reactNativeReanimated.default.interpolate,
      multiply = _reactNativeReanimated.default.multiply,
      Extrapolate = _reactNativeReanimated.default.Extrapolate;

  var TabBarIndicator = function (_React$Component) {
    (0, _inherits2.default)(TabBarIndicator, _React$Component);

    function TabBarIndicator() {
      var _getPrototypeOf2;

      var _this;

      (0, _classCallCheck2.default)(this, TabBarIndicator);

      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
        args[_key] = arguments[_key];
      }

      _this = (0, _possibleConstructorReturn2.default)(this, (_getPrototypeOf2 = (0, _getPrototypeOf3.default)(TabBarIndicator)).call.apply(_getPrototypeOf2, [this].concat(args)));

      _this.fadeInIndicator = function () {
        var _this$props = _this.props,
            navigationState = _this$props.navigationState,
            layout = _this$props.layout,
            width = _this$props.width,
            getTabWidth = _this$props.getTabWidth;

        if (!_this.isIndicatorShown && width === 'auto' && layout.width && navigationState.routes.every(function (_, i) {
          return getTabWidth(i);
        })) {
          _this.isIndicatorShown = true;

          _reactNativeReanimated.default.timing(_this.opacity, {
            duration: 150,
            toValue: 1,
            easing: _reactNativeReanimated.Easing.in(_reactNativeReanimated.Easing.linear)
          }).start();
        }
      };

      _this.isIndicatorShown = false;
      _this.opacity = new _reactNativeReanimated.default.Value(_this.props.width === 'auto' ? 0 : 1);
      _this.getTranslateX = (0, _memoize.default)(function (position, routes, getTabWidth) {
        var inputRange = routes.map(function (_, i) {
          return i;
        });
        var outputRange = routes.reduce(function (acc, _, i) {
          if (i === 0) return [0];
          return [].concat((0, _toConsumableArray2.default)(acc), [acc[i - 1] + getTabWidth(i - 1)]);
        }, []);
        var translateX = interpolate(position, {
          inputRange: inputRange,
          outputRange: outputRange,
          extrapolate: Extrapolate.CLAMP
        });
        return multiply(translateX, _reactNative.I18nManager.isRTL ? -1 : 1);
      });
      _this.getWidth = (0, _memoize.default)(function (position, routes, getTabWidth) {
        var inputRange = routes.map(function (_, i) {
          return i;
        });
        var outputRange = inputRange.map(getTabWidth);
        return interpolate(position, {
          inputRange: inputRange,
          outputRange: outputRange,
          extrapolate: Extrapolate.CLAMP
        });
      });
      return _this;
    }

    (0, _createClass2.default)(TabBarIndicator, [{
      key: "componentDidMount",
      value: function componentDidMount() {
        this.fadeInIndicator();
      }
    }, {
      key: "componentDidUpdate",
      value: function componentDidUpdate() {
        this.fadeInIndicator();
      }
    }, {
      key: "render",
      value: function render() {
        var _this$props2 = this.props,
            position = _this$props2.position,
            navigationState = _this$props2.navigationState,
            getTabWidth = _this$props2.getTabWidth,
            width = _this$props2.width,
            style = _this$props2.style,
            layout = _this$props2.layout;
        var routes = navigationState.routes;
        var translateX = routes.length > 1 ? this.getTranslateX(position, routes, getTabWidth) : 0;
        var indicatorWidth = width === 'auto' ? routes.length > 1 ? this.getWidth(position, routes, getTabWidth) : getTabWidth(0) : width;
        return React.createElement(_reactNativeReanimated.default.View, {
          style: [styles.indicator, {
            width: indicatorWidth
          }, layout.width ? {
            transform: [{
              translateX: translateX
            }]
          } : {
            left: 100 / routes.length * navigationState.index + "%"
          }, width === 'auto' ? {
            opacity: this.opacity
          } : null, style],
          __source: {
            fileName: _jsxFileName,
            lineNumber: 117
          }
        });
      }
    }]);
    return TabBarIndicator;
  }(React.Component);

  exports.default = TabBarIndicator;

  var styles = _reactNative.StyleSheet.create({
    indicator: {
      backgroundColor: '#ffeb3b',
      position: 'absolute',
      left: 0,
      bottom: 0,
      right: 0,
      height: 2
    }
  });
},604,[9,1,20,24,25,32,34,37,54,2,536,603],"node_modules/react-native-tab-view/lib/module/TabBarIndicator.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireWildcard");

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf3 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits"));

  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[7], "react"));

  var _reactNative = _$$_REQUIRE(_dependencyMap[8], "react-native");

  var _jsxFileName = "/Users/osdnk/work/react-native-tab-view/src/SceneView.tsx";

  var SceneView = function (_React$Component) {
    (0, _inherits2.default)(SceneView, _React$Component);

    function SceneView() {
      var _getPrototypeOf2;

      var _this;

      (0, _classCallCheck2.default)(this, SceneView);

      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
        args[_key] = arguments[_key];
      }

      _this = (0, _possibleConstructorReturn2.default)(this, (_getPrototypeOf2 = (0, _getPrototypeOf3.default)(SceneView)).call.apply(_getPrototypeOf2, [this].concat(args)));
      _this.state = {
        loading: Math.abs(_this.props.navigationState.index - _this.props.index) > _this.props.lazyPreloadDistance
      };

      _this.handleEnter = function (value) {
        var index = _this.props.index;

        if (value === index && _this.state.loading) {
          _this.setState({
            loading: false
          });
        }
      };

      return _this;
    }

    (0, _createClass2.default)(SceneView, [{
      key: "componentDidMount",
      value: function componentDidMount() {
        var _this2 = this;

        if (this.props.lazy) {
          this.props.addListener('enter', this.handleEnter);
        } else if (this.state.loading) {
          setTimeout(function () {
            return _this2.setState({
              loading: false
            });
          }, 0);
        }
      }
    }, {
      key: "componentDidUpdate",
      value: function componentDidUpdate(prevProps, prevState) {
        if (this.props.lazy !== prevProps.lazy || this.state.loading !== prevState.loading) {
          if (this.props.lazy && this.state.loading) {
            this.props.addListener('enter', this.handleEnter);
          } else {
            this.props.removeListener('enter', this.handleEnter);
          }
        }
      }
    }, {
      key: "componentWillUnmount",
      value: function componentWillUnmount() {
        this.props.removeListener('enter', this.handleEnter);
      }
    }, {
      key: "render",
      value: function render() {
        var _this$props = this.props,
            navigationState = _this$props.navigationState,
            index = _this$props.index,
            layout = _this$props.layout,
            style = _this$props.style;
        var loading = this.state.loading;
        var focused = navigationState.index === index;
        return React.createElement(_reactNative.View, {
          accessibilityElementsHidden: !focused,
          importantForAccessibility: focused ? 'auto' : 'no-hide-descendants',
          style: [styles.route, layout.width ? {
            width: layout.width
          } : focused ? _reactNative.StyleSheet.absoluteFill : null, style],
          __source: {
            fileName: _jsxFileName,
            lineNumber: 92
          }
        }, focused || layout.width ? this.props.children({
          loading: loading
        }) : null);
      }
    }], [{
      key: "getDerivedStateFromProps",
      value: function getDerivedStateFromProps(props, state) {
        if (state.loading && Math.abs(props.navigationState.index - props.index) <= props.lazyPreloadDistance) {
          return {
            loading: false
          };
        }

        return null;
      }
    }]);
    return SceneView;
  }(React.Component);

  exports.default = SceneView;

  var styles = _reactNative.StyleSheet.create({
    route: {
      flex: 1,
      overflow: 'hidden'
    }
  });
},605,[9,1,24,25,32,34,37,54,2],"node_modules/react-native-tab-view/lib/module/SceneView.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireWildcard");

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _extends2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/extends"));

  var _defineProperty2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/defineProperty"));

  var _slicedToArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/slicedToArray"));

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf3 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "@babel/runtime/helpers/inherits"));

  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[10], "react"));

  var _reactNative = _$$_REQUIRE(_dependencyMap[11], "react-native");

  var _reactNativeGestureHandler = _$$_REQUIRE(_dependencyMap[12], "react-native-gesture-handler");

  var _reactNativeReanimated = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[13], "react-native-reanimated"));

  var _memoize = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[14], "./memoize"));

  var _jsxFileName = "/Users/osdnk/work/react-native-tab-view/src/Pager.tsx";

  function ownKeys(object, enumerableOnly) {
    var keys = Object.keys(object);

    if (Object.getOwnPropertySymbols) {
      var symbols = Object.getOwnPropertySymbols(object);
      if (enumerableOnly) symbols = symbols.filter(function (sym) {
        return Object.getOwnPropertyDescriptor(object, sym).enumerable;
      });
      keys.push.apply(keys, symbols);
    }

    return keys;
  }

  function _objectSpread(target) {
    for (var i = 1; i < arguments.length; i++) {
      var source = arguments[i] != null ? arguments[i] : {};

      if (i % 2) {
        ownKeys(source, true).forEach(function (key) {
          (0, _defineProperty2.default)(target, key, source[key]);
        });
      } else if (Object.getOwnPropertyDescriptors) {
        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
      } else {
        ownKeys(source).forEach(function (key) {
          Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
        });
      }
    }

    return target;
  }

  var Clock = _reactNativeReanimated.default.Clock,
      Value = _reactNativeReanimated.default.Value,
      onChange = _reactNativeReanimated.default.onChange,
      and = _reactNativeReanimated.default.and,
      abs = _reactNativeReanimated.default.abs,
      add = _reactNativeReanimated.default.add,
      block = _reactNativeReanimated.default.block,
      call = _reactNativeReanimated.default.call,
      ceil = _reactNativeReanimated.default.ceil,
      clockRunning = _reactNativeReanimated.default.clockRunning,
      cond = _reactNativeReanimated.default.cond,
      divide = _reactNativeReanimated.default.divide,
      eq = _reactNativeReanimated.default.eq,
      event = _reactNativeReanimated.default.event,
      floor = _reactNativeReanimated.default.floor,
      greaterThan = _reactNativeReanimated.default.greaterThan,
      lessThan = _reactNativeReanimated.default.lessThan,
      max = _reactNativeReanimated.default.max,
      min = _reactNativeReanimated.default.min,
      multiply = _reactNativeReanimated.default.multiply,
      neq = _reactNativeReanimated.default.neq,
      not = _reactNativeReanimated.default.not,
      round = _reactNativeReanimated.default.round,
      set = _reactNativeReanimated.default.set,
      spring = _reactNativeReanimated.default.spring,
      startClock = _reactNativeReanimated.default.startClock,
      stopClock = _reactNativeReanimated.default.stopClock,
      sub = _reactNativeReanimated.default.sub,
      timing = _reactNativeReanimated.default.timing;
  var TRUE = 1;
  var FALSE = 0;
  var NOOP = 0;
  var UNSET = -1;
  var DIRECTION_LEFT = 1;
  var DIRECTION_RIGHT = -1;
  var SWIPE_DISTANCE_MINIMUM = 20;
  var SWIPE_VELOCITY_IMPACT = 0.2;
  var SPRING_CONFIG = {
    stiffness: 1000,
    damping: 500,
    mass: 3,
    overshootClamping: true,
    restDisplacementThreshold: 0.01,
    restSpeedThreshold: 0.01
  };
  var SPRING_VELOCITY_SCALE = 1;
  var TIMING_CONFIG = {
    duration: 200,
    easing: _reactNativeReanimated.Easing.out(_reactNativeReanimated.Easing.cubic)
  };

  var Pager = function (_React$Component) {
    (0, _inherits2.default)(Pager, _React$Component);

    function Pager() {
      var _getPrototypeOf2;

      var _this;

      (0, _classCallCheck2.default)(this, Pager);

      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
        args[_key] = arguments[_key];
      }

      _this = (0, _possibleConstructorReturn2.default)(this, (_getPrototypeOf2 = (0, _getPrototypeOf3.default)(Pager)).call.apply(_getPrototypeOf2, [this].concat(args)));
      _this.clock = new Clock();
      _this.velocityX = new Value(0);
      _this.gestureX = new Value(0);
      _this.gestureState = new Value(_reactNativeGestureHandler.State.UNDETERMINED);
      _this.offsetX = new Value(0);
      _this.progress = new Value(_this.props.navigationState.index * _this.props.layout.width * DIRECTION_RIGHT);
      _this.index = new Value(_this.props.navigationState.index);
      _this.nextIndex = new Value(UNSET);
      _this.lastEnteredIndex = new Value(_this.props.navigationState.index);
      _this.isSwiping = new Value(FALSE);
      _this.isSwipeGesture = new Value(FALSE);
      _this.indexAtSwipeEnd = new Value(_this.props.navigationState.index);
      _this.routesLength = new Value(_this.props.navigationState.routes.length);
      _this.layoutWidth = new Value(_this.props.layout.width);
      _this.swipeVelocityImpact = new Value(_this.props.swipeVelocityImpact !== undefined ? _this.props.swipeVelocityImpact : SWIPE_VELOCITY_IMPACT);
      _this.springVelocityScale = new Value(_this.props.springVelocityScale !== undefined ? _this.props.springVelocityScale : SPRING_VELOCITY_SCALE);
      _this.position = cond(_this.layoutWidth, divide(multiply(_this.progress, -1), _this.layoutWidth), _this.index);
      _this.springConfig = {
        damping: new Value(_this.props.springConfig.damping !== undefined ? _this.props.springConfig.damping : SPRING_CONFIG.damping),
        mass: new Value(_this.props.springConfig.mass !== undefined ? _this.props.springConfig.mass : SPRING_CONFIG.mass),
        stiffness: new Value(_this.props.springConfig.stiffness !== undefined ? _this.props.springConfig.stiffness : SPRING_CONFIG.stiffness),
        restSpeedThreshold: new Value(_this.props.springConfig.restSpeedThreshold !== undefined ? _this.props.springConfig.restSpeedThreshold : SPRING_CONFIG.restSpeedThreshold),
        restDisplacementThreshold: new Value(_this.props.springConfig.restDisplacementThreshold !== undefined ? _this.props.springConfig.restDisplacementThreshold : SPRING_CONFIG.restDisplacementThreshold)
      };
      _this.timingConfig = {
        duration: new Value(_this.props.timingConfig.duration !== undefined ? _this.props.timingConfig.duration : TIMING_CONFIG.duration)
      };
      _this.initialVelocityForSpring = new Value(0);
      _this.currentIndexValue = _this.props.navigationState.index;
      _this.pendingIndexValue = undefined;
      _this.previouslyFocusedTextInput = null;
      _this.enterListeners = [];

      _this.jumpToIndex = function (index) {
        _this.isSwipeGesture.setValue(FALSE);

        _this.nextIndex.setValue(index);
      };

      _this.jumpTo = function (key) {
        var _this$props = _this.props,
            navigationState = _this$props.navigationState,
            keyboardDismissMode = _this$props.keyboardDismissMode,
            onIndexChange = _this$props.onIndexChange;
        var index = navigationState.routes.findIndex(function (route) {
          return route.key === key;
        });

        if (navigationState.index === index) {
          _this.jumpToIndex(index);
        } else {
          onIndexChange(index);

          if (keyboardDismissMode === 'auto') {
            _reactNative.Keyboard.dismiss();
          }
        }
      };

      _this.addListener = function (type, listener) {
        switch (type) {
          case 'enter':
            _this.enterListeners.push(listener);

            break;
        }
      };

      _this.removeListener = function (type, listener) {
        switch (type) {
          case 'enter':
            {
              var _index = _this.enterListeners.indexOf(listener);

              if (_index > -1) {
                _this.enterListeners.splice(_index, 1);
              }

              break;
            }
        }
      };

      _this.handleEnteredIndexChange = function (_ref) {
        var _ref2 = (0, _slicedToArray2.default)(_ref, 1),
            value = _ref2[0];

        var index = Math.max(0, Math.min(value, _this.props.navigationState.routes.length - 1));

        _this.enterListeners.forEach(function (listener) {
          return listener(index);
        });
      };

      _this.transitionTo = function (index) {
        var toValue = new Value(0);
        var frameTime = new Value(0);
        var state = {
          position: _this.progress,
          time: new Value(0),
          finished: new Value(FALSE)
        };
        return block([cond(clockRunning(_this.clock), NOOP, [set(toValue, multiply(index, _this.layoutWidth, DIRECTION_RIGHT)), set(frameTime, 0), set(state.time, 0), set(state.finished, FALSE), set(_this.index, index)]), cond(_this.isSwipeGesture, [cond(not(clockRunning(_this.clock)), _reactNative.I18nManager.isRTL ? set(_this.initialVelocityForSpring, multiply(-1, _this.velocityX, _this.springVelocityScale)) : set(_this.initialVelocityForSpring, multiply(_this.velocityX, _this.springVelocityScale))), spring(_this.clock, _objectSpread({}, state, {
          velocity: _this.initialVelocityForSpring
        }), _objectSpread({}, SPRING_CONFIG, {}, _this.springConfig, {
          toValue: toValue
        }))], timing(_this.clock, _objectSpread({}, state, {
          frameTime: frameTime
        }), _objectSpread({}, TIMING_CONFIG, {}, _this.timingConfig, {
          toValue: toValue
        }))), cond(not(clockRunning(_this.clock)), startClock(_this.clock)), cond(state.finished, [set(_this.isSwipeGesture, FALSE), set(_this.gestureX, 0), set(_this.velocityX, 0), stopClock(_this.clock)])]);
      };

      _this.handleGestureEvent = event([{
        nativeEvent: {
          translationX: _this.gestureX,
          velocityX: _this.velocityX,
          state: _this.gestureState
        }
      }]);
      _this.extrapolatedPosition = add(_this.gestureX, multiply(_this.velocityX, _this.swipeVelocityImpact));
      _this.translateX = block([onChange(_this.index, call([_this.index], function (_ref3) {
        var _ref4 = (0, _slicedToArray2.default)(_ref3, 1),
            value = _ref4[0];

        _this.currentIndexValue = value;

        if (value !== _this.props.navigationState.index) {
          _this.props.onIndexChange(value);

          _this.pendingIndexValue = value;

          _this.forceUpdate();
        }
      })), onChange(_this.position, cond(_reactNative.I18nManager.isRTL ? lessThan(_this.gestureX, 0) : greaterThan(_this.gestureX, 0), cond(neq(floor(_this.position), _this.lastEnteredIndex), [set(_this.lastEnteredIndex, floor(_this.position)), call([floor(_this.position)], _this.handleEnteredIndexChange)]), cond(neq(ceil(_this.position), _this.lastEnteredIndex), [set(_this.lastEnteredIndex, ceil(_this.position)), call([ceil(_this.position)], _this.handleEnteredIndexChange)]))), onChange(_this.isSwiping, call([_this.isSwiping, _this.indexAtSwipeEnd, _this.index], function (_ref5) {
        var _ref6 = (0, _slicedToArray2.default)(_ref5, 3),
            isSwiping = _ref6[0],
            indexAtSwipeEnd = _ref6[1],
            currentIndex = _ref6[2];

        var _this$props2 = _this.props,
            keyboardDismissMode = _this$props2.keyboardDismissMode,
            onSwipeStart = _this$props2.onSwipeStart,
            onSwipeEnd = _this$props2.onSwipeEnd;

        if (isSwiping === TRUE) {
          onSwipeStart && onSwipeStart();

          if (keyboardDismissMode === 'auto') {
            var input = _reactNative.TextInput.State.currentlyFocusedField();

            _reactNative.TextInput.State.blurTextInput(input);

            _this.previouslyFocusedTextInput = input;
          } else if (keyboardDismissMode === 'on-drag') {
            _reactNative.Keyboard.dismiss();
          }
        } else {
          onSwipeEnd && onSwipeEnd();

          if (keyboardDismissMode === 'auto') {
            if (indexAtSwipeEnd === currentIndex) {
              var _input = _this.previouslyFocusedTextInput;

              if (_input) {
                _reactNative.TextInput.State.focusTextInput(_input);
              }
            }

            _this.previouslyFocusedTextInput = null;
          }
        }
      })), onChange(_this.nextIndex, cond(neq(_this.nextIndex, UNSET), [cond(clockRunning(_this.clock), stopClock(_this.clock)), set(_this.gestureX, 0), set(_this.index, _this.nextIndex), set(_this.nextIndex, UNSET)])), cond(eq(_this.gestureState, _reactNativeGestureHandler.State.ACTIVE), [cond(_this.isSwiping, NOOP, [set(_this.isSwiping, TRUE), set(_this.isSwipeGesture, TRUE), set(_this.offsetX, _this.progress)]), set(_this.progress, _reactNative.I18nManager.isRTL ? sub(_this.offsetX, _this.gestureX) : add(_this.offsetX, _this.gestureX)), stopClock(_this.clock)], [set(_this.isSwiping, FALSE), set(_this.indexAtSwipeEnd, _this.index), _this.transitionTo(cond(and(greaterThan(abs(_this.gestureX), SWIPE_DISTANCE_MINIMUM), greaterThan(abs(_this.extrapolatedPosition), divide(_this.layoutWidth, 2))), round(min(max(0, sub(_this.index, cond(greaterThan(_this.extrapolatedPosition, 0), _reactNative.I18nManager.isRTL ? DIRECTION_RIGHT : DIRECTION_LEFT, _reactNative.I18nManager.isRTL ? DIRECTION_LEFT : DIRECTION_RIGHT))), sub(_this.routesLength, 1))), _this.index))]), _this.progress]);
      _this.getTranslateX = (0, _memoize.default)(function (layoutWidth, routesLength, translateX) {
        return multiply(min(max(multiply(layoutWidth, sub(routesLength, 1), DIRECTION_RIGHT), translateX), 0), _reactNative.I18nManager.isRTL ? -1 : 1);
      });
      return _this;
    }

    (0, _createClass2.default)(Pager, [{
      key: "componentDidUpdate",
      value: function componentDidUpdate(prevProps) {
        var _this$props3 = this.props,
            navigationState = _this$props3.navigationState,
            layout = _this$props3.layout,
            swipeVelocityImpact = _this$props3.swipeVelocityImpact,
            springVelocityScale = _this$props3.springVelocityScale,
            springConfig = _this$props3.springConfig,
            timingConfig = _this$props3.timingConfig;
        var index = navigationState.index,
            routes = navigationState.routes;

        if (index !== prevProps.navigationState.index && index !== this.currentIndexValue || typeof this.pendingIndexValue === 'number' && index !== this.pendingIndexValue) {
          this.jumpToIndex(index);
        }

        this.pendingIndexValue = undefined;

        if (prevProps.navigationState.routes.length !== routes.length) {
          this.routesLength.setValue(routes.length);
        }

        if (prevProps.layout.width !== layout.width) {
          this.progress.setValue(-index * layout.width);
          this.layoutWidth.setValue(layout.width);
        }

        if (prevProps.swipeVelocityImpact !== swipeVelocityImpact) {
          this.swipeVelocityImpact.setValue(swipeVelocityImpact !== undefined ? swipeVelocityImpact : SWIPE_VELOCITY_IMPACT);
        }

        if (prevProps.springVelocityScale !== springVelocityScale) {
          this.springVelocityScale.setValue(springVelocityScale !== undefined ? springVelocityScale : SPRING_VELOCITY_SCALE);
        }

        if (prevProps.springConfig !== springConfig) {
          this.springConfig.damping.setValue(springConfig.damping !== undefined ? springConfig.damping : SPRING_CONFIG.damping);
          this.springConfig.mass.setValue(springConfig.mass !== undefined ? springConfig.mass : SPRING_CONFIG.mass);
          this.springConfig.stiffness.setValue(springConfig.stiffness !== undefined ? springConfig.stiffness : SPRING_CONFIG.stiffness);
          this.springConfig.restSpeedThreshold.setValue(springConfig.restSpeedThreshold !== undefined ? springConfig.restSpeedThreshold : SPRING_CONFIG.restSpeedThreshold);
          this.springConfig.restDisplacementThreshold.setValue(springConfig.restDisplacementThreshold !== undefined ? springConfig.restDisplacementThreshold : SPRING_CONFIG.restDisplacementThreshold);
        }

        if (prevProps.timingConfig !== timingConfig) {
          this.timingConfig.duration.setValue(timingConfig.duration !== undefined ? timingConfig.duration : TIMING_CONFIG.duration);
        }
      }
    }, {
      key: "render",
      value: function render() {
        var _this2 = this;

        var _this$props4 = this.props,
            layout = _this$props4.layout,
            navigationState = _this$props4.navigationState,
            swipeEnabled = _this$props4.swipeEnabled,
            children = _this$props4.children,
            removeClippedSubviews = _this$props4.removeClippedSubviews,
            gestureHandlerProps = _this$props4.gestureHandlerProps;
        var translateX = this.getTranslateX(this.layoutWidth, this.routesLength, this.translateX);
        return children({
          position: this.position,
          addListener: this.addListener,
          removeListener: this.removeListener,
          jumpTo: this.jumpTo,
          render: function render(children) {
            return React.createElement(_reactNativeGestureHandler.PanGestureHandler, (0, _extends2.default)({
              enabled: layout.width !== 0 && swipeEnabled,
              onGestureEvent: _this2.handleGestureEvent,
              onHandlerStateChange: _this2.handleGestureEvent,
              activeOffsetX: [-SWIPE_DISTANCE_MINIMUM, SWIPE_DISTANCE_MINIMUM],
              failOffsetY: [-SWIPE_DISTANCE_MINIMUM, SWIPE_DISTANCE_MINIMUM]
            }, gestureHandlerProps, {
              __source: {
                fileName: _jsxFileName,
                lineNumber: 659
              }
            }), React.createElement(_reactNativeReanimated.default.View, {
              removeClippedSubviews: removeClippedSubviews,
              style: [styles.container, layout.width ? {
                width: layout.width * navigationState.routes.length,
                transform: [{
                  translateX: translateX
                }]
              } : null],
              __source: {
                fileName: _jsxFileName,
                lineNumber: 667
              }
            }, children));
          }
        });
      }
    }]);
    return Pager;
  }(React.Component);

  exports.default = Pager;
  Pager.defaultProps = {
    swipeVelocityImpact: SWIPE_VELOCITY_IMPACT,
    springVelocityScale: SPRING_VELOCITY_SCALE
  };

  var styles = _reactNative.StyleSheet.create({
    container: {
      flex: 1,
      flexDirection: 'row'
    }
  });
},606,[9,1,13,46,14,24,25,32,34,37,54,2,503,536,603],"node_modules/react-native-tab-view/lib/module/Pager.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireWildcard");

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = SceneMap;

  var _objectWithoutProperties2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/objectWithoutProperties"));

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "@babel/runtime/helpers/inherits"));

  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[8], "react"));

  var _jsxFileName = "/Users/osdnk/work/react-native-tab-view/src/SceneMap.tsx";

  var SceneComponent = function (_React$PureComponent) {
    (0, _inherits2.default)(SceneComponent, _React$PureComponent);

    function SceneComponent() {
      (0, _classCallCheck2.default)(this, SceneComponent);
      return (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(SceneComponent).apply(this, arguments));
    }

    (0, _createClass2.default)(SceneComponent, [{
      key: "render",
      value: function render() {
        var _this$props = this.props,
            component = _this$props.component,
            rest = (0, _objectWithoutProperties2.default)(_this$props, ["component"]);
        return React.createElement(component, rest);
      }
    }]);
    return SceneComponent;
  }(React.PureComponent);

  function SceneMap(scenes) {
    return function (_ref) {
      var route = _ref.route,
          jumpTo = _ref.jumpTo,
          position = _ref.position;
      return React.createElement(SceneComponent, {
        key: route.key,
        component: scenes[route.key],
        route: route,
        jumpTo: jumpTo,
        position: position,
        __source: {
          fileName: _jsxFileName,
          lineNumber: 16
        }
      });
    };
  }
},607,[9,1,52,24,25,32,34,37,54],"node_modules/react-native-tab-view/lib/module/SceneMap.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {},608,[],"node_modules/react-native-tab-view/lib/module/types.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireWildcard");

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _extends2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/extends"));

  var _objectWithoutProperties2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/objectWithoutProperties"));

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf3 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "@babel/runtime/helpers/inherits"));

  var React = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[9], "react"));

  var _reactNative = _$$_REQUIRE(_dependencyMap[10], "react-native");

  var _reactNativeTabView = _$$_REQUIRE(_dependencyMap[11], "react-native-tab-view");

  var _reactNativeReanimated = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[12], "react-native-reanimated"));

  var _jsxFileName = "/Users/satya/Workspace/Callstack/react-navigation-tabs/src/views/MaterialTopTabBar.tsx";

  var TabBarTop = function (_React$PureComponent) {
    (0, _inherits2.default)(TabBarTop, _React$PureComponent);

    function TabBarTop() {
      var _getPrototypeOf2;

      var _this;

      (0, _classCallCheck2.default)(this, TabBarTop);

      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
        args[_key] = arguments[_key];
      }

      _this = (0, _possibleConstructorReturn2.default)(this, (_getPrototypeOf2 = (0, _getPrototypeOf3.default)(TabBarTop)).call.apply(_getPrototypeOf2, [this].concat(args)));

      _this._renderLabel = function (_ref) {
        var route = _ref.route,
            focused = _ref.focused,
            color = _ref.color;
        var _this$props = _this.props,
            showLabel = _this$props.showLabel,
            upperCaseLabel = _this$props.upperCaseLabel,
            labelStyle = _this$props.labelStyle,
            allowFontScaling = _this$props.allowFontScaling;

        if (showLabel === false) {
          return null;
        }

        var label = _this.props.getLabelText({
          route: route
        });

        if (typeof label === 'string') {
          return React.createElement(_reactNativeReanimated.default.Text, {
            style: [styles.label, {
              color: color
            }, labelStyle],
            allowFontScaling: allowFontScaling,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 38
            }
          }, upperCaseLabel ? label.toUpperCase() : label);
        }

        if (typeof label === 'function') {
          return label({
            focused: focused,
            tintColor: color
          });
        }

        return label;
      };

      _this._renderIcon = function (_ref2) {
        var route = _ref2.route,
            focused = _ref2.focused,
            color = _ref2.color;
        var _this$props2 = _this.props,
            renderIcon = _this$props2.renderIcon,
            showIcon = _this$props2.showIcon,
            iconStyle = _this$props2.iconStyle;

        if (showIcon === false) {
          return null;
        }

        return React.createElement(_reactNative.View, {
          style: [styles.icon, iconStyle],
          __source: {
            fileName: _jsxFileName,
            lineNumber: 62
          }
        }, renderIcon({
          route: route,
          focused: focused,
          tintColor: color
        }));
      };

      return _this;
    }

    (0, _createClass2.default)(TabBarTop, [{
      key: "render",
      value: function render() {
        var _this$props3 = this.props,
            navigation = _this$props3.navigation,
            activeTintColor = _this$props3.activeTintColor,
            inactiveTintColor = _this$props3.inactiveTintColor,
            renderIcon = _this$props3.renderIcon,
            getLabelText = _this$props3.getLabelText,
            allowFontScaling = _this$props3.allowFontScaling,
            showLabel = _this$props3.showLabel,
            showIcon = _this$props3.showIcon,
            upperCaseLabel = _this$props3.upperCaseLabel,
            tabBarPosition = _this$props3.tabBarPosition,
            screenProps = _this$props3.screenProps,
            iconStyle = _this$props3.iconStyle,
            rest = (0, _objectWithoutProperties2.default)(_this$props3, ["navigation", "activeTintColor", "inactiveTintColor", "renderIcon", "getLabelText", "allowFontScaling", "showLabel", "showIcon", "upperCaseLabel", "tabBarPosition", "screenProps", "iconStyle"]);
        return React.createElement(_reactNativeTabView.TabBar, (0, _extends2.default)({}, rest, {
          activeColor: activeTintColor,
          inactiveColor: inactiveTintColor,
          navigationState: navigation.state,
          renderIcon: this._renderIcon,
          renderLabel: this._renderLabel,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 92
          }
        }));
      }
    }]);
    return TabBarTop;
  }(React.PureComponent);

  exports.default = TabBarTop;
  TabBarTop.defaultProps = {
    activeTintColor: 'rgba(255, 255, 255, 1)',
    inactiveTintColor: 'rgba(255, 255, 255, 0.7)',
    showIcon: false,
    showLabel: true,
    upperCaseLabel: true,
    allowFontScaling: true
  };

  var styles = _reactNative.StyleSheet.create({
    icon: {
      height: 24,
      width: 24
    },
    label: {
      textAlign: 'center',
      fontSize: 13,
      margin: 4,
      backgroundColor: 'transparent'
    }
  });
},609,[9,1,13,52,24,25,32,34,37,54,2,598,536],"node_modules/react-navigation-tabs/lib/module/views/MaterialTopTabBar.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {},610,[],"node_modules/react-navigation-tabs/lib/module/types.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.getImageSource = exports.ToolbarAndroid = exports.TabBarItemIOS = exports.TabBarItem = exports.Button = exports.default = void 0;

  var _createIconSet = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./lib/create-icon-set"));

  var _Ionicons = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "./glyphmaps/Ionicons.json"));

  var iconSet = (0, _createIconSet.default)(_Ionicons.default, 'Ionicons', 'Ionicons.ttf');
  var _default = iconSet;
  exports.default = _default;
  var Button = iconSet.Button;
  exports.Button = Button;
  var TabBarItem = iconSet.TabBarItem;
  exports.TabBarItem = TabBarItem;
  var TabBarItemIOS = iconSet.TabBarItemIOS;
  exports.TabBarItemIOS = TabBarItemIOS;
  var ToolbarAndroid = iconSet.ToolbarAndroid;
  exports.ToolbarAndroid = ToolbarAndroid;
  var getImageSource = iconSet.getImageSource;
  exports.getImageSource = getImageSource;
},611,[1,612,775],"node_modules/react-native-vector-icons/Ionicons.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/interopRequireWildcard");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = createIconSet;
  exports.DEFAULT_ICON_COLOR = exports.DEFAULT_ICON_SIZE = exports.NativeIconAPI = void 0;

  var _toConsumableArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/toConsumableArray"));

  var _extends2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/extends"));

  var _objectWithoutProperties2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/objectWithoutProperties"));

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf3 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "@babel/runtime/helpers/inherits"));

  var _react = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[10], "react"));

  var _propTypes = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[11], "prop-types"));

  var _reactNative = _$$_REQUIRE(_dependencyMap[12], "./react-native");

  var _ensureNativeModuleAvailable = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[13], "./ensure-native-module-available"));

  var _iconButton = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[14], "./icon-button"));

  var _tabBarItemIos = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[15], "./tab-bar-item-ios"));

  var _toolbarAndroid = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[16], "./toolbar-android"));

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native-vector-icons/lib/create-icon-set.js";
  var NativeIconAPI = _reactNative.NativeModules.RNVectorIconsManager || _reactNative.NativeModules.RNVectorIconsModule;
  exports.NativeIconAPI = NativeIconAPI;
  var DEFAULT_ICON_SIZE = 12;
  exports.DEFAULT_ICON_SIZE = DEFAULT_ICON_SIZE;
  var DEFAULT_ICON_COLOR = 'black';
  exports.DEFAULT_ICON_COLOR = DEFAULT_ICON_COLOR;

  function createIconSet(glyphMap, fontFamily, fontFile, fontStyle) {
    var fontBasename = fontFile ? fontFile.replace(/\.(otf|ttf)$/, '') : fontFamily;

    var fontReference = _reactNative.Platform.select({
      windows: "/Assets/" + fontFile + "#" + fontFamily,
      android: fontBasename,
      web: fontBasename,
      default: fontFamily
    });

    var IconNamePropType = _propTypes.default.oneOf(Object.keys(glyphMap));

    var Icon = function (_PureComponent) {
      (0, _inherits2.default)(Icon, _PureComponent);

      function Icon() {
        var _getPrototypeOf2;

        var _this;

        (0, _classCallCheck2.default)(this, Icon);

        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
          args[_key] = arguments[_key];
        }

        _this = (0, _possibleConstructorReturn2.default)(this, (_getPrototypeOf2 = (0, _getPrototypeOf3.default)(Icon)).call.apply(_getPrototypeOf2, [this].concat(args)));
        _this.root = null;

        _this.handleRef = function (ref) {
          _this.root = ref;
        };

        return _this;
      }

      (0, _createClass2.default)(Icon, [{
        key: "setNativeProps",
        value: function setNativeProps(nativeProps) {
          if (this.root) {
            this.root.setNativeProps(nativeProps);
          }
        }
      }, {
        key: "render",
        value: function render() {
          var _this$props = this.props,
              name = _this$props.name,
              size = _this$props.size,
              color = _this$props.color,
              style = _this$props.style,
              children = _this$props.children,
              props = (0, _objectWithoutProperties2.default)(_this$props, ["name", "size", "color", "style", "children"]);
          var glyph = name ? glyphMap[name] || '?' : '';

          if (typeof glyph === 'number') {
            glyph = String.fromCharCode(glyph);
          }

          var styleDefaults = {
            fontSize: size,
            color: color
          };
          var styleOverrides = {
            fontFamily: fontReference,
            fontWeight: 'normal',
            fontStyle: 'normal'
          };
          props.style = [styleDefaults, style, styleOverrides, fontStyle || {}];
          props.ref = this.handleRef;
          return _react.default.createElement(_reactNative.Text, (0, _extends2.default)({}, props, {
            __source: {
              fileName: _jsxFileName,
              lineNumber: 92
            }
          }), glyph, children);
        }
      }]);
      return Icon;
    }(_react.PureComponent);

    Icon.propTypes = {
      allowFontScaling: _propTypes.default.bool,
      name: IconNamePropType,
      size: _propTypes.default.number,
      color: _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.number]),
      children: _propTypes.default.node,
      style: _propTypes.default.any
    };
    Icon.defaultProps = {
      size: DEFAULT_ICON_SIZE,
      allowFontScaling: false
    };
    var imageSourceCache = {};

    function getImageSource(name) {
      var size = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : DEFAULT_ICON_SIZE;
      var color = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : DEFAULT_ICON_COLOR;
      (0, _ensureNativeModuleAvailable.default)();
      var glyph = glyphMap[name] || '?';

      if (typeof glyph === 'number') {
        glyph = String.fromCharCode(glyph);
      }

      var processedColor = (0, _reactNative.processColor)(color);
      var cacheKey = glyph + ":" + size + ":" + processedColor;

      var scale = _reactNative.PixelRatio.get();

      return new Promise(function (resolve, reject) {
        var cached = imageSourceCache[cacheKey];

        if (typeof cached !== 'undefined') {
          if (!cached || cached instanceof Error) {
            reject(cached);
          } else {
            resolve({
              uri: cached,
              scale: scale
            });
          }
        } else {
          NativeIconAPI.getImageForFont(fontReference, glyph, size, processedColor, function (err, image) {
            var error = typeof err === 'string' ? new Error(err) : err;
            imageSourceCache[cacheKey] = image || error || false;

            if (!error && image) {
              resolve({
                uri: image,
                scale: scale
              });
            } else {
              reject(error);
            }
          });
        }
      });
    }

    function loadFont() {
      var file = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : fontFile;

      if (_reactNative.Platform.OS === 'ios') {
        (0, _ensureNativeModuleAvailable.default)();

        if (!file) {
          return Promise.reject(new Error('Unable to load font, because no file was specified. '));
        }

        return NativeIconAPI.loadFontWithFileName.apply(NativeIconAPI, (0, _toConsumableArray2.default)(file.split('.')));
      }

      return Promise.resolve();
    }

    function hasIcon(name) {
      return Object.prototype.hasOwnProperty.call(glyphMap, name);
    }

    function getRawGlyphMap() {
      return glyphMap;
    }

    function getFontFamily() {
      return fontReference;
    }

    Icon.Button = (0, _iconButton.default)(Icon);
    Icon.TabBarItem = (0, _tabBarItemIos.default)(IconNamePropType, getImageSource);
    Icon.TabBarItemIOS = Icon.TabBarItem;
    Icon.ToolbarAndroid = (0, _toolbarAndroid.default)(IconNamePropType, getImageSource);
    Icon.getImageSource = getImageSource;
    Icon.loadFont = loadFont;
    Icon.hasIcon = hasIcon;
    Icon.getRawGlyphMap = getRawGlyphMap;
    Icon.getFontFamily = getFontFamily;
    return Icon;
  }
},612,[1,9,20,13,52,24,25,32,34,37,54,69,613,614,615,760,774],"node_modules/react-native-vector-icons/lib/create-icon-set.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });

  var _reactNative = _$$_REQUIRE(_dependencyMap[0], "react-native");

  Object.keys(_reactNative).forEach(function (key) {
    if (key === "default" || key === "__esModule") return;
    Object.defineProperty(exports, key, {
      enumerable: true,
      get: function get() {
        return _reactNative[key];
      }
    });
  });
},613,[2],"node_modules/react-native-vector-icons/lib/react-native.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = ensureNativeModuleAvailable;

  var _reactNative = _$$_REQUIRE(_dependencyMap[0], "./react-native");

  var NativeIconAPI = _reactNative.NativeModules.RNVectorIconsManager || _reactNative.NativeModules.RNVectorIconsModule;

  function ensureNativeModuleAvailable() {
    if (!NativeIconAPI) {
      if (_reactNative.Platform.OS === 'android') {
        throw new Error('RNVectorIconsModule not available, did you properly integrate the module? Try running `react-native link react-native-vector-icons` and recompiling.');
      }

      throw new Error('RNVectorIconsManager not available, did you add the library to your project and link with libRNVectorIcons.a? Try running `react-native link react-native-vector-icons` and recompiling.');
    }
  }
},614,[613],"node_modules/react-native-vector-icons/lib/ensure-native-module-available.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/interopRequireWildcard");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = createIconButtonComponent;

  var _extends2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/extends"));

  var _objectWithoutProperties2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/objectWithoutProperties"));

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "@babel/runtime/helpers/inherits"));

  var _isString = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "lodash/isString"));

  var _omit = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[10], "lodash/omit"));

  var _pick = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[11], "lodash/pick"));

  var _react = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[12], "react"));

  var _propTypes = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[13], "prop-types"));

  var _reactNative = _$$_REQUIRE(_dependencyMap[14], "./react-native");

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native-vector-icons/lib/icon-button.js";

  var styles = _reactNative.StyleSheet.create({
    container: {
      flexDirection: 'row',
      justifyContent: 'flex-start',
      alignItems: 'center',
      padding: 8
    },
    touchable: {
      overflow: 'hidden'
    },
    icon: {
      marginRight: 10
    },
    text: {
      fontWeight: '600',
      backgroundColor: 'transparent'
    }
  });

  var IOS7_BLUE = '#007AFF';
  var TEXT_PROP_NAMES = ['ellipsizeMode', 'numberOfLines', 'textBreakStrategy', 'selectable', 'suppressHighlighting', 'allowFontScaling', 'adjustsFontSizeToFit', 'minimumFontScale'];
  var TOUCHABLE_PROP_NAMES = ['accessible', 'accessibilityLabel', 'accessibilityHint', 'accessibilityComponentType', 'accessibilityRole', 'accessibilityStates', 'accessibilityTraits', 'onFocus', 'onBlur', 'disabled', 'onPress', 'onPressIn', 'onPressOut', 'onLayout', 'onLongPress', 'nativeID', 'testID', 'delayPressIn', 'delayPressOut', 'delayLongPress', 'activeOpacity', 'underlayColor', 'selectionColor', 'onShowUnderlay', 'onHideUnderlay', 'hasTVPreferredFocus', 'tvParallaxProperties'];

  function createIconButtonComponent(Icon) {
    var _class, _temp;

    return _temp = _class = function (_PureComponent) {
      (0, _inherits2.default)(IconButton, _PureComponent);

      function IconButton() {
        (0, _classCallCheck2.default)(this, IconButton);
        return (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(IconButton).apply(this, arguments));
      }

      (0, _createClass2.default)(IconButton, [{
        key: "render",
        value: function render() {
          var _this$props = this.props,
              style = _this$props.style,
              iconStyle = _this$props.iconStyle,
              children = _this$props.children,
              restProps = (0, _objectWithoutProperties2.default)(_this$props, ["style", "iconStyle", "children"]);
          var iconProps = (0, _pick.default)(restProps, TEXT_PROP_NAMES, 'style', 'name', 'size', 'color');
          var touchableProps = (0, _pick.default)(restProps, TOUCHABLE_PROP_NAMES);
          var props = (0, _omit.default)(restProps, Object.keys(iconProps), Object.keys(touchableProps), 'iconStyle', 'borderRadius', 'backgroundColor');
          iconProps.style = iconStyle ? [styles.icon, iconStyle] : styles.icon;
          var colorStyle = (0, _pick.default)(this.props, 'color');
          var blockStyle = (0, _pick.default)(this.props, 'backgroundColor', 'borderRadius');
          return _react.default.createElement(_reactNative.TouchableHighlight, (0, _extends2.default)({
            style: [styles.touchable, blockStyle]
          }, touchableProps, {
            __source: {
              fileName: _jsxFileName,
              lineNumber: 118
            }
          }), _react.default.createElement(_reactNative.View, (0, _extends2.default)({
            style: [styles.container, blockStyle, style]
          }, props, {
            __source: {
              fileName: _jsxFileName,
              lineNumber: 122
            }
          }), _react.default.createElement(Icon, (0, _extends2.default)({}, iconProps, {
            __source: {
              fileName: _jsxFileName,
              lineNumber: 123
            }
          })), (0, _isString.default)(children) ? _react.default.createElement(_reactNative.Text, {
            style: [styles.text, colorStyle],
            __source: {
              fileName: _jsxFileName,
              lineNumber: 125
            }
          }, children) : children));
        }
      }]);
      return IconButton;
    }(_react.PureComponent), _class.propTypes = {
      backgroundColor: _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.number]),
      borderRadius: _propTypes.default.number,
      color: _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.number]),
      size: _propTypes.default.number,
      iconStyle: _propTypes.default.any,
      style: _propTypes.default.any,
      children: _propTypes.default.node
    }, _class.defaultProps = {
      backgroundColor: IOS7_BLUE,
      borderRadius: 5,
      color: 'white',
      size: 20
    }, _temp;
  }
},615,[1,9,13,52,24,25,32,34,37,616,625,753,54,69,613],"node_modules/react-native-vector-icons/lib/icon-button.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var baseGetTag = _$$_REQUIRE(_dependencyMap[0], "./_baseGetTag"),
      isArray = _$$_REQUIRE(_dependencyMap[1], "./isArray"),
      isObjectLike = _$$_REQUIRE(_dependencyMap[2], "./isObjectLike");

  var stringTag = '[object String]';

  function isString(value) {
    return typeof value == 'string' || !isArray(value) && isObjectLike(value) && baseGetTag(value) == stringTag;
  }

  module.exports = isString;
},616,[617,623,624],"node_modules/lodash/isString.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var Symbol = _$$_REQUIRE(_dependencyMap[0], "./_Symbol"),
      getRawTag = _$$_REQUIRE(_dependencyMap[1], "./_getRawTag"),
      objectToString = _$$_REQUIRE(_dependencyMap[2], "./_objectToString");

  var nullTag = '[object Null]',
      undefinedTag = '[object Undefined]';
  var symToStringTag = Symbol ? typeof Symbol === "function" ? Symbol.toStringTag : "@@toStringTag" : undefined;

  function baseGetTag(value) {
    if (value == null) {
      return value === undefined ? undefinedTag : nullTag;
    }

    return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);
  }

  module.exports = baseGetTag;
},617,[618,621,622],"node_modules/lodash/_baseGetTag.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var root = _$$_REQUIRE(_dependencyMap[0], "./_root");

  var Symbol = root.Symbol;
  module.exports = Symbol;
},618,[619],"node_modules/lodash/_Symbol.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var freeGlobal = _$$_REQUIRE(_dependencyMap[0], "./_freeGlobal");

  var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
  var root = freeGlobal || freeSelf || Function('return this')();
  module.exports = root;
},619,[620],"node_modules/lodash/_root.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;
  module.exports = freeGlobal;
},620,[],"node_modules/lodash/_freeGlobal.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var Symbol = _$$_REQUIRE(_dependencyMap[0], "./_Symbol");

  var objectProto = Object.prototype;
  var hasOwnProperty = objectProto.hasOwnProperty;
  var nativeObjectToString = objectProto.toString;
  var symToStringTag = Symbol ? typeof Symbol === "function" ? Symbol.toStringTag : "@@toStringTag" : undefined;

  function getRawTag(value) {
    var isOwn = hasOwnProperty.call(value, symToStringTag),
        tag = value[symToStringTag];

    try {
      value[symToStringTag] = undefined;
      var unmasked = true;
    } catch (e) {}

    var result = nativeObjectToString.call(value);

    if (unmasked) {
      if (isOwn) {
        value[symToStringTag] = tag;
      } else {
        delete value[symToStringTag];
      }
    }

    return result;
  }

  module.exports = getRawTag;
},621,[618],"node_modules/lodash/_getRawTag.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var objectProto = Object.prototype;
  var nativeObjectToString = objectProto.toString;

  function objectToString(value) {
    return nativeObjectToString.call(value);
  }

  module.exports = objectToString;
},622,[],"node_modules/lodash/_objectToString.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var isArray = Array.isArray;
  module.exports = isArray;
},623,[],"node_modules/lodash/isArray.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  function isObjectLike(value) {
    return value != null && typeof value == 'object';
  }

  module.exports = isObjectLike;
},624,[],"node_modules/lodash/isObjectLike.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var arrayMap = _$$_REQUIRE(_dependencyMap[0], "./_arrayMap"),
      baseClone = _$$_REQUIRE(_dependencyMap[1], "./_baseClone"),
      baseUnset = _$$_REQUIRE(_dependencyMap[2], "./_baseUnset"),
      castPath = _$$_REQUIRE(_dependencyMap[3], "./_castPath"),
      copyObject = _$$_REQUIRE(_dependencyMap[4], "./_copyObject"),
      customOmitClone = _$$_REQUIRE(_dependencyMap[5], "./_customOmitClone"),
      flatRest = _$$_REQUIRE(_dependencyMap[6], "./_flatRest"),
      getAllKeysIn = _$$_REQUIRE(_dependencyMap[7], "./_getAllKeysIn");

  var CLONE_DEEP_FLAG = 1,
      CLONE_FLAT_FLAG = 2,
      CLONE_SYMBOLS_FLAG = 4;
  var omit = flatRest(function (object, paths) {
    var result = {};

    if (object == null) {
      return result;
    }

    var isDeep = false;
    paths = arrayMap(paths, function (path) {
      path = castPath(path, object);
      isDeep || (isDeep = path.length > 1);
      return path;
    });
    copyObject(object, getAllKeysIn(object), result);

    if (isDeep) {
      result = baseClone(result, CLONE_DEEP_FLAG | CLONE_FLAT_FLAG | CLONE_SYMBOLS_FLAG, customOmitClone);
    }

    var length = paths.length;

    while (length--) {
      baseUnset(result, paths[length]);
    }

    return result;
  });
  module.exports = omit;
},625,[626,627,726,727,671,740,742,706],"node_modules/lodash/omit.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  function arrayMap(array, iteratee) {
    var index = -1,
        length = array == null ? 0 : array.length,
        result = Array(length);

    while (++index < length) {
      result[index] = iteratee(array[index], index, array);
    }

    return result;
  }

  module.exports = arrayMap;
},626,[],"node_modules/lodash/_arrayMap.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var Stack = _$$_REQUIRE(_dependencyMap[0], "./_Stack"),
      arrayEach = _$$_REQUIRE(_dependencyMap[1], "./_arrayEach"),
      assignValue = _$$_REQUIRE(_dependencyMap[2], "./_assignValue"),
      baseAssign = _$$_REQUIRE(_dependencyMap[3], "./_baseAssign"),
      baseAssignIn = _$$_REQUIRE(_dependencyMap[4], "./_baseAssignIn"),
      cloneBuffer = _$$_REQUIRE(_dependencyMap[5], "./_cloneBuffer"),
      copyArray = _$$_REQUIRE(_dependencyMap[6], "./_copyArray"),
      copySymbols = _$$_REQUIRE(_dependencyMap[7], "./_copySymbols"),
      copySymbolsIn = _$$_REQUIRE(_dependencyMap[8], "./_copySymbolsIn"),
      getAllKeys = _$$_REQUIRE(_dependencyMap[9], "./_getAllKeys"),
      getAllKeysIn = _$$_REQUIRE(_dependencyMap[10], "./_getAllKeysIn"),
      getTag = _$$_REQUIRE(_dependencyMap[11], "./_getTag"),
      initCloneArray = _$$_REQUIRE(_dependencyMap[12], "./_initCloneArray"),
      initCloneByTag = _$$_REQUIRE(_dependencyMap[13], "./_initCloneByTag"),
      initCloneObject = _$$_REQUIRE(_dependencyMap[14], "./_initCloneObject"),
      isArray = _$$_REQUIRE(_dependencyMap[15], "./isArray"),
      isBuffer = _$$_REQUIRE(_dependencyMap[16], "./isBuffer"),
      isMap = _$$_REQUIRE(_dependencyMap[17], "./isMap"),
      isObject = _$$_REQUIRE(_dependencyMap[18], "./isObject"),
      isSet = _$$_REQUIRE(_dependencyMap[19], "./isSet"),
      keys = _$$_REQUIRE(_dependencyMap[20], "./keys");

  var CLONE_DEEP_FLAG = 1,
      CLONE_FLAT_FLAG = 2,
      CLONE_SYMBOLS_FLAG = 4;
  var argsTag = '[object Arguments]',
      arrayTag = '[object Array]',
      boolTag = '[object Boolean]',
      dateTag = '[object Date]',
      errorTag = '[object Error]',
      funcTag = '[object Function]',
      genTag = '[object GeneratorFunction]',
      mapTag = '[object Map]',
      numberTag = '[object Number]',
      objectTag = '[object Object]',
      regexpTag = '[object RegExp]',
      setTag = '[object Set]',
      stringTag = '[object String]',
      symbolTag = '[object Symbol]',
      weakMapTag = '[object WeakMap]';
  var arrayBufferTag = '[object ArrayBuffer]',
      dataViewTag = '[object DataView]',
      float32Tag = '[object Float32Array]',
      float64Tag = '[object Float64Array]',
      int8Tag = '[object Int8Array]',
      int16Tag = '[object Int16Array]',
      int32Tag = '[object Int32Array]',
      uint8Tag = '[object Uint8Array]',
      uint8ClampedTag = '[object Uint8ClampedArray]',
      uint16Tag = '[object Uint16Array]',
      uint32Tag = '[object Uint32Array]';
  var cloneableTags = {};
  cloneableTags[argsTag] = cloneableTags[arrayTag] = cloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] = cloneableTags[boolTag] = cloneableTags[dateTag] = cloneableTags[float32Tag] = cloneableTags[float64Tag] = cloneableTags[int8Tag] = cloneableTags[int16Tag] = cloneableTags[int32Tag] = cloneableTags[mapTag] = cloneableTags[numberTag] = cloneableTags[objectTag] = cloneableTags[regexpTag] = cloneableTags[setTag] = cloneableTags[stringTag] = cloneableTags[symbolTag] = cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] = cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;
  cloneableTags[errorTag] = cloneableTags[funcTag] = cloneableTags[weakMapTag] = false;

  function baseClone(value, bitmask, customizer, key, object, stack) {
    var result,
        isDeep = bitmask & CLONE_DEEP_FLAG,
        isFlat = bitmask & CLONE_FLAT_FLAG,
        isFull = bitmask & CLONE_SYMBOLS_FLAG;

    if (customizer) {
      result = object ? customizer(value, key, object, stack) : customizer(value);
    }

    if (result !== undefined) {
      return result;
    }

    if (!isObject(value)) {
      return value;
    }

    var isArr = isArray(value);

    if (isArr) {
      result = initCloneArray(value);

      if (!isDeep) {
        return copyArray(value, result);
      }
    } else {
      var tag = getTag(value),
          isFunc = tag == funcTag || tag == genTag;

      if (isBuffer(value)) {
        return cloneBuffer(value, isDeep);
      }

      if (tag == objectTag || tag == argsTag || isFunc && !object) {
        result = isFlat || isFunc ? {} : initCloneObject(value);

        if (!isDeep) {
          return isFlat ? copySymbolsIn(value, baseAssignIn(result, value)) : copySymbols(value, baseAssign(result, value));
        }
      } else {
        if (!cloneableTags[tag]) {
          return object ? value : {};
        }

        result = initCloneByTag(value, tag, isDeep);
      }
    }

    stack || (stack = new Stack());
    var stacked = stack.get(value);

    if (stacked) {
      return stacked;
    }

    stack.set(value, result);

    if (isSet(value)) {
      value.forEach(function (subValue) {
        result.add(baseClone(subValue, bitmask, customizer, subValue, value, stack));
      });
    } else if (isMap(value)) {
      value.forEach(function (subValue, key) {
        result.set(key, baseClone(subValue, bitmask, customizer, key, value, stack));
      });
    }

    var keysFunc = isFull ? isFlat ? getAllKeysIn : getAllKeys : isFlat ? keysIn : keys;
    var props = isArr ? undefined : keysFunc(value);
    arrayEach(props || value, function (subValue, key) {
      if (props) {
        key = subValue;
        subValue = value[key];
      }

      assignValue(result, key, baseClone(subValue, bitmask, customizer, key, value, stack));
    });
    return result;
  }

  module.exports = baseClone;
},627,[628,666,667,670,690,694,695,696,700,704,706,707,712,713,720,623,677,722,646,724,672],"node_modules/lodash/_baseClone.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var ListCache = _$$_REQUIRE(_dependencyMap[0], "./_ListCache"),
      stackClear = _$$_REQUIRE(_dependencyMap[1], "./_stackClear"),
      stackDelete = _$$_REQUIRE(_dependencyMap[2], "./_stackDelete"),
      stackGet = _$$_REQUIRE(_dependencyMap[3], "./_stackGet"),
      stackHas = _$$_REQUIRE(_dependencyMap[4], "./_stackHas"),
      stackSet = _$$_REQUIRE(_dependencyMap[5], "./_stackSet");

  function Stack(entries) {
    var data = this.__data__ = new ListCache(entries);
    this.size = data.size;
  }

  Stack.prototype.clear = stackClear;
  Stack.prototype['delete'] = stackDelete;
  Stack.prototype.get = stackGet;
  Stack.prototype.has = stackHas;
  Stack.prototype.set = stackSet;
  module.exports = Stack;
},628,[629,637,638,639,640,641],"node_modules/lodash/_Stack.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var listCacheClear = _$$_REQUIRE(_dependencyMap[0], "./_listCacheClear"),
      listCacheDelete = _$$_REQUIRE(_dependencyMap[1], "./_listCacheDelete"),
      listCacheGet = _$$_REQUIRE(_dependencyMap[2], "./_listCacheGet"),
      listCacheHas = _$$_REQUIRE(_dependencyMap[3], "./_listCacheHas"),
      listCacheSet = _$$_REQUIRE(_dependencyMap[4], "./_listCacheSet");

  function ListCache(entries) {
    var index = -1,
        length = entries == null ? 0 : entries.length;
    this.clear();

    while (++index < length) {
      var entry = entries[index];
      this.set(entry[0], entry[1]);
    }
  }

  ListCache.prototype.clear = listCacheClear;
  ListCache.prototype['delete'] = listCacheDelete;
  ListCache.prototype.get = listCacheGet;
  ListCache.prototype.has = listCacheHas;
  ListCache.prototype.set = listCacheSet;
  module.exports = ListCache;
},629,[630,631,634,635,636],"node_modules/lodash/_ListCache.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  function listCacheClear() {
    this.__data__ = [];
    this.size = 0;
  }

  module.exports = listCacheClear;
},630,[],"node_modules/lodash/_listCacheClear.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var assocIndexOf = _$$_REQUIRE(_dependencyMap[0], "./_assocIndexOf");

  var arrayProto = Array.prototype;
  var splice = arrayProto.splice;

  function listCacheDelete(key) {
    var data = this.__data__,
        index = assocIndexOf(data, key);

    if (index < 0) {
      return false;
    }

    var lastIndex = data.length - 1;

    if (index == lastIndex) {
      data.pop();
    } else {
      splice.call(data, index, 1);
    }

    --this.size;
    return true;
  }

  module.exports = listCacheDelete;
},631,[632],"node_modules/lodash/_listCacheDelete.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var eq = _$$_REQUIRE(_dependencyMap[0], "./eq");

  function assocIndexOf(array, key) {
    var length = array.length;

    while (length--) {
      if (eq(array[length][0], key)) {
        return length;
      }
    }

    return -1;
  }

  module.exports = assocIndexOf;
},632,[633],"node_modules/lodash/_assocIndexOf.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  function eq(value, other) {
    return value === other || value !== value && other !== other;
  }

  module.exports = eq;
},633,[],"node_modules/lodash/eq.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var assocIndexOf = _$$_REQUIRE(_dependencyMap[0], "./_assocIndexOf");

  function listCacheGet(key) {
    var data = this.__data__,
        index = assocIndexOf(data, key);
    return index < 0 ? undefined : data[index][1];
  }

  module.exports = listCacheGet;
},634,[632],"node_modules/lodash/_listCacheGet.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var assocIndexOf = _$$_REQUIRE(_dependencyMap[0], "./_assocIndexOf");

  function listCacheHas(key) {
    return assocIndexOf(this.__data__, key) > -1;
  }

  module.exports = listCacheHas;
},635,[632],"node_modules/lodash/_listCacheHas.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var assocIndexOf = _$$_REQUIRE(_dependencyMap[0], "./_assocIndexOf");

  function listCacheSet(key, value) {
    var data = this.__data__,
        index = assocIndexOf(data, key);

    if (index < 0) {
      ++this.size;
      data.push([key, value]);
    } else {
      data[index][1] = value;
    }

    return this;
  }

  module.exports = listCacheSet;
},636,[632],"node_modules/lodash/_listCacheSet.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var ListCache = _$$_REQUIRE(_dependencyMap[0], "./_ListCache");

  function stackClear() {
    this.__data__ = new ListCache();
    this.size = 0;
  }

  module.exports = stackClear;
},637,[629],"node_modules/lodash/_stackClear.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  function stackDelete(key) {
    var data = this.__data__,
        result = data['delete'](key);
    this.size = data.size;
    return result;
  }

  module.exports = stackDelete;
},638,[],"node_modules/lodash/_stackDelete.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  function stackGet(key) {
    return this.__data__.get(key);
  }

  module.exports = stackGet;
},639,[],"node_modules/lodash/_stackGet.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  function stackHas(key) {
    return this.__data__.has(key);
  }

  module.exports = stackHas;
},640,[],"node_modules/lodash/_stackHas.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var ListCache = _$$_REQUIRE(_dependencyMap[0], "./_ListCache"),
      Map = _$$_REQUIRE(_dependencyMap[1], "./_Map"),
      MapCache = _$$_REQUIRE(_dependencyMap[2], "./_MapCache");

  var LARGE_ARRAY_SIZE = 200;

  function stackSet(key, value) {
    var data = this.__data__;

    if (data instanceof ListCache) {
      var pairs = data.__data__;

      if (!Map || pairs.length < LARGE_ARRAY_SIZE - 1) {
        pairs.push([key, value]);
        this.size = ++data.size;
        return this;
      }

      data = this.__data__ = new MapCache(pairs);
    }

    data.set(key, value);
    this.size = data.size;
    return this;
  }

  module.exports = stackSet;
},641,[629,642,651],"node_modules/lodash/_stackSet.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var getNative = _$$_REQUIRE(_dependencyMap[0], "./_getNative"),
      root = _$$_REQUIRE(_dependencyMap[1], "./_root");

  var Map = getNative(root, 'Map');
  module.exports = Map;
},642,[643,619],"node_modules/lodash/_Map.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var baseIsNative = _$$_REQUIRE(_dependencyMap[0], "./_baseIsNative"),
      getValue = _$$_REQUIRE(_dependencyMap[1], "./_getValue");

  function getNative(object, key) {
    var value = getValue(object, key);
    return baseIsNative(value) ? value : undefined;
  }

  module.exports = getNative;
},643,[644,650],"node_modules/lodash/_getNative.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var isFunction = _$$_REQUIRE(_dependencyMap[0], "./isFunction"),
      isMasked = _$$_REQUIRE(_dependencyMap[1], "./_isMasked"),
      isObject = _$$_REQUIRE(_dependencyMap[2], "./isObject"),
      toSource = _$$_REQUIRE(_dependencyMap[3], "./_toSource");

  var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
  var reIsHostCtor = /^\[object .+?Constructor\]$/;
  var funcProto = Function.prototype,
      objectProto = Object.prototype;
  var funcToString = funcProto.toString;
  var hasOwnProperty = objectProto.hasOwnProperty;
  var reIsNative = RegExp('^' + funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&').replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$');

  function baseIsNative(value) {
    if (!isObject(value) || isMasked(value)) {
      return false;
    }

    var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
    return pattern.test(toSource(value));
  }

  module.exports = baseIsNative;
},644,[645,647,646,649],"node_modules/lodash/_baseIsNative.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var baseGetTag = _$$_REQUIRE(_dependencyMap[0], "./_baseGetTag"),
      isObject = _$$_REQUIRE(_dependencyMap[1], "./isObject");

  var asyncTag = '[object AsyncFunction]',
      funcTag = '[object Function]',
      genTag = '[object GeneratorFunction]',
      proxyTag = '[object Proxy]';

  function isFunction(value) {
    if (!isObject(value)) {
      return false;
    }

    var tag = baseGetTag(value);
    return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
  }

  module.exports = isFunction;
},645,[617,646],"node_modules/lodash/isFunction.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  function isObject(value) {
    var type = typeof value;
    return value != null && (type == 'object' || type == 'function');
  }

  module.exports = isObject;
},646,[],"node_modules/lodash/isObject.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var coreJsData = _$$_REQUIRE(_dependencyMap[0], "./_coreJsData");

  var maskSrcKey = function () {
    var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');
    return uid ? 'Symbol(src)_1.' + uid : '';
  }();

  function isMasked(func) {
    return !!maskSrcKey && maskSrcKey in func;
  }

  module.exports = isMasked;
},647,[648],"node_modules/lodash/_isMasked.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var root = _$$_REQUIRE(_dependencyMap[0], "./_root");

  var coreJsData = root['__core-js_shared__'];
  module.exports = coreJsData;
},648,[619],"node_modules/lodash/_coreJsData.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var funcProto = Function.prototype;
  var funcToString = funcProto.toString;

  function toSource(func) {
    if (func != null) {
      try {
        return funcToString.call(func);
      } catch (e) {}

      try {
        return func + '';
      } catch (e) {}
    }

    return '';
  }

  module.exports = toSource;
},649,[],"node_modules/lodash/_toSource.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  function getValue(object, key) {
    return object == null ? undefined : object[key];
  }

  module.exports = getValue;
},650,[],"node_modules/lodash/_getValue.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var mapCacheClear = _$$_REQUIRE(_dependencyMap[0], "./_mapCacheClear"),
      mapCacheDelete = _$$_REQUIRE(_dependencyMap[1], "./_mapCacheDelete"),
      mapCacheGet = _$$_REQUIRE(_dependencyMap[2], "./_mapCacheGet"),
      mapCacheHas = _$$_REQUIRE(_dependencyMap[3], "./_mapCacheHas"),
      mapCacheSet = _$$_REQUIRE(_dependencyMap[4], "./_mapCacheSet");

  function MapCache(entries) {
    var index = -1,
        length = entries == null ? 0 : entries.length;
    this.clear();

    while (++index < length) {
      var entry = entries[index];
      this.set(entry[0], entry[1]);
    }
  }

  MapCache.prototype.clear = mapCacheClear;
  MapCache.prototype['delete'] = mapCacheDelete;
  MapCache.prototype.get = mapCacheGet;
  MapCache.prototype.has = mapCacheHas;
  MapCache.prototype.set = mapCacheSet;
  module.exports = MapCache;
},651,[652,660,663,664,665],"node_modules/lodash/_MapCache.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var Hash = _$$_REQUIRE(_dependencyMap[0], "./_Hash"),
      ListCache = _$$_REQUIRE(_dependencyMap[1], "./_ListCache"),
      Map = _$$_REQUIRE(_dependencyMap[2], "./_Map");

  function mapCacheClear() {
    this.size = 0;
    this.__data__ = {
      'hash': new Hash(),
      'map': new (Map || ListCache)(),
      'string': new Hash()
    };
  }

  module.exports = mapCacheClear;
},652,[653,629,642],"node_modules/lodash/_mapCacheClear.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var hashClear = _$$_REQUIRE(_dependencyMap[0], "./_hashClear"),
      hashDelete = _$$_REQUIRE(_dependencyMap[1], "./_hashDelete"),
      hashGet = _$$_REQUIRE(_dependencyMap[2], "./_hashGet"),
      hashHas = _$$_REQUIRE(_dependencyMap[3], "./_hashHas"),
      hashSet = _$$_REQUIRE(_dependencyMap[4], "./_hashSet");

  function Hash(entries) {
    var index = -1,
        length = entries == null ? 0 : entries.length;
    this.clear();

    while (++index < length) {
      var entry = entries[index];
      this.set(entry[0], entry[1]);
    }
  }

  Hash.prototype.clear = hashClear;
  Hash.prototype['delete'] = hashDelete;
  Hash.prototype.get = hashGet;
  Hash.prototype.has = hashHas;
  Hash.prototype.set = hashSet;
  module.exports = Hash;
},653,[654,656,657,658,659],"node_modules/lodash/_Hash.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var nativeCreate = _$$_REQUIRE(_dependencyMap[0], "./_nativeCreate");

  function hashClear() {
    this.__data__ = nativeCreate ? nativeCreate(null) : {};
    this.size = 0;
  }

  module.exports = hashClear;
},654,[655],"node_modules/lodash/_hashClear.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var getNative = _$$_REQUIRE(_dependencyMap[0], "./_getNative");

  var nativeCreate = getNative(Object, 'create');
  module.exports = nativeCreate;
},655,[643],"node_modules/lodash/_nativeCreate.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  function hashDelete(key) {
    var result = this.has(key) && delete this.__data__[key];
    this.size -= result ? 1 : 0;
    return result;
  }

  module.exports = hashDelete;
},656,[],"node_modules/lodash/_hashDelete.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var nativeCreate = _$$_REQUIRE(_dependencyMap[0], "./_nativeCreate");

  var HASH_UNDEFINED = '__lodash_hash_undefined__';
  var objectProto = Object.prototype;
  var hasOwnProperty = objectProto.hasOwnProperty;

  function hashGet(key) {
    var data = this.__data__;

    if (nativeCreate) {
      var result = data[key];
      return result === HASH_UNDEFINED ? undefined : result;
    }

    return hasOwnProperty.call(data, key) ? data[key] : undefined;
  }

  module.exports = hashGet;
},657,[655],"node_modules/lodash/_hashGet.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var nativeCreate = _$$_REQUIRE(_dependencyMap[0], "./_nativeCreate");

  var objectProto = Object.prototype;
  var hasOwnProperty = objectProto.hasOwnProperty;

  function hashHas(key) {
    var data = this.__data__;
    return nativeCreate ? data[key] !== undefined : hasOwnProperty.call(data, key);
  }

  module.exports = hashHas;
},658,[655],"node_modules/lodash/_hashHas.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var nativeCreate = _$$_REQUIRE(_dependencyMap[0], "./_nativeCreate");

  var HASH_UNDEFINED = '__lodash_hash_undefined__';

  function hashSet(key, value) {
    var data = this.__data__;
    this.size += this.has(key) ? 0 : 1;
    data[key] = nativeCreate && value === undefined ? HASH_UNDEFINED : value;
    return this;
  }

  module.exports = hashSet;
},659,[655],"node_modules/lodash/_hashSet.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var getMapData = _$$_REQUIRE(_dependencyMap[0], "./_getMapData");

  function mapCacheDelete(key) {
    var result = getMapData(this, key)['delete'](key);
    this.size -= result ? 1 : 0;
    return result;
  }

  module.exports = mapCacheDelete;
},660,[661],"node_modules/lodash/_mapCacheDelete.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var isKeyable = _$$_REQUIRE(_dependencyMap[0], "./_isKeyable");

  function getMapData(map, key) {
    var data = map.__data__;
    return isKeyable(key) ? data[typeof key == 'string' ? 'string' : 'hash'] : data.map;
  }

  module.exports = getMapData;
},661,[662],"node_modules/lodash/_getMapData.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  function isKeyable(value) {
    var type = typeof value;
    return type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean' ? value !== '__proto__' : value === null;
  }

  module.exports = isKeyable;
},662,[],"node_modules/lodash/_isKeyable.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var getMapData = _$$_REQUIRE(_dependencyMap[0], "./_getMapData");

  function mapCacheGet(key) {
    return getMapData(this, key).get(key);
  }

  module.exports = mapCacheGet;
},663,[661],"node_modules/lodash/_mapCacheGet.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var getMapData = _$$_REQUIRE(_dependencyMap[0], "./_getMapData");

  function mapCacheHas(key) {
    return getMapData(this, key).has(key);
  }

  module.exports = mapCacheHas;
},664,[661],"node_modules/lodash/_mapCacheHas.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var getMapData = _$$_REQUIRE(_dependencyMap[0], "./_getMapData");

  function mapCacheSet(key, value) {
    var data = getMapData(this, key),
        size = data.size;
    data.set(key, value);
    this.size += data.size == size ? 0 : 1;
    return this;
  }

  module.exports = mapCacheSet;
},665,[661],"node_modules/lodash/_mapCacheSet.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  function arrayEach(array, iteratee) {
    var index = -1,
        length = array == null ? 0 : array.length;

    while (++index < length) {
      if (iteratee(array[index], index, array) === false) {
        break;
      }
    }

    return array;
  }

  module.exports = arrayEach;
},666,[],"node_modules/lodash/_arrayEach.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var baseAssignValue = _$$_REQUIRE(_dependencyMap[0], "./_baseAssignValue"),
      eq = _$$_REQUIRE(_dependencyMap[1], "./eq");

  var objectProto = Object.prototype;
  var hasOwnProperty = objectProto.hasOwnProperty;

  function assignValue(object, key, value) {
    var objValue = object[key];

    if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) || value === undefined && !(key in object)) {
      baseAssignValue(object, key, value);
    }
  }

  module.exports = assignValue;
},667,[668,633],"node_modules/lodash/_assignValue.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var defineProperty = _$$_REQUIRE(_dependencyMap[0], "./_defineProperty");

  function baseAssignValue(object, key, value) {
    if (key == '__proto__' && defineProperty) {
      defineProperty(object, key, {
        'configurable': true,
        'enumerable': true,
        'value': value,
        'writable': true
      });
    } else {
      object[key] = value;
    }
  }

  module.exports = baseAssignValue;
},668,[669],"node_modules/lodash/_baseAssignValue.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var getNative = _$$_REQUIRE(_dependencyMap[0], "./_getNative");

  var defineProperty = function () {
    try {
      var func = getNative(Object, 'defineProperty');
      func({}, '', {});
      return func;
    } catch (e) {}
  }();

  module.exports = defineProperty;
},669,[643],"node_modules/lodash/_defineProperty.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var copyObject = _$$_REQUIRE(_dependencyMap[0], "./_copyObject"),
      keys = _$$_REQUIRE(_dependencyMap[1], "./keys");

  function baseAssign(object, source) {
    return object && copyObject(source, keys(source), object);
  }

  module.exports = baseAssign;
},670,[671,672],"node_modules/lodash/_baseAssign.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var assignValue = _$$_REQUIRE(_dependencyMap[0], "./_assignValue"),
      baseAssignValue = _$$_REQUIRE(_dependencyMap[1], "./_baseAssignValue");

  function copyObject(source, props, object, customizer) {
    var isNew = !object;
    object || (object = {});
    var index = -1,
        length = props.length;

    while (++index < length) {
      var key = props[index];
      var newValue = customizer ? customizer(object[key], source[key], key, object, source) : undefined;

      if (newValue === undefined) {
        newValue = source[key];
      }

      if (isNew) {
        baseAssignValue(object, key, newValue);
      } else {
        assignValue(object, key, newValue);
      }
    }

    return object;
  }

  module.exports = copyObject;
},671,[667,668],"node_modules/lodash/_copyObject.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var arrayLikeKeys = _$$_REQUIRE(_dependencyMap[0], "./_arrayLikeKeys"),
      baseKeys = _$$_REQUIRE(_dependencyMap[1], "./_baseKeys"),
      isArrayLike = _$$_REQUIRE(_dependencyMap[2], "./isArrayLike");

  function keys(object) {
    return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
  }

  module.exports = keys;
},672,[673,685,689],"node_modules/lodash/keys.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var baseTimes = _$$_REQUIRE(_dependencyMap[0], "./_baseTimes"),
      isArguments = _$$_REQUIRE(_dependencyMap[1], "./isArguments"),
      isArray = _$$_REQUIRE(_dependencyMap[2], "./isArray"),
      isBuffer = _$$_REQUIRE(_dependencyMap[3], "./isBuffer"),
      isIndex = _$$_REQUIRE(_dependencyMap[4], "./_isIndex"),
      isTypedArray = _$$_REQUIRE(_dependencyMap[5], "./isTypedArray");

  var objectProto = Object.prototype;
  var hasOwnProperty = objectProto.hasOwnProperty;

  function arrayLikeKeys(value, inherited) {
    var isArr = isArray(value),
        isArg = !isArr && isArguments(value),
        isBuff = !isArr && !isArg && isBuffer(value),
        isType = !isArr && !isArg && !isBuff && isTypedArray(value),
        skipIndexes = isArr || isArg || isBuff || isType,
        result = skipIndexes ? baseTimes(value.length, String) : [],
        length = result.length;

    for (var key in value) {
      if ((inherited || hasOwnProperty.call(value, key)) && !(skipIndexes && (key == 'length' || isBuff && (key == 'offset' || key == 'parent') || isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset') || isIndex(key, length)))) {
        result.push(key);
      }
    }

    return result;
  }

  module.exports = arrayLikeKeys;
},673,[674,675,623,677,679,680],"node_modules/lodash/_arrayLikeKeys.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  function baseTimes(n, iteratee) {
    var index = -1,
        result = Array(n);

    while (++index < n) {
      result[index] = iteratee(index);
    }

    return result;
  }

  module.exports = baseTimes;
},674,[],"node_modules/lodash/_baseTimes.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var baseIsArguments = _$$_REQUIRE(_dependencyMap[0], "./_baseIsArguments"),
      isObjectLike = _$$_REQUIRE(_dependencyMap[1], "./isObjectLike");

  var objectProto = Object.prototype;
  var hasOwnProperty = objectProto.hasOwnProperty;
  var propertyIsEnumerable = objectProto.propertyIsEnumerable;
  var isArguments = baseIsArguments(function () {
    return arguments;
  }()) ? baseIsArguments : function (value) {
    return isObjectLike(value) && hasOwnProperty.call(value, 'callee') && !propertyIsEnumerable.call(value, 'callee');
  };
  module.exports = isArguments;
},675,[676,624],"node_modules/lodash/isArguments.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var baseGetTag = _$$_REQUIRE(_dependencyMap[0], "./_baseGetTag"),
      isObjectLike = _$$_REQUIRE(_dependencyMap[1], "./isObjectLike");

  var argsTag = '[object Arguments]';

  function baseIsArguments(value) {
    return isObjectLike(value) && baseGetTag(value) == argsTag;
  }

  module.exports = baseIsArguments;
},676,[617,624],"node_modules/lodash/_baseIsArguments.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var root = _$$_REQUIRE(_dependencyMap[0], "./_root"),
      stubFalse = _$$_REQUIRE(_dependencyMap[1], "./stubFalse");

  var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;
  var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;
  var moduleExports = freeModule && freeModule.exports === freeExports;
  var Buffer = moduleExports ? root.Buffer : undefined;
  var nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined;
  var isBuffer = nativeIsBuffer || stubFalse;
  module.exports = isBuffer;
},677,[619,678],"node_modules/lodash/isBuffer.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  function stubFalse() {
    return false;
  }

  module.exports = stubFalse;
},678,[],"node_modules/lodash/stubFalse.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var MAX_SAFE_INTEGER = 9007199254740991;
  var reIsUint = /^(?:0|[1-9]\d*)$/;

  function isIndex(value, length) {
    var type = typeof value;
    length = length == null ? MAX_SAFE_INTEGER : length;
    return !!length && (type == 'number' || type != 'symbol' && reIsUint.test(value)) && value > -1 && value % 1 == 0 && value < length;
  }

  module.exports = isIndex;
},679,[],"node_modules/lodash/_isIndex.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var baseIsTypedArray = _$$_REQUIRE(_dependencyMap[0], "./_baseIsTypedArray"),
      baseUnary = _$$_REQUIRE(_dependencyMap[1], "./_baseUnary"),
      nodeUtil = _$$_REQUIRE(_dependencyMap[2], "./_nodeUtil");

  var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
  var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
  module.exports = isTypedArray;
},680,[681,683,684],"node_modules/lodash/isTypedArray.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var baseGetTag = _$$_REQUIRE(_dependencyMap[0], "./_baseGetTag"),
      isLength = _$$_REQUIRE(_dependencyMap[1], "./isLength"),
      isObjectLike = _$$_REQUIRE(_dependencyMap[2], "./isObjectLike");

  var argsTag = '[object Arguments]',
      arrayTag = '[object Array]',
      boolTag = '[object Boolean]',
      dateTag = '[object Date]',
      errorTag = '[object Error]',
      funcTag = '[object Function]',
      mapTag = '[object Map]',
      numberTag = '[object Number]',
      objectTag = '[object Object]',
      regexpTag = '[object RegExp]',
      setTag = '[object Set]',
      stringTag = '[object String]',
      weakMapTag = '[object WeakMap]';
  var arrayBufferTag = '[object ArrayBuffer]',
      dataViewTag = '[object DataView]',
      float32Tag = '[object Float32Array]',
      float64Tag = '[object Float64Array]',
      int8Tag = '[object Int8Array]',
      int16Tag = '[object Int16Array]',
      int32Tag = '[object Int32Array]',
      uint8Tag = '[object Uint8Array]',
      uint8ClampedTag = '[object Uint8ClampedArray]',
      uint16Tag = '[object Uint16Array]',
      uint32Tag = '[object Uint32Array]';
  var typedArrayTags = {};
  typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = typedArrayTags[uint32Tag] = true;
  typedArrayTags[argsTag] = typedArrayTags[arrayTag] = typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] = typedArrayTags[dataViewTag] = typedArrayTags[dateTag] = typedArrayTags[errorTag] = typedArrayTags[funcTag] = typedArrayTags[mapTag] = typedArrayTags[numberTag] = typedArrayTags[objectTag] = typedArrayTags[regexpTag] = typedArrayTags[setTag] = typedArrayTags[stringTag] = typedArrayTags[weakMapTag] = false;

  function baseIsTypedArray(value) {
    return isObjectLike(value) && isLength(value.length) && !!typedArrayTags[baseGetTag(value)];
  }

  module.exports = baseIsTypedArray;
},681,[617,682,624],"node_modules/lodash/_baseIsTypedArray.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var MAX_SAFE_INTEGER = 9007199254740991;

  function isLength(value) {
    return typeof value == 'number' && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
  }

  module.exports = isLength;
},682,[],"node_modules/lodash/isLength.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  function baseUnary(func) {
    return function (value) {
      return func(value);
    };
  }

  module.exports = baseUnary;
},683,[],"node_modules/lodash/_baseUnary.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var freeGlobal = _$$_REQUIRE(_dependencyMap[0], "./_freeGlobal");

  var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;
  var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;
  var moduleExports = freeModule && freeModule.exports === freeExports;
  var freeProcess = moduleExports && freeGlobal.process;

  var nodeUtil = function () {
    try {
      var types = freeModule && freeModule.require && freeModule.require('util').types;

      if (types) {
        return types;
      }

      return freeProcess && freeProcess.binding && freeProcess.binding('util');
    } catch (e) {}
  }();

  module.exports = nodeUtil;
},684,[620],"node_modules/lodash/_nodeUtil.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var isPrototype = _$$_REQUIRE(_dependencyMap[0], "./_isPrototype"),
      nativeKeys = _$$_REQUIRE(_dependencyMap[1], "./_nativeKeys");

  var objectProto = Object.prototype;
  var hasOwnProperty = objectProto.hasOwnProperty;

  function baseKeys(object) {
    if (!isPrototype(object)) {
      return nativeKeys(object);
    }

    var result = [];

    for (var key in Object(object)) {
      if (hasOwnProperty.call(object, key) && key != 'constructor') {
        result.push(key);
      }
    }

    return result;
  }

  module.exports = baseKeys;
},685,[686,687],"node_modules/lodash/_baseKeys.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var objectProto = Object.prototype;

  function isPrototype(value) {
    var Ctor = value && value.constructor,
        proto = typeof Ctor == 'function' && Ctor.prototype || objectProto;
    return value === proto;
  }

  module.exports = isPrototype;
},686,[],"node_modules/lodash/_isPrototype.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var overArg = _$$_REQUIRE(_dependencyMap[0], "./_overArg");

  var nativeKeys = overArg(Object.keys, Object);
  module.exports = nativeKeys;
},687,[688],"node_modules/lodash/_nativeKeys.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  function overArg(func, transform) {
    return function (arg) {
      return func(transform(arg));
    };
  }

  module.exports = overArg;
},688,[],"node_modules/lodash/_overArg.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var isFunction = _$$_REQUIRE(_dependencyMap[0], "./isFunction"),
      isLength = _$$_REQUIRE(_dependencyMap[1], "./isLength");

  function isArrayLike(value) {
    return value != null && isLength(value.length) && !isFunction(value);
  }

  module.exports = isArrayLike;
},689,[645,682],"node_modules/lodash/isArrayLike.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var copyObject = _$$_REQUIRE(_dependencyMap[0], "./_copyObject"),
      keysIn = _$$_REQUIRE(_dependencyMap[1], "./keysIn");

  function baseAssignIn(object, source) {
    return object && copyObject(source, keysIn(source), object);
  }

  module.exports = baseAssignIn;
},690,[671,691],"node_modules/lodash/_baseAssignIn.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var arrayLikeKeys = _$$_REQUIRE(_dependencyMap[0], "./_arrayLikeKeys"),
      baseKeysIn = _$$_REQUIRE(_dependencyMap[1], "./_baseKeysIn"),
      isArrayLike = _$$_REQUIRE(_dependencyMap[2], "./isArrayLike");

  function keysIn(object) {
    return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);
  }

  module.exports = keysIn;
},691,[673,692,689],"node_modules/lodash/keysIn.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var isObject = _$$_REQUIRE(_dependencyMap[0], "./isObject"),
      isPrototype = _$$_REQUIRE(_dependencyMap[1], "./_isPrototype"),
      nativeKeysIn = _$$_REQUIRE(_dependencyMap[2], "./_nativeKeysIn");

  var objectProto = Object.prototype;
  var hasOwnProperty = objectProto.hasOwnProperty;

  function baseKeysIn(object) {
    if (!isObject(object)) {
      return nativeKeysIn(object);
    }

    var isProto = isPrototype(object),
        result = [];

    for (var key in object) {
      if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {
        result.push(key);
      }
    }

    return result;
  }

  module.exports = baseKeysIn;
},692,[646,686,693],"node_modules/lodash/_baseKeysIn.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  function nativeKeysIn(object) {
    var result = [];

    if (object != null) {
      for (var key in Object(object)) {
        result.push(key);
      }
    }

    return result;
  }

  module.exports = nativeKeysIn;
},693,[],"node_modules/lodash/_nativeKeysIn.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var root = _$$_REQUIRE(_dependencyMap[0], "./_root");

  var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;
  var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;
  var moduleExports = freeModule && freeModule.exports === freeExports;
  var Buffer = moduleExports ? root.Buffer : undefined,
      allocUnsafe = Buffer ? Buffer.allocUnsafe : undefined;

  function cloneBuffer(buffer, isDeep) {
    if (isDeep) {
      return buffer.slice();
    }

    var length = buffer.length,
        result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);
    buffer.copy(result);
    return result;
  }

  module.exports = cloneBuffer;
},694,[619],"node_modules/lodash/_cloneBuffer.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  function copyArray(source, array) {
    var index = -1,
        length = source.length;
    array || (array = Array(length));

    while (++index < length) {
      array[index] = source[index];
    }

    return array;
  }

  module.exports = copyArray;
},695,[],"node_modules/lodash/_copyArray.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var copyObject = _$$_REQUIRE(_dependencyMap[0], "./_copyObject"),
      getSymbols = _$$_REQUIRE(_dependencyMap[1], "./_getSymbols");

  function copySymbols(source, object) {
    return copyObject(source, getSymbols(source), object);
  }

  module.exports = copySymbols;
},696,[671,697],"node_modules/lodash/_copySymbols.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var arrayFilter = _$$_REQUIRE(_dependencyMap[0], "./_arrayFilter"),
      stubArray = _$$_REQUIRE(_dependencyMap[1], "./stubArray");

  var objectProto = Object.prototype;
  var propertyIsEnumerable = objectProto.propertyIsEnumerable;
  var nativeGetSymbols = Object.getOwnPropertySymbols;
  var getSymbols = !nativeGetSymbols ? stubArray : function (object) {
    if (object == null) {
      return [];
    }

    object = Object(object);
    return arrayFilter(nativeGetSymbols(object), function (symbol) {
      return propertyIsEnumerable.call(object, symbol);
    });
  };
  module.exports = getSymbols;
},697,[698,699],"node_modules/lodash/_getSymbols.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  function arrayFilter(array, predicate) {
    var index = -1,
        length = array == null ? 0 : array.length,
        resIndex = 0,
        result = [];

    while (++index < length) {
      var value = array[index];

      if (predicate(value, index, array)) {
        result[resIndex++] = value;
      }
    }

    return result;
  }

  module.exports = arrayFilter;
},698,[],"node_modules/lodash/_arrayFilter.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  function stubArray() {
    return [];
  }

  module.exports = stubArray;
},699,[],"node_modules/lodash/stubArray.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var copyObject = _$$_REQUIRE(_dependencyMap[0], "./_copyObject"),
      getSymbolsIn = _$$_REQUIRE(_dependencyMap[1], "./_getSymbolsIn");

  function copySymbolsIn(source, object) {
    return copyObject(source, getSymbolsIn(source), object);
  }

  module.exports = copySymbolsIn;
},700,[671,701],"node_modules/lodash/_copySymbolsIn.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var arrayPush = _$$_REQUIRE(_dependencyMap[0], "./_arrayPush"),
      getPrototype = _$$_REQUIRE(_dependencyMap[1], "./_getPrototype"),
      getSymbols = _$$_REQUIRE(_dependencyMap[2], "./_getSymbols"),
      stubArray = _$$_REQUIRE(_dependencyMap[3], "./stubArray");

  var nativeGetSymbols = Object.getOwnPropertySymbols;
  var getSymbolsIn = !nativeGetSymbols ? stubArray : function (object) {
    var result = [];

    while (object) {
      arrayPush(result, getSymbols(object));
      object = getPrototype(object);
    }

    return result;
  };
  module.exports = getSymbolsIn;
},701,[702,703,697,699],"node_modules/lodash/_getSymbolsIn.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  function arrayPush(array, values) {
    var index = -1,
        length = values.length,
        offset = array.length;

    while (++index < length) {
      array[offset + index] = values[index];
    }

    return array;
  }

  module.exports = arrayPush;
},702,[],"node_modules/lodash/_arrayPush.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var overArg = _$$_REQUIRE(_dependencyMap[0], "./_overArg");

  var getPrototype = overArg(Object.getPrototypeOf, Object);
  module.exports = getPrototype;
},703,[688],"node_modules/lodash/_getPrototype.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var baseGetAllKeys = _$$_REQUIRE(_dependencyMap[0], "./_baseGetAllKeys"),
      getSymbols = _$$_REQUIRE(_dependencyMap[1], "./_getSymbols"),
      keys = _$$_REQUIRE(_dependencyMap[2], "./keys");

  function getAllKeys(object) {
    return baseGetAllKeys(object, keys, getSymbols);
  }

  module.exports = getAllKeys;
},704,[705,697,672],"node_modules/lodash/_getAllKeys.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var arrayPush = _$$_REQUIRE(_dependencyMap[0], "./_arrayPush"),
      isArray = _$$_REQUIRE(_dependencyMap[1], "./isArray");

  function baseGetAllKeys(object, keysFunc, symbolsFunc) {
    var result = keysFunc(object);
    return isArray(object) ? result : arrayPush(result, symbolsFunc(object));
  }

  module.exports = baseGetAllKeys;
},705,[702,623],"node_modules/lodash/_baseGetAllKeys.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var baseGetAllKeys = _$$_REQUIRE(_dependencyMap[0], "./_baseGetAllKeys"),
      getSymbolsIn = _$$_REQUIRE(_dependencyMap[1], "./_getSymbolsIn"),
      keysIn = _$$_REQUIRE(_dependencyMap[2], "./keysIn");

  function getAllKeysIn(object) {
    return baseGetAllKeys(object, keysIn, getSymbolsIn);
  }

  module.exports = getAllKeysIn;
},706,[705,701,691],"node_modules/lodash/_getAllKeysIn.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var DataView = _$$_REQUIRE(_dependencyMap[0], "./_DataView"),
      Map = _$$_REQUIRE(_dependencyMap[1], "./_Map"),
      Promise = _$$_REQUIRE(_dependencyMap[2], "./_Promise"),
      Set = _$$_REQUIRE(_dependencyMap[3], "./_Set"),
      WeakMap = _$$_REQUIRE(_dependencyMap[4], "./_WeakMap"),
      baseGetTag = _$$_REQUIRE(_dependencyMap[5], "./_baseGetTag"),
      toSource = _$$_REQUIRE(_dependencyMap[6], "./_toSource");

  var mapTag = '[object Map]',
      objectTag = '[object Object]',
      promiseTag = '[object Promise]',
      setTag = '[object Set]',
      weakMapTag = '[object WeakMap]';
  var dataViewTag = '[object DataView]';
  var dataViewCtorString = toSource(DataView),
      mapCtorString = toSource(Map),
      promiseCtorString = toSource(Promise),
      setCtorString = toSource(Set),
      weakMapCtorString = toSource(WeakMap);
  var getTag = baseGetTag;

  if (DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag || Map && getTag(new Map()) != mapTag || Promise && getTag(Promise.resolve()) != promiseTag || Set && getTag(new Set()) != setTag || WeakMap && getTag(new WeakMap()) != weakMapTag) {
    getTag = function getTag(value) {
      var result = baseGetTag(value),
          Ctor = result == objectTag ? value.constructor : undefined,
          ctorString = Ctor ? toSource(Ctor) : '';

      if (ctorString) {
        switch (ctorString) {
          case dataViewCtorString:
            return dataViewTag;

          case mapCtorString:
            return mapTag;

          case promiseCtorString:
            return promiseTag;

          case setCtorString:
            return setTag;

          case weakMapCtorString:
            return weakMapTag;
        }
      }

      return result;
    };
  }

  module.exports = getTag;
},707,[708,642,709,710,711,617,649],"node_modules/lodash/_getTag.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var getNative = _$$_REQUIRE(_dependencyMap[0], "./_getNative"),
      root = _$$_REQUIRE(_dependencyMap[1], "./_root");

  var DataView = getNative(root, 'DataView');
  module.exports = DataView;
},708,[643,619],"node_modules/lodash/_DataView.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var getNative = _$$_REQUIRE(_dependencyMap[0], "./_getNative"),
      root = _$$_REQUIRE(_dependencyMap[1], "./_root");

  var Promise = getNative(root, 'Promise');
  module.exports = Promise;
},709,[643,619],"node_modules/lodash/_Promise.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var getNative = _$$_REQUIRE(_dependencyMap[0], "./_getNative"),
      root = _$$_REQUIRE(_dependencyMap[1], "./_root");

  var Set = getNative(root, 'Set');
  module.exports = Set;
},710,[643,619],"node_modules/lodash/_Set.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var getNative = _$$_REQUIRE(_dependencyMap[0], "./_getNative"),
      root = _$$_REQUIRE(_dependencyMap[1], "./_root");

  var WeakMap = getNative(root, 'WeakMap');
  module.exports = WeakMap;
},711,[643,619],"node_modules/lodash/_WeakMap.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var objectProto = Object.prototype;
  var hasOwnProperty = objectProto.hasOwnProperty;

  function initCloneArray(array) {
    var length = array.length,
        result = new array.constructor(length);

    if (length && typeof array[0] == 'string' && hasOwnProperty.call(array, 'index')) {
      result.index = array.index;
      result.input = array.input;
    }

    return result;
  }

  module.exports = initCloneArray;
},712,[],"node_modules/lodash/_initCloneArray.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var cloneArrayBuffer = _$$_REQUIRE(_dependencyMap[0], "./_cloneArrayBuffer"),
      cloneDataView = _$$_REQUIRE(_dependencyMap[1], "./_cloneDataView"),
      cloneRegExp = _$$_REQUIRE(_dependencyMap[2], "./_cloneRegExp"),
      cloneSymbol = _$$_REQUIRE(_dependencyMap[3], "./_cloneSymbol"),
      cloneTypedArray = _$$_REQUIRE(_dependencyMap[4], "./_cloneTypedArray");

  var boolTag = '[object Boolean]',
      dateTag = '[object Date]',
      mapTag = '[object Map]',
      numberTag = '[object Number]',
      regexpTag = '[object RegExp]',
      setTag = '[object Set]',
      stringTag = '[object String]',
      symbolTag = '[object Symbol]';
  var arrayBufferTag = '[object ArrayBuffer]',
      dataViewTag = '[object DataView]',
      float32Tag = '[object Float32Array]',
      float64Tag = '[object Float64Array]',
      int8Tag = '[object Int8Array]',
      int16Tag = '[object Int16Array]',
      int32Tag = '[object Int32Array]',
      uint8Tag = '[object Uint8Array]',
      uint8ClampedTag = '[object Uint8ClampedArray]',
      uint16Tag = '[object Uint16Array]',
      uint32Tag = '[object Uint32Array]';

  function initCloneByTag(object, tag, isDeep) {
    var Ctor = object.constructor;

    switch (tag) {
      case arrayBufferTag:
        return cloneArrayBuffer(object);

      case boolTag:
      case dateTag:
        return new Ctor(+object);

      case dataViewTag:
        return cloneDataView(object, isDeep);

      case float32Tag:
      case float64Tag:
      case int8Tag:
      case int16Tag:
      case int32Tag:
      case uint8Tag:
      case uint8ClampedTag:
      case uint16Tag:
      case uint32Tag:
        return cloneTypedArray(object, isDeep);

      case mapTag:
        return new Ctor();

      case numberTag:
      case stringTag:
        return new Ctor(object);

      case regexpTag:
        return cloneRegExp(object);

      case setTag:
        return new Ctor();

      case symbolTag:
        return cloneSymbol(object);
    }
  }

  module.exports = initCloneByTag;
},713,[714,716,717,718,719],"node_modules/lodash/_initCloneByTag.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var Uint8Array = _$$_REQUIRE(_dependencyMap[0], "./_Uint8Array");

  function cloneArrayBuffer(arrayBuffer) {
    var result = new arrayBuffer.constructor(arrayBuffer.byteLength);
    new Uint8Array(result).set(new Uint8Array(arrayBuffer));
    return result;
  }

  module.exports = cloneArrayBuffer;
},714,[715],"node_modules/lodash/_cloneArrayBuffer.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var root = _$$_REQUIRE(_dependencyMap[0], "./_root");

  var Uint8Array = root.Uint8Array;
  module.exports = Uint8Array;
},715,[619],"node_modules/lodash/_Uint8Array.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var cloneArrayBuffer = _$$_REQUIRE(_dependencyMap[0], "./_cloneArrayBuffer");

  function cloneDataView(dataView, isDeep) {
    var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer;
    return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);
  }

  module.exports = cloneDataView;
},716,[714],"node_modules/lodash/_cloneDataView.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var reFlags = /\w*$/;

  function cloneRegExp(regexp) {
    var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));
    result.lastIndex = regexp.lastIndex;
    return result;
  }

  module.exports = cloneRegExp;
},717,[],"node_modules/lodash/_cloneRegExp.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var Symbol = _$$_REQUIRE(_dependencyMap[0], "./_Symbol");

  var symbolProto = Symbol ? typeof Symbol === "function" ? Symbol.prototype : "@@prototype" : undefined,
      symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;

  function cloneSymbol(symbol) {
    return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {};
  }

  module.exports = cloneSymbol;
},718,[618],"node_modules/lodash/_cloneSymbol.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var cloneArrayBuffer = _$$_REQUIRE(_dependencyMap[0], "./_cloneArrayBuffer");

  function cloneTypedArray(typedArray, isDeep) {
    var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;
    return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
  }

  module.exports = cloneTypedArray;
},719,[714],"node_modules/lodash/_cloneTypedArray.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var baseCreate = _$$_REQUIRE(_dependencyMap[0], "./_baseCreate"),
      getPrototype = _$$_REQUIRE(_dependencyMap[1], "./_getPrototype"),
      isPrototype = _$$_REQUIRE(_dependencyMap[2], "./_isPrototype");

  function initCloneObject(object) {
    return typeof object.constructor == 'function' && !isPrototype(object) ? baseCreate(getPrototype(object)) : {};
  }

  module.exports = initCloneObject;
},720,[721,703,686],"node_modules/lodash/_initCloneObject.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var isObject = _$$_REQUIRE(_dependencyMap[0], "./isObject");

  var objectCreate = Object.create;

  var baseCreate = function () {
    function object() {}

    return function (proto) {
      if (!isObject(proto)) {
        return {};
      }

      if (objectCreate) {
        return objectCreate(proto);
      }

      object.prototype = proto;
      var result = new object();
      object.prototype = undefined;
      return result;
    };
  }();

  module.exports = baseCreate;
},721,[646],"node_modules/lodash/_baseCreate.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var baseIsMap = _$$_REQUIRE(_dependencyMap[0], "./_baseIsMap"),
      baseUnary = _$$_REQUIRE(_dependencyMap[1], "./_baseUnary"),
      nodeUtil = _$$_REQUIRE(_dependencyMap[2], "./_nodeUtil");

  var nodeIsMap = nodeUtil && nodeUtil.isMap;
  var isMap = nodeIsMap ? baseUnary(nodeIsMap) : baseIsMap;
  module.exports = isMap;
},722,[723,683,684],"node_modules/lodash/isMap.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var getTag = _$$_REQUIRE(_dependencyMap[0], "./_getTag"),
      isObjectLike = _$$_REQUIRE(_dependencyMap[1], "./isObjectLike");

  var mapTag = '[object Map]';

  function baseIsMap(value) {
    return isObjectLike(value) && getTag(value) == mapTag;
  }

  module.exports = baseIsMap;
},723,[707,624],"node_modules/lodash/_baseIsMap.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var baseIsSet = _$$_REQUIRE(_dependencyMap[0], "./_baseIsSet"),
      baseUnary = _$$_REQUIRE(_dependencyMap[1], "./_baseUnary"),
      nodeUtil = _$$_REQUIRE(_dependencyMap[2], "./_nodeUtil");

  var nodeIsSet = nodeUtil && nodeUtil.isSet;
  var isSet = nodeIsSet ? baseUnary(nodeIsSet) : baseIsSet;
  module.exports = isSet;
},724,[725,683,684],"node_modules/lodash/isSet.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var getTag = _$$_REQUIRE(_dependencyMap[0], "./_getTag"),
      isObjectLike = _$$_REQUIRE(_dependencyMap[1], "./isObjectLike");

  var setTag = '[object Set]';

  function baseIsSet(value) {
    return isObjectLike(value) && getTag(value) == setTag;
  }

  module.exports = baseIsSet;
},725,[707,624],"node_modules/lodash/_baseIsSet.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var castPath = _$$_REQUIRE(_dependencyMap[0], "./_castPath"),
      last = _$$_REQUIRE(_dependencyMap[1], "./last"),
      parent = _$$_REQUIRE(_dependencyMap[2], "./_parent"),
      toKey = _$$_REQUIRE(_dependencyMap[3], "./_toKey");

  function baseUnset(object, path) {
    path = castPath(path, object);
    object = parent(object, path);
    return object == null || delete object[toKey(last(path))];
  }

  module.exports = baseUnset;
},726,[727,735,736,738],"node_modules/lodash/_baseUnset.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var isArray = _$$_REQUIRE(_dependencyMap[0], "./isArray"),
      isKey = _$$_REQUIRE(_dependencyMap[1], "./_isKey"),
      stringToPath = _$$_REQUIRE(_dependencyMap[2], "./_stringToPath"),
      toString = _$$_REQUIRE(_dependencyMap[3], "./toString");

  function castPath(value, object) {
    if (isArray(value)) {
      return value;
    }

    return isKey(value, object) ? [value] : stringToPath(toString(value));
  }

  module.exports = castPath;
},727,[623,728,730,733],"node_modules/lodash/_castPath.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var isArray = _$$_REQUIRE(_dependencyMap[0], "./isArray"),
      isSymbol = _$$_REQUIRE(_dependencyMap[1], "./isSymbol");

  var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,
      reIsPlainProp = /^\w*$/;

  function isKey(value, object) {
    if (isArray(value)) {
      return false;
    }

    var type = typeof value;

    if (type == 'number' || type == 'symbol' || type == 'boolean' || value == null || isSymbol(value)) {
      return true;
    }

    return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || object != null && value in Object(object);
  }

  module.exports = isKey;
},728,[623,729],"node_modules/lodash/_isKey.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var baseGetTag = _$$_REQUIRE(_dependencyMap[0], "./_baseGetTag"),
      isObjectLike = _$$_REQUIRE(_dependencyMap[1], "./isObjectLike");

  var symbolTag = '[object Symbol]';

  function isSymbol(value) {
    return typeof value == 'symbol' || isObjectLike(value) && baseGetTag(value) == symbolTag;
  }

  module.exports = isSymbol;
},729,[617,624],"node_modules/lodash/isSymbol.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var memoizeCapped = _$$_REQUIRE(_dependencyMap[0], "./_memoizeCapped");

  var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
  var reEscapeChar = /\\(\\)?/g;
  var stringToPath = memoizeCapped(function (string) {
    var result = [];

    if (string.charCodeAt(0) === 46) {
        result.push('');
      }

    string.replace(rePropName, function (match, number, quote, subString) {
      result.push(quote ? subString.replace(reEscapeChar, '$1') : number || match);
    });
    return result;
  });
  module.exports = stringToPath;
},730,[731],"node_modules/lodash/_stringToPath.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var memoize = _$$_REQUIRE(_dependencyMap[0], "./memoize");

  var MAX_MEMOIZE_SIZE = 500;

  function memoizeCapped(func) {
    var result = memoize(func, function (key) {
      if (cache.size === MAX_MEMOIZE_SIZE) {
        cache.clear();
      }

      return key;
    });
    var cache = result.cache;
    return result;
  }

  module.exports = memoizeCapped;
},731,[732],"node_modules/lodash/_memoizeCapped.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var MapCache = _$$_REQUIRE(_dependencyMap[0], "./_MapCache");

  var FUNC_ERROR_TEXT = 'Expected a function';

  function memoize(func, resolver) {
    if (typeof func != 'function' || resolver != null && typeof resolver != 'function') {
      throw new TypeError(FUNC_ERROR_TEXT);
    }

    var memoized = function memoized() {
      var args = arguments,
          key = resolver ? resolver.apply(this, args) : args[0],
          cache = memoized.cache;

      if (cache.has(key)) {
        return cache.get(key);
      }

      var result = func.apply(this, args);
      memoized.cache = cache.set(key, result) || cache;
      return result;
    };

    memoized.cache = new (memoize.Cache || MapCache)();
    return memoized;
  }

  memoize.Cache = MapCache;
  module.exports = memoize;
},732,[651],"node_modules/lodash/memoize.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var baseToString = _$$_REQUIRE(_dependencyMap[0], "./_baseToString");

  function toString(value) {
    return value == null ? '' : baseToString(value);
  }

  module.exports = toString;
},733,[734],"node_modules/lodash/toString.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var Symbol = _$$_REQUIRE(_dependencyMap[0], "./_Symbol"),
      arrayMap = _$$_REQUIRE(_dependencyMap[1], "./_arrayMap"),
      isArray = _$$_REQUIRE(_dependencyMap[2], "./isArray"),
      isSymbol = _$$_REQUIRE(_dependencyMap[3], "./isSymbol");

  var INFINITY = 1 / 0;
  var symbolProto = Symbol ? typeof Symbol === "function" ? Symbol.prototype : "@@prototype" : undefined,
      symbolToString = symbolProto ? symbolProto.toString : undefined;

  function baseToString(value) {
    if (typeof value == 'string') {
      return value;
    }

    if (isArray(value)) {
      return arrayMap(value, baseToString) + '';
    }

    if (isSymbol(value)) {
      return symbolToString ? symbolToString.call(value) : '';
    }

    var result = value + '';
    return result == '0' && 1 / value == -INFINITY ? '-0' : result;
  }

  module.exports = baseToString;
},734,[618,626,623,729],"node_modules/lodash/_baseToString.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  function last(array) {
    var length = array == null ? 0 : array.length;
    return length ? array[length - 1] : undefined;
  }

  module.exports = last;
},735,[],"node_modules/lodash/last.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var baseGet = _$$_REQUIRE(_dependencyMap[0], "./_baseGet"),
      baseSlice = _$$_REQUIRE(_dependencyMap[1], "./_baseSlice");

  function parent(object, path) {
    return path.length < 2 ? object : baseGet(object, baseSlice(path, 0, -1));
  }

  module.exports = parent;
},736,[737,739],"node_modules/lodash/_parent.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var castPath = _$$_REQUIRE(_dependencyMap[0], "./_castPath"),
      toKey = _$$_REQUIRE(_dependencyMap[1], "./_toKey");

  function baseGet(object, path) {
    path = castPath(path, object);
    var index = 0,
        length = path.length;

    while (object != null && index < length) {
      object = object[toKey(path[index++])];
    }

    return index && index == length ? object : undefined;
  }

  module.exports = baseGet;
},737,[727,738],"node_modules/lodash/_baseGet.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var isSymbol = _$$_REQUIRE(_dependencyMap[0], "./isSymbol");

  var INFINITY = 1 / 0;

  function toKey(value) {
    if (typeof value == 'string' || isSymbol(value)) {
      return value;
    }

    var result = value + '';
    return result == '0' && 1 / value == -INFINITY ? '-0' : result;
  }

  module.exports = toKey;
},738,[729],"node_modules/lodash/_toKey.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  function baseSlice(array, start, end) {
    var index = -1,
        length = array.length;

    if (start < 0) {
      start = -start > length ? 0 : length + start;
    }

    end = end > length ? length : end;

    if (end < 0) {
      end += length;
    }

    length = start > end ? 0 : end - start >>> 0;
    start >>>= 0;
    var result = Array(length);

    while (++index < length) {
      result[index] = array[index + start];
    }

    return result;
  }

  module.exports = baseSlice;
},739,[],"node_modules/lodash/_baseSlice.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var isPlainObject = _$$_REQUIRE(_dependencyMap[0], "./isPlainObject");

  function customOmitClone(value) {
    return isPlainObject(value) ? undefined : value;
  }

  module.exports = customOmitClone;
},740,[741],"node_modules/lodash/_customOmitClone.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var baseGetTag = _$$_REQUIRE(_dependencyMap[0], "./_baseGetTag"),
      getPrototype = _$$_REQUIRE(_dependencyMap[1], "./_getPrototype"),
      isObjectLike = _$$_REQUIRE(_dependencyMap[2], "./isObjectLike");

  var objectTag = '[object Object]';
  var funcProto = Function.prototype,
      objectProto = Object.prototype;
  var funcToString = funcProto.toString;
  var hasOwnProperty = objectProto.hasOwnProperty;
  var objectCtorString = funcToString.call(Object);

  function isPlainObject(value) {
    if (!isObjectLike(value) || baseGetTag(value) != objectTag) {
      return false;
    }

    var proto = getPrototype(value);

    if (proto === null) {
      return true;
    }

    var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor;
    return typeof Ctor == 'function' && Ctor instanceof Ctor && funcToString.call(Ctor) == objectCtorString;
  }

  module.exports = isPlainObject;
},741,[617,703,624],"node_modules/lodash/isPlainObject.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var flatten = _$$_REQUIRE(_dependencyMap[0], "./flatten"),
      overRest = _$$_REQUIRE(_dependencyMap[1], "./_overRest"),
      setToString = _$$_REQUIRE(_dependencyMap[2], "./_setToString");

  function flatRest(func) {
    return setToString(overRest(func, undefined, flatten), func + '');
  }

  module.exports = flatRest;
},742,[743,746,748],"node_modules/lodash/_flatRest.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var baseFlatten = _$$_REQUIRE(_dependencyMap[0], "./_baseFlatten");

  function flatten(array) {
    var length = array == null ? 0 : array.length;
    return length ? baseFlatten(array, 1) : [];
  }

  module.exports = flatten;
},743,[744],"node_modules/lodash/flatten.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var arrayPush = _$$_REQUIRE(_dependencyMap[0], "./_arrayPush"),
      isFlattenable = _$$_REQUIRE(_dependencyMap[1], "./_isFlattenable");

  function baseFlatten(array, depth, predicate, isStrict, result) {
    var index = -1,
        length = array.length;
    predicate || (predicate = isFlattenable);
    result || (result = []);

    while (++index < length) {
      var value = array[index];

      if (depth > 0 && predicate(value)) {
        if (depth > 1) {
          baseFlatten(value, depth - 1, predicate, isStrict, result);
        } else {
          arrayPush(result, value);
        }
      } else if (!isStrict) {
        result[result.length] = value;
      }
    }

    return result;
  }

  module.exports = baseFlatten;
},744,[702,745],"node_modules/lodash/_baseFlatten.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var Symbol = _$$_REQUIRE(_dependencyMap[0], "./_Symbol"),
      isArguments = _$$_REQUIRE(_dependencyMap[1], "./isArguments"),
      isArray = _$$_REQUIRE(_dependencyMap[2], "./isArray");

  var spreadableSymbol = Symbol ? typeof Symbol === "function" ? Symbol.isConcatSpreadable : "@@isConcatSpreadable" : undefined;

  function isFlattenable(value) {
    return isArray(value) || isArguments(value) || !!(spreadableSymbol && value && value[spreadableSymbol]);
  }

  module.exports = isFlattenable;
},745,[618,675,623],"node_modules/lodash/_isFlattenable.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var apply = _$$_REQUIRE(_dependencyMap[0], "./_apply");

  var nativeMax = Math.max;

  function overRest(func, start, transform) {
    start = nativeMax(start === undefined ? func.length - 1 : start, 0);
    return function () {
      var args = arguments,
          index = -1,
          length = nativeMax(args.length - start, 0),
          array = Array(length);

      while (++index < length) {
        array[index] = args[start + index];
      }

      index = -1;
      var otherArgs = Array(start + 1);

      while (++index < start) {
        otherArgs[index] = args[index];
      }

      otherArgs[start] = transform(array);
      return apply(func, this, otherArgs);
    };
  }

  module.exports = overRest;
},746,[747],"node_modules/lodash/_overRest.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  function apply(func, thisArg, args) {
    switch (args.length) {
      case 0:
        return func.call(thisArg);

      case 1:
        return func.call(thisArg, args[0]);

      case 2:
        return func.call(thisArg, args[0], args[1]);

      case 3:
        return func.call(thisArg, args[0], args[1], args[2]);
    }

    return func.apply(thisArg, args);
  }

  module.exports = apply;
},747,[],"node_modules/lodash/_apply.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var baseSetToString = _$$_REQUIRE(_dependencyMap[0], "./_baseSetToString"),
      shortOut = _$$_REQUIRE(_dependencyMap[1], "./_shortOut");

  var setToString = shortOut(baseSetToString);
  module.exports = setToString;
},748,[749,752],"node_modules/lodash/_setToString.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var constant = _$$_REQUIRE(_dependencyMap[0], "./constant"),
      defineProperty = _$$_REQUIRE(_dependencyMap[1], "./_defineProperty"),
      identity = _$$_REQUIRE(_dependencyMap[2], "./identity");

  var baseSetToString = !defineProperty ? identity : function (func, string) {
    return defineProperty(func, 'toString', {
      'configurable': true,
      'enumerable': false,
      'value': constant(string),
      'writable': true
    });
  };
  module.exports = baseSetToString;
},749,[750,669,751],"node_modules/lodash/_baseSetToString.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  function constant(value) {
    return function () {
      return value;
    };
  }

  module.exports = constant;
},750,[],"node_modules/lodash/constant.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  function identity(value) {
    return value;
  }

  module.exports = identity;
},751,[],"node_modules/lodash/identity.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var HOT_COUNT = 800,
      HOT_SPAN = 16;
  var nativeNow = Date.now;

  function shortOut(func) {
    var count = 0,
        lastCalled = 0;
    return function () {
      var stamp = nativeNow(),
          remaining = HOT_SPAN - (stamp - lastCalled);
      lastCalled = stamp;

      if (remaining > 0) {
        if (++count >= HOT_COUNT) {
          return arguments[0];
        }
      } else {
        count = 0;
      }

      return func.apply(undefined, arguments);
    };
  }

  module.exports = shortOut;
},752,[],"node_modules/lodash/_shortOut.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var basePick = _$$_REQUIRE(_dependencyMap[0], "./_basePick"),
      flatRest = _$$_REQUIRE(_dependencyMap[1], "./_flatRest");

  var pick = flatRest(function (object, paths) {
    return object == null ? {} : basePick(object, paths);
  });
  module.exports = pick;
},753,[754,742],"node_modules/lodash/pick.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var basePickBy = _$$_REQUIRE(_dependencyMap[0], "./_basePickBy"),
      hasIn = _$$_REQUIRE(_dependencyMap[1], "./hasIn");

  function basePick(object, paths) {
    return basePickBy(object, paths, function (value, path) {
      return hasIn(object, path);
    });
  }

  module.exports = basePick;
},754,[755,757],"node_modules/lodash/_basePick.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var baseGet = _$$_REQUIRE(_dependencyMap[0], "./_baseGet"),
      baseSet = _$$_REQUIRE(_dependencyMap[1], "./_baseSet"),
      castPath = _$$_REQUIRE(_dependencyMap[2], "./_castPath");

  function basePickBy(object, paths, predicate) {
    var index = -1,
        length = paths.length,
        result = {};

    while (++index < length) {
      var path = paths[index],
          value = baseGet(object, path);

      if (predicate(value, path)) {
        baseSet(result, castPath(path, object), value);
      }
    }

    return result;
  }

  module.exports = basePickBy;
},755,[737,756,727],"node_modules/lodash/_basePickBy.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var assignValue = _$$_REQUIRE(_dependencyMap[0], "./_assignValue"),
      castPath = _$$_REQUIRE(_dependencyMap[1], "./_castPath"),
      isIndex = _$$_REQUIRE(_dependencyMap[2], "./_isIndex"),
      isObject = _$$_REQUIRE(_dependencyMap[3], "./isObject"),
      toKey = _$$_REQUIRE(_dependencyMap[4], "./_toKey");

  function baseSet(object, path, value, customizer) {
    if (!isObject(object)) {
      return object;
    }

    path = castPath(path, object);
    var index = -1,
        length = path.length,
        lastIndex = length - 1,
        nested = object;

    while (nested != null && ++index < length) {
      var key = toKey(path[index]),
          newValue = value;

      if (index != lastIndex) {
        var objValue = nested[key];
        newValue = customizer ? customizer(objValue, key, nested) : undefined;

        if (newValue === undefined) {
          newValue = isObject(objValue) ? objValue : isIndex(path[index + 1]) ? [] : {};
        }
      }

      assignValue(nested, key, newValue);
      nested = nested[key];
    }

    return object;
  }

  module.exports = baseSet;
},756,[667,727,679,646,738],"node_modules/lodash/_baseSet.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var baseHasIn = _$$_REQUIRE(_dependencyMap[0], "./_baseHasIn"),
      hasPath = _$$_REQUIRE(_dependencyMap[1], "./_hasPath");

  function hasIn(object, path) {
    return object != null && hasPath(object, path, baseHasIn);
  }

  module.exports = hasIn;
},757,[758,759],"node_modules/lodash/hasIn.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  function baseHasIn(object, key) {
    return object != null && key in Object(object);
  }

  module.exports = baseHasIn;
},758,[],"node_modules/lodash/_baseHasIn.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var castPath = _$$_REQUIRE(_dependencyMap[0], "./_castPath"),
      isArguments = _$$_REQUIRE(_dependencyMap[1], "./isArguments"),
      isArray = _$$_REQUIRE(_dependencyMap[2], "./isArray"),
      isIndex = _$$_REQUIRE(_dependencyMap[3], "./_isIndex"),
      isLength = _$$_REQUIRE(_dependencyMap[4], "./isLength"),
      toKey = _$$_REQUIRE(_dependencyMap[5], "./_toKey");

  function hasPath(object, path, hasFunc) {
    path = castPath(path, object);
    var index = -1,
        length = path.length,
        result = false;

    while (++index < length) {
      var key = toKey(path[index]);

      if (!(result = object != null && hasFunc(object, key))) {
        break;
      }

      object = object[key];
    }

    if (result || ++index != length) {
      return result;
    }

    length = object == null ? 0 : object.length;
    return !!length && isLength(length) && isIndex(key, length) && (isArray(object) || isArguments(object));
  }

  module.exports = hasPath;
},759,[727,675,623,679,682,738],"node_modules/lodash/_hasPath.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/interopRequireWildcard");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = createTabBarItemIOSComponent;

  var _extends2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/extends"));

  var _regenerator = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/regenerator"));

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf3 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "@babel/runtime/helpers/inherits"));

  var _isEqual = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "lodash/isEqual"));

  var _pick = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[10], "lodash/pick"));

  var _react = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[11], "react"));

  var _propTypes = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[12], "prop-types"));

  var _reactNative = _$$_REQUIRE(_dependencyMap[13], "./react-native");

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native-vector-icons/lib/tab-bar-item-ios.js";
  var ICON_PROP_NAMES = ['iconName', 'iconSize', 'iconColor'];
  var SELECTED_ICON_PROP_NAMES = [].concat(ICON_PROP_NAMES, ['selectedIconName', 'selectedIconColor']);

  var arePropsEqual = function arePropsEqual(keys) {
    return function (prevProps, nextProps) {
      return (0, _isEqual.default)((0, _pick.default)(prevProps, keys), (0, _pick.default)(nextProps, keys));
    };
  };

  var areIconPropsEqual = arePropsEqual(ICON_PROP_NAMES);
  var areSelectedIconPropsEqual = arePropsEqual(SELECTED_ICON_PROP_NAMES);

  function createTabBarItemIOSComponent(IconNamePropType, getImageSource) {
    var _class, _temp;

    return _temp = _class = function (_PureComponent) {
      (0, _inherits2.default)(TabBarItemIOS, _PureComponent);

      function TabBarItemIOS() {
        var _getPrototypeOf2;

        var _this;

        (0, _classCallCheck2.default)(this, TabBarItemIOS);

        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
          args[_key] = arguments[_key];
        }

        _this = (0, _possibleConstructorReturn2.default)(this, (_getPrototypeOf2 = (0, _getPrototypeOf3.default)(TabBarItemIOS)).call.apply(_getPrototypeOf2, [this].concat(args)));
        _this.state = {
          icon: undefined,
          selectedIcon: undefined
        };
        return _this;
      }

      (0, _createClass2.default)(TabBarItemIOS, [{
        key: "componentDidMount",
        value: function componentDidMount() {
          this.updateIconSource();
          this.updateSelectedIconSource();
        }
      }, {
        key: "componentDidUpdate",
        value: function componentDidUpdate(prevProps) {
          if (!areIconPropsEqual(prevProps, this.props)) {
            this.updateIconSource();
          }

          if (!areSelectedIconPropsEqual(prevProps, this.props)) {
            this.updateSelectedIconSource();
          }
        }
      }, {
        key: "updateIconSource",
        value: function updateIconSource() {
          var _this$props, iconName, iconSize, iconColor, icon;

          return _regenerator.default.async(function updateIconSource$(_context) {
            while (1) {
              switch (_context.prev = _context.next) {
                case 0:
                  _this$props = this.props, iconName = _this$props.iconName, iconSize = _this$props.iconSize, iconColor = _this$props.iconColor;

                  if (!iconName) {
                    _context.next = 8;
                    break;
                  }

                  _context.next = 4;
                  return _regenerator.default.awrap(getImageSource(iconName, iconSize, iconColor));

                case 4:
                  icon = _context.sent;
                  this.setState({
                    icon: icon
                  });
                  _context.next = 9;
                  break;

                case 8:
                  if (this.state.icon) {
                    this.setState({
                      icon: undefined
                    });
                  }

                case 9:
                case "end":
                  return _context.stop();
              }
            }
          }, null, this);
        }
      }, {
        key: "updateSelectedIconSource",
        value: function updateSelectedIconSource() {
          var _this$props2, iconName, iconColor, iconSize, selectedIconName, selectedIconColor, selectedIcon;

          return _regenerator.default.async(function updateSelectedIconSource$(_context2) {
            while (1) {
              switch (_context2.prev = _context2.next) {
                case 0:
                  _this$props2 = this.props, iconName = _this$props2.iconName, iconColor = _this$props2.iconColor, iconSize = _this$props2.iconSize, selectedIconName = _this$props2.selectedIconName, selectedIconColor = _this$props2.selectedIconColor;

                  if (!(selectedIconName || selectedIconColor)) {
                    _context2.next = 8;
                    break;
                  }

                  _context2.next = 4;
                  return _regenerator.default.awrap(getImageSource(selectedIconName || iconName, iconSize, selectedIconColor || iconColor));

                case 4:
                  selectedIcon = _context2.sent;
                  this.setState({
                    selectedIcon: selectedIcon
                  });
                  _context2.next = 9;
                  break;

                case 8:
                  if (this.state.selectedIcon) {
                    this.setState({
                      selectedIcon: undefined
                    });
                  }

                case 9:
                case "end":
                  return _context2.stop();
              }
            }
          }, null, this);
        }
      }, {
        key: "render",
        value: function render() {
          return _react.default.createElement(_reactNative.TabBarIOS.Item, (0, _extends2.default)({}, this.state, this.props, {
            __source: {
              fileName: _jsxFileName,
              lineNumber: 93
            }
          }));
        }
      }]);
      return TabBarItemIOS;
    }(_react.PureComponent), _class.propTypes = {
      iconName: IconNamePropType.isRequired,
      selectedIconName: IconNamePropType,
      iconSize: _propTypes.default.number,
      iconColor: _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.number]),
      selectedIconColor: _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.number])
    }, _class.defaultProps = {
      iconSize: 30
    }, _temp;
  }
},760,[1,9,13,103,24,25,32,34,37,761,753,54,69,613],"node_modules/react-native-vector-icons/lib/tab-bar-item-ios.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var baseIsEqual = _$$_REQUIRE(_dependencyMap[0], "./_baseIsEqual");

  function isEqual(value, other) {
    return baseIsEqual(value, other);
  }

  module.exports = isEqual;
},761,[762],"node_modules/lodash/isEqual.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var baseIsEqualDeep = _$$_REQUIRE(_dependencyMap[0], "./_baseIsEqualDeep"),
      isObjectLike = _$$_REQUIRE(_dependencyMap[1], "./isObjectLike");

  function baseIsEqual(value, other, bitmask, customizer, stack) {
    if (value === other) {
      return true;
    }

    if (value == null || other == null || !isObjectLike(value) && !isObjectLike(other)) {
      return value !== value && other !== other;
    }

    return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);
  }

  module.exports = baseIsEqual;
},762,[763,624],"node_modules/lodash/_baseIsEqual.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var Stack = _$$_REQUIRE(_dependencyMap[0], "./_Stack"),
      equalArrays = _$$_REQUIRE(_dependencyMap[1], "./_equalArrays"),
      equalByTag = _$$_REQUIRE(_dependencyMap[2], "./_equalByTag"),
      equalObjects = _$$_REQUIRE(_dependencyMap[3], "./_equalObjects"),
      getTag = _$$_REQUIRE(_dependencyMap[4], "./_getTag"),
      isArray = _$$_REQUIRE(_dependencyMap[5], "./isArray"),
      isBuffer = _$$_REQUIRE(_dependencyMap[6], "./isBuffer"),
      isTypedArray = _$$_REQUIRE(_dependencyMap[7], "./isTypedArray");

  var COMPARE_PARTIAL_FLAG = 1;
  var argsTag = '[object Arguments]',
      arrayTag = '[object Array]',
      objectTag = '[object Object]';
  var objectProto = Object.prototype;
  var hasOwnProperty = objectProto.hasOwnProperty;

  function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
    var objIsArr = isArray(object),
        othIsArr = isArray(other),
        objTag = objIsArr ? arrayTag : getTag(object),
        othTag = othIsArr ? arrayTag : getTag(other);
    objTag = objTag == argsTag ? objectTag : objTag;
    othTag = othTag == argsTag ? objectTag : othTag;
    var objIsObj = objTag == objectTag,
        othIsObj = othTag == objectTag,
        isSameTag = objTag == othTag;

    if (isSameTag && isBuffer(object)) {
      if (!isBuffer(other)) {
        return false;
      }

      objIsArr = true;
      objIsObj = false;
    }

    if (isSameTag && !objIsObj) {
      stack || (stack = new Stack());
      return objIsArr || isTypedArray(object) ? equalArrays(object, other, bitmask, customizer, equalFunc, stack) : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);
    }

    if (!(bitmask & COMPARE_PARTIAL_FLAG)) {
      var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),
          othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');

      if (objIsWrapped || othIsWrapped) {
        var objUnwrapped = objIsWrapped ? object.value() : object,
            othUnwrapped = othIsWrapped ? other.value() : other;
        stack || (stack = new Stack());
        return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
      }
    }

    if (!isSameTag) {
      return false;
    }

    stack || (stack = new Stack());
    return equalObjects(object, other, bitmask, customizer, equalFunc, stack);
  }

  module.exports = baseIsEqualDeep;
},763,[628,764,770,773,707,623,677,680],"node_modules/lodash/_baseIsEqualDeep.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var SetCache = _$$_REQUIRE(_dependencyMap[0], "./_SetCache"),
      arraySome = _$$_REQUIRE(_dependencyMap[1], "./_arraySome"),
      cacheHas = _$$_REQUIRE(_dependencyMap[2], "./_cacheHas");

  var COMPARE_PARTIAL_FLAG = 1,
      COMPARE_UNORDERED_FLAG = 2;

  function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {
    var isPartial = bitmask & COMPARE_PARTIAL_FLAG,
        arrLength = array.length,
        othLength = other.length;

    if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
      return false;
    }

    var stacked = stack.get(array);

    if (stacked && stack.get(other)) {
      return stacked == other;
    }

    var index = -1,
        result = true,
        seen = bitmask & COMPARE_UNORDERED_FLAG ? new SetCache() : undefined;
    stack.set(array, other);
    stack.set(other, array);

    while (++index < arrLength) {
      var arrValue = array[index],
          othValue = other[index];

      if (customizer) {
        var compared = isPartial ? customizer(othValue, arrValue, index, other, array, stack) : customizer(arrValue, othValue, index, array, other, stack);
      }

      if (compared !== undefined) {
        if (compared) {
          continue;
        }

        result = false;
        break;
      }

      if (seen) {
        if (!arraySome(other, function (othValue, othIndex) {
          if (!cacheHas(seen, othIndex) && (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
            return seen.push(othIndex);
          }
        })) {
          result = false;
          break;
        }
      } else if (!(arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
        result = false;
        break;
      }
    }

    stack['delete'](array);
    stack['delete'](other);
    return result;
  }

  module.exports = equalArrays;
},764,[765,768,769],"node_modules/lodash/_equalArrays.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var MapCache = _$$_REQUIRE(_dependencyMap[0], "./_MapCache"),
      setCacheAdd = _$$_REQUIRE(_dependencyMap[1], "./_setCacheAdd"),
      setCacheHas = _$$_REQUIRE(_dependencyMap[2], "./_setCacheHas");

  function SetCache(values) {
    var index = -1,
        length = values == null ? 0 : values.length;
    this.__data__ = new MapCache();

    while (++index < length) {
      this.add(values[index]);
    }
  }

  SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
  SetCache.prototype.has = setCacheHas;
  module.exports = SetCache;
},765,[651,766,767],"node_modules/lodash/_SetCache.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var HASH_UNDEFINED = '__lodash_hash_undefined__';

  function setCacheAdd(value) {
    this.__data__.set(value, HASH_UNDEFINED);

    return this;
  }

  module.exports = setCacheAdd;
},766,[],"node_modules/lodash/_setCacheAdd.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  function setCacheHas(value) {
    return this.__data__.has(value);
  }

  module.exports = setCacheHas;
},767,[],"node_modules/lodash/_setCacheHas.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  function arraySome(array, predicate) {
    var index = -1,
        length = array == null ? 0 : array.length;

    while (++index < length) {
      if (predicate(array[index], index, array)) {
        return true;
      }
    }

    return false;
  }

  module.exports = arraySome;
},768,[],"node_modules/lodash/_arraySome.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  function cacheHas(cache, key) {
    return cache.has(key);
  }

  module.exports = cacheHas;
},769,[],"node_modules/lodash/_cacheHas.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var Symbol = _$$_REQUIRE(_dependencyMap[0], "./_Symbol"),
      Uint8Array = _$$_REQUIRE(_dependencyMap[1], "./_Uint8Array"),
      eq = _$$_REQUIRE(_dependencyMap[2], "./eq"),
      equalArrays = _$$_REQUIRE(_dependencyMap[3], "./_equalArrays"),
      mapToArray = _$$_REQUIRE(_dependencyMap[4], "./_mapToArray"),
      setToArray = _$$_REQUIRE(_dependencyMap[5], "./_setToArray");

  var COMPARE_PARTIAL_FLAG = 1,
      COMPARE_UNORDERED_FLAG = 2;
  var boolTag = '[object Boolean]',
      dateTag = '[object Date]',
      errorTag = '[object Error]',
      mapTag = '[object Map]',
      numberTag = '[object Number]',
      regexpTag = '[object RegExp]',
      setTag = '[object Set]',
      stringTag = '[object String]',
      symbolTag = '[object Symbol]';
  var arrayBufferTag = '[object ArrayBuffer]',
      dataViewTag = '[object DataView]';
  var symbolProto = Symbol ? typeof Symbol === "function" ? Symbol.prototype : "@@prototype" : undefined,
      symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;

  function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {
    switch (tag) {
      case dataViewTag:
        if (object.byteLength != other.byteLength || object.byteOffset != other.byteOffset) {
          return false;
        }

        object = object.buffer;
        other = other.buffer;

      case arrayBufferTag:
        if (object.byteLength != other.byteLength || !equalFunc(new Uint8Array(object), new Uint8Array(other))) {
          return false;
        }

        return true;

      case boolTag:
      case dateTag:
      case numberTag:
        return eq(+object, +other);

      case errorTag:
        return object.name == other.name && object.message == other.message;

      case regexpTag:
      case stringTag:
        return object == other + '';

      case mapTag:
        var convert = mapToArray;

      case setTag:
        var isPartial = bitmask & COMPARE_PARTIAL_FLAG;
        convert || (convert = setToArray);

        if (object.size != other.size && !isPartial) {
          return false;
        }

        var stacked = stack.get(object);

        if (stacked) {
          return stacked == other;
        }

        bitmask |= COMPARE_UNORDERED_FLAG;
        stack.set(object, other);
        var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
        stack['delete'](object);
        return result;

      case symbolTag:
        if (symbolValueOf) {
          return symbolValueOf.call(object) == symbolValueOf.call(other);
        }

    }

    return false;
  }

  module.exports = equalByTag;
},770,[618,715,633,764,771,772],"node_modules/lodash/_equalByTag.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  function mapToArray(map) {
    var index = -1,
        result = Array(map.size);
    map.forEach(function (value, key) {
      result[++index] = [key, value];
    });
    return result;
  }

  module.exports = mapToArray;
},771,[],"node_modules/lodash/_mapToArray.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  function setToArray(set) {
    var index = -1,
        result = Array(set.size);
    set.forEach(function (value) {
      result[++index] = value;
    });
    return result;
  }

  module.exports = setToArray;
},772,[],"node_modules/lodash/_setToArray.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var getAllKeys = _$$_REQUIRE(_dependencyMap[0], "./_getAllKeys");

  var COMPARE_PARTIAL_FLAG = 1;
  var objectProto = Object.prototype;
  var hasOwnProperty = objectProto.hasOwnProperty;

  function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {
    var isPartial = bitmask & COMPARE_PARTIAL_FLAG,
        objProps = getAllKeys(object),
        objLength = objProps.length,
        othProps = getAllKeys(other),
        othLength = othProps.length;

    if (objLength != othLength && !isPartial) {
      return false;
    }

    var index = objLength;

    while (index--) {
      var key = objProps[index];

      if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {
        return false;
      }
    }

    var stacked = stack.get(object);

    if (stacked && stack.get(other)) {
      return stacked == other;
    }

    var result = true;
    stack.set(object, other);
    stack.set(other, object);
    var skipCtor = isPartial;

    while (++index < objLength) {
      key = objProps[index];
      var objValue = object[key],
          othValue = other[key];

      if (customizer) {
        var compared = isPartial ? customizer(othValue, objValue, key, other, object, stack) : customizer(objValue, othValue, key, object, other, stack);
      }

      if (!(compared === undefined ? objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack) : compared)) {
        result = false;
        break;
      }

      skipCtor || (skipCtor = key == 'constructor');
    }

    if (result && !skipCtor) {
      var objCtor = object.constructor,
          othCtor = other.constructor;

      if (objCtor != othCtor && 'constructor' in object && 'constructor' in other && !(typeof objCtor == 'function' && objCtor instanceof objCtor && typeof othCtor == 'function' && othCtor instanceof othCtor)) {
        result = false;
      }
    }

    stack['delete'](object);
    stack['delete'](other);
    return result;
  }

  module.exports = equalObjects;
},773,[704],"node_modules/lodash/_equalObjects.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  var _interopRequireWildcard = _$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/interopRequireWildcard");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = createToolbarAndroidComponent;

  var _extends2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/extends"));

  var _defineProperty2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/defineProperty"));

  var _regenerator = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/regenerator"));

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf3 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[9], "@babel/runtime/helpers/inherits"));

  var _isEqual = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[10], "lodash/isEqual"));

  var _pick = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[11], "lodash/pick"));

  var _react = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[12], "react"));

  var _propTypes = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[13], "prop-types"));

  var _reactNative = _$$_REQUIRE(_dependencyMap[14], "./react-native");

  var _jsxFileName = "/home/flummi/dev/f0ckapp/node_modules/react-native-vector-icons/lib/toolbar-android.js";

  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

  var ICON_PROP_NAMES = ['iconSize', 'iconColor', 'titleColor'];
  var LOGO_ICON_PROP_NAMES = [].concat(ICON_PROP_NAMES, ['logoName']);
  var NAV_ICON_PROP_NAMES = [].concat(ICON_PROP_NAMES, ['navIconName']);
  var OVERFLOW_ICON_PROP_NAMES = [].concat(ICON_PROP_NAMES, ['overflowIconName']);
  var ACTIONS_PROP_NAMES = [].concat(ICON_PROP_NAMES, ['actions']);

  var arePropsEqual = function arePropsEqual(keys) {
    return function (prevProps, nextProps) {
      return (0, _isEqual.default)((0, _pick.default)(prevProps, keys), (0, _pick.default)(nextProps, keys));
    };
  };

  var areLogoIconPropsEqual = arePropsEqual(LOGO_ICON_PROP_NAMES);
  var areNavIconPropsEqual = arePropsEqual(NAV_ICON_PROP_NAMES);
  var areOverflowIconPropsEqual = arePropsEqual(OVERFLOW_ICON_PROP_NAMES);
  var areActionPropsEqual = arePropsEqual(ACTIONS_PROP_NAMES);

  function createToolbarAndroidComponent(IconNamePropType, getImageSource) {
    var _class, _temp;

    return _temp = _class = function (_PureComponent) {
      (0, _inherits2.default)(IconToolbarAndroid, _PureComponent);

      function IconToolbarAndroid() {
        var _getPrototypeOf2;

        var _this;

        (0, _classCallCheck2.default)(this, IconToolbarAndroid);

        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
          args[_key] = arguments[_key];
        }

        _this = (0, _possibleConstructorReturn2.default)(this, (_getPrototypeOf2 = (0, _getPrototypeOf3.default)(IconToolbarAndroid)).call.apply(_getPrototypeOf2, [this].concat(args)));
        _this.state = {
          logo: undefined,
          navIcon: undefined,
          overflowIcon: undefined,
          actions: undefined
        };
        return _this;
      }

      (0, _createClass2.default)(IconToolbarAndroid, [{
        key: "componentDidMount",
        value: function componentDidMount() {
          this.updateLogoIconSource();
          this.updateNavIconSource();
          this.updateOverflowIconSource();
          this.updateActionIconSources();
        }
      }, {
        key: "componentDidUpdate",
        value: function componentDidUpdate(prevProps) {
          if (!areLogoIconPropsEqual(prevProps, this.props)) {
            this.updateLogoIconSource();
          }

          if (!areNavIconPropsEqual(prevProps, this.props)) {
            this.updateNavIconSource();
          }

          if (!areOverflowIconPropsEqual(prevProps, this.props)) {
            this.updateOverflowIconSource();
          }

          if (!areActionPropsEqual(prevProps, this.props)) {
            this.updateActionIconSources();
          }
        }
      }, {
        key: "updateLogoIconSource",
        value: function updateLogoIconSource() {
          var _this$props, logoName, iconSize, iconColor, titleColor, logo;

          return _regenerator.default.async(function updateLogoIconSource$(_context) {
            while (1) {
              switch (_context.prev = _context.next) {
                case 0:
                  _this$props = this.props, logoName = _this$props.logoName, iconSize = _this$props.iconSize, iconColor = _this$props.iconColor, titleColor = _this$props.titleColor;

                  if (!logoName) {
                    _context.next = 8;
                    break;
                  }

                  _context.next = 4;
                  return _regenerator.default.awrap(getImageSource(logoName, iconSize, iconColor || titleColor));

                case 4:
                  logo = _context.sent;
                  this.setState({
                    logo: logo
                  });
                  _context.next = 9;
                  break;

                case 8:
                  if (this.state.logo) {
                    this.setState({
                      logo: undefined
                    });
                  }

                case 9:
                case "end":
                  return _context.stop();
              }
            }
          }, null, this);
        }
      }, {
        key: "updateNavIconSource",
        value: function updateNavIconSource() {
          var _this$props2, navIconName, iconSize, iconColor, titleColor, navIcon;

          return _regenerator.default.async(function updateNavIconSource$(_context2) {
            while (1) {
              switch (_context2.prev = _context2.next) {
                case 0:
                  _this$props2 = this.props, navIconName = _this$props2.navIconName, iconSize = _this$props2.iconSize, iconColor = _this$props2.iconColor, titleColor = _this$props2.titleColor;

                  if (!navIconName) {
                    _context2.next = 8;
                    break;
                  }

                  _context2.next = 4;
                  return _regenerator.default.awrap(getImageSource(navIconName, iconSize, iconColor || titleColor));

                case 4:
                  navIcon = _context2.sent;
                  this.setState({
                    navIcon: navIcon
                  });
                  _context2.next = 9;
                  break;

                case 8:
                  if (this.state.navIcon) {
                    this.setState({
                      navIcon: undefined
                    });
                  }

                case 9:
                case "end":
                  return _context2.stop();
              }
            }
          }, null, this);
        }
      }, {
        key: "updateOverflowIconSource",
        value: function updateOverflowIconSource() {
          var _this$props3, overflowIconName, iconSize, iconColor, titleColor, overflowIcon;

          return _regenerator.default.async(function updateOverflowIconSource$(_context3) {
            while (1) {
              switch (_context3.prev = _context3.next) {
                case 0:
                  _this$props3 = this.props, overflowIconName = _this$props3.overflowIconName, iconSize = _this$props3.iconSize, iconColor = _this$props3.iconColor, titleColor = _this$props3.titleColor;

                  if (!overflowIconName) {
                    _context3.next = 8;
                    break;
                  }

                  _context3.next = 4;
                  return _regenerator.default.awrap(getImageSource(overflowIconName, iconSize, iconColor || titleColor));

                case 4:
                  overflowIcon = _context3.sent;
                  this.setState({
                    overflowIcon: overflowIcon
                  });
                  _context3.next = 9;
                  break;

                case 8:
                  if (this.state.overflowIcon) {
                    this.setState({
                      overflowIcon: undefined
                    });
                  }

                case 9:
                case "end":
                  return _context3.stop();
              }
            }
          }, null, this);
        }
      }, {
        key: "updateActionIconSources",
        value: function updateActionIconSources() {
          var _this$props4, actions, iconSize, iconColor, titleColor, updatedActions;

          return _regenerator.default.async(function updateActionIconSources$(_context4) {
            while (1) {
              switch (_context4.prev = _context4.next) {
                case 0:
                  _this$props4 = this.props, actions = _this$props4.actions, iconSize = _this$props4.iconSize, iconColor = _this$props4.iconColor, titleColor = _this$props4.titleColor;
                  _context4.next = 3;
                  return _regenerator.default.awrap(Promise.all((actions || []).map(function (action) {
                    if (action.iconName) {
                      return getImageSource(action.iconName, action.iconSize || iconSize, action.iconColor || iconColor || titleColor).then(function (icon) {
                        return _objectSpread({}, action, {
                          icon: icon
                        });
                      });
                    }

                    return Promise.resolve(action);
                  })));

                case 3:
                  updatedActions = _context4.sent;
                  this.setState({
                    actions: updatedActions
                  });

                case 5:
                case "end":
                  return _context4.stop();
              }
            }
          }, null, this);
        }
      }, {
        key: "render",
        value: function render() {
          return _react.default.createElement(_reactNative.ToolbarAndroid, (0, _extends2.default)({}, this.props, this.state, {
            __source: {
              fileName: _jsxFileName,
              lineNumber: 142
            }
          }));
        }
      }]);
      return IconToolbarAndroid;
    }(_react.PureComponent), _class.propTypes = {
      logoName: IconNamePropType,
      navIconName: IconNamePropType,
      overflowIconName: IconNamePropType,
      actions: _propTypes.default.arrayOf(_propTypes.default.shape({
        title: _propTypes.default.string.isRequired,
        iconName: IconNamePropType,
        iconSize: _propTypes.default.number,
        iconColor: _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.number]),
        show: _propTypes.default.oneOf(['always', 'ifRoom', 'never']),
        showWithText: _propTypes.default.bool
      })),
      iconSize: _propTypes.default.number,
      iconColor: _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.number]),
      titleColor: _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.number])
    }, _class.defaultProps = {
      iconSize: 24
    }, _temp;
  }
},774,[1,9,13,46,103,24,25,32,34,37,761,753,54,69,613],"node_modules/react-native-vector-icons/lib/toolbar-android.js");
__d(function(global, require, _aUnused, _bUnused, module, exports, _cUnused) {
  module.exports = {
  "ios-add": 61698,
  "ios-add-circle": 61697,
  "ios-add-circle-outline": 61696,
  "ios-airplane": 61751,
  "ios-alarm": 62408,
  "ios-albums": 62410,
  "ios-alert": 61700,
  "ios-american-football": 61702,
  "ios-analytics": 62414,
  "ios-aperture": 61704,
  "ios-apps": 61706,
  "ios-appstore": 61708,
  "ios-archive": 61710,
  "ios-arrow-back": 62415,
  "ios-arrow-down": 62416,
  "ios-arrow-dropdown": 61712,
  "ios-arrow-dropdown-circle": 61733,
  "ios-arrow-dropleft": 61714,
  "ios-arrow-dropleft-circle": 61737,
  "ios-arrow-dropright": 61716,
  "ios-arrow-dropright-circle": 61739,
  "ios-arrow-dropup": 61718,
  "ios-arrow-dropup-circle": 61741,
  "ios-arrow-forward": 62417,
  "ios-arrow-round-back": 61719,
  "ios-arrow-round-down": 61720,
  "ios-arrow-round-forward": 61721,
  "ios-arrow-round-up": 61722,
  "ios-arrow-up": 62424,
  "ios-at": 62426,
  "ios-attach": 61723,
  "ios-backspace": 61725,
  "ios-barcode": 62428,
  "ios-baseball": 62430,
  "ios-basket": 61727,
  "ios-basketball": 62432,
  "ios-battery-charging": 61728,
  "ios-battery-dead": 61729,
  "ios-battery-full": 61730,
  "ios-beaker": 61732,
  "ios-bed": 61753,
  "ios-beer": 61734,
  "ios-bicycle": 61735,
  "ios-bluetooth": 61736,
  "ios-boat": 61738,
  "ios-body": 62436,
  "ios-bonfire": 61740,
  "ios-book": 62440,
  "ios-bookmark": 61742,
  "ios-bookmarks": 62442,
  "ios-bowtie": 61744,
  "ios-briefcase": 62446,
  "ios-browsers": 62448,
  "ios-brush": 61746,
  "ios-bug": 61748,
  "ios-build": 61750,
  "ios-bulb": 61752,
  "ios-bus": 61754,
  "ios-business": 61859,
  "ios-cafe": 61756,
  "ios-calculator": 62450,
  "ios-calendar": 62452,
  "ios-call": 61758,
  "ios-camera": 62454,
  "ios-car": 61760,
  "ios-card": 61762,
  "ios-cart": 62456,
  "ios-cash": 61764,
  "ios-cellular": 61757,
  "ios-chatboxes": 62458,
  "ios-chatbubbles": 61766,
  "ios-checkbox": 61768,
  "ios-checkbox-outline": 61767,
  "ios-checkmark": 62463,
  "ios-checkmark-circle": 61770,
  "ios-checkmark-circle-outline": 61769,
  "ios-clipboard": 61772,
  "ios-clock": 62467,
  "ios-close": 62470,
  "ios-close-circle": 61774,
  "ios-close-circle-outline": 61773,
  "ios-cloud": 62476,
  "ios-cloud-circle": 61778,
  "ios-cloud-done": 61780,
  "ios-cloud-download": 62472,
  "ios-cloud-outline": 62473,
  "ios-cloud-upload": 62475,
  "ios-cloudy": 62480,
  "ios-cloudy-night": 62478,
  "ios-code": 61783,
  "ios-code-download": 61781,
  "ios-code-working": 61782,
  "ios-cog": 62482,
  "ios-color-fill": 61785,
  "ios-color-filter": 62484,
  "ios-color-palette": 61787,
  "ios-color-wand": 62486,
  "ios-compass": 61789,
  "ios-construct": 61791,
  "ios-contact": 62490,
  "ios-contacts": 61793,
  "ios-contract": 61794,
  "ios-contrast": 61795,
  "ios-copy": 62492,
  "ios-create": 61797,
  "ios-crop": 62494,
  "ios-cube": 61800,
  "ios-cut": 61802,
  "ios-desktop": 61804,
  "ios-disc": 61806,
  "ios-document": 61808,
  "ios-done-all": 61809,
  "ios-download": 62496,
  "ios-easel": 61811,
  "ios-egg": 61813,
  "ios-exit": 61815,
  "ios-expand": 61816,
  "ios-eye": 62501,
  "ios-eye-off": 61818,
  "ios-fastforward": 62503,
  "ios-female": 61819,
  "ios-filing": 62505,
  "ios-film": 62507,
  "ios-finger-print": 61820,
  "ios-fitness": 61867,
  "ios-flag": 62509,
  "ios-flame": 62511,
  "ios-flash": 61822,
  "ios-flash-off": 61743,
  "ios-flashlight": 61761,
  "ios-flask": 62513,
  "ios-flower": 62515,
  "ios-folder": 62517,
  "ios-folder-open": 61824,
  "ios-football": 62519,
  "ios-funnel": 61826,
  "ios-gift": 61841,
  "ios-git-branch": 61827,
  "ios-git-commit": 61828,
  "ios-git-compare": 61829,
  "ios-git-merge": 61830,
  "ios-git-network": 61831,
  "ios-git-pull-request": 61832,
  "ios-glasses": 62527,
  "ios-globe": 61834,
  "ios-grid": 61836,
  "ios-hammer": 61838,
  "ios-hand": 61840,
  "ios-happy": 61842,
  "ios-headset": 61844,
  "ios-heart": 62531,
  "ios-heart-dislike": 61759,
  "ios-heart-empty": 61851,
  "ios-heart-half": 61853,
  "ios-help": 62534,
  "ios-help-buoy": 61846,
  "ios-help-circle": 61848,
  "ios-help-circle-outline": 61847,
  "ios-home": 62536,
  "ios-hourglass": 61699,
  "ios-ice-cream": 61850,
  "ios-image": 61852,
  "ios-images": 61854,
  "ios-infinite": 62538,
  "ios-information": 62541,
  "ios-information-circle": 61856,
  "ios-information-circle-outline": 61855,
  "ios-jet": 61861,
  "ios-journal": 61833,
  "ios-key": 61863,
  "ios-keypad": 62544,
  "ios-laptop": 61864,
  "ios-leaf": 61866,
  "ios-link": 61994,
  "ios-list": 62548,
  "ios-list-box": 61763,
  "ios-locate": 61870,
  "ios-lock": 61872,
  "ios-log-in": 61873,
  "ios-log-out": 61874,
  "ios-magnet": 61876,
  "ios-mail": 61880,
  "ios-mail-open": 61878,
  "ios-mail-unread": 61765,
  "ios-male": 61881,
  "ios-man": 61883,
  "ios-map": 61885,
  "ios-medal": 61887,
  "ios-medical": 62556,
  "ios-medkit": 62558,
  "ios-megaphone": 61889,
  "ios-menu": 61891,
  "ios-mic": 62561,
  "ios-mic-off": 62559,
  "ios-microphone": 61894,
  "ios-moon": 62568,
  "ios-more": 61896,
  "ios-move": 61899,
  "ios-musical-note": 62571,
  "ios-musical-notes": 62572,
  "ios-navigate": 62574,
  "ios-notifications": 61907,
  "ios-notifications-off": 61905,
  "ios-notifications-outline": 61747,
  "ios-nuclear": 61909,
  "ios-nutrition": 62576,
  "ios-open": 61911,
  "ios-options": 61913,
  "ios-outlet": 61915,
  "ios-paper": 62578,
  "ios-paper-plane": 61917,
  "ios-partly-sunny": 61919,
  "ios-pause": 62584,
  "ios-paw": 62586,
  "ios-people": 62588,
  "ios-person": 62590,
  "ios-person-add": 61921,
  "ios-phone-landscape": 61922,
  "ios-phone-portrait": 61923,
  "ios-photos": 62594,
  "ios-pie": 62596,
  "ios-pin": 61925,
  "ios-pint": 62598,
  "ios-pizza": 61927,
  "ios-planet": 61931,
  "ios-play": 62600,
  "ios-play-circle": 61715,
  "ios-podium": 61933,
  "ios-power": 61935,
  "ios-pricetag": 62605,
  "ios-pricetags": 62607,
  "ios-print": 61937,
  "ios-pulse": 62611,
  "ios-qr-scanner": 61939,
  "ios-quote": 61941,
  "ios-radio": 61945,
  "ios-radio-button-off": 61942,
  "ios-radio-button-on": 61943,
  "ios-rainy": 62613,
  "ios-recording": 62615,
  "ios-redo": 62617,
  "ios-refresh": 62620,
  "ios-refresh-circle": 61749,
  "ios-remove": 61948,
  "ios-remove-circle": 61947,
  "ios-remove-circle-outline": 61946,
  "ios-reorder": 61949,
  "ios-repeat": 61950,
  "ios-resize": 61951,
  "ios-restaurant": 61953,
  "ios-return-left": 61954,
  "ios-return-right": 61955,
  "ios-reverse-camera": 62623,
  "ios-rewind": 62625,
  "ios-ribbon": 61957,
  "ios-rocket": 61771,
  "ios-rose": 62627,
  "ios-sad": 61959,
  "ios-save": 61862,
  "ios-school": 61961,
  "ios-search": 62629,
  "ios-send": 61964,
  "ios-settings": 62631,
  "ios-share": 61969,
  "ios-share-alt": 61967,
  "ios-shirt": 61971,
  "ios-shuffle": 62633,
  "ios-skip-backward": 61973,
  "ios-skip-forward": 61975,
  "ios-snow": 61976,
  "ios-speedometer": 62640,
  "ios-square": 61978,
  "ios-square-outline": 61788,
  "ios-star": 62643,
  "ios-star-half": 62641,
  "ios-star-outline": 62642,
  "ios-stats": 61980,
  "ios-stopwatch": 62645,
  "ios-subway": 61982,
  "ios-sunny": 62647,
  "ios-swap": 61983,
  "ios-switch": 61985,
  "ios-sync": 61986,
  "ios-tablet-landscape": 61987,
  "ios-tablet-portrait": 62030,
  "ios-tennisball": 62651,
  "ios-text": 62032,
  "ios-thermometer": 62034,
  "ios-thumbs-down": 62036,
  "ios-thumbs-up": 62038,
  "ios-thunderstorm": 62653,
  "ios-time": 62655,
  "ios-timer": 62657,
  "ios-today": 61775,
  "ios-train": 62040,
  "ios-transgender": 62041,
  "ios-trash": 62661,
  "ios-trending-down": 62042,
  "ios-trending-up": 62043,
  "ios-trophy": 62045,
  "ios-tv": 61717,
  "ios-umbrella": 62047,
  "ios-undo": 62663,
  "ios-unlock": 62049,
  "ios-videocam": 62669,
  "ios-volume-high": 61724,
  "ios-volume-low": 61726,
  "ios-volume-mute": 62051,
  "ios-volume-off": 62052,
  "ios-walk": 62054,
  "ios-wallet": 61835,
  "ios-warning": 62056,
  "ios-watch": 62057,
  "ios-water": 62059,
  "ios-wifi": 62061,
  "ios-wine": 62063,
  "ios-woman": 62065,
  "logo-android": 61989,
  "logo-angular": 61991,
  "logo-apple": 61993,
  "logo-bitbucket": 61843,
  "logo-bitcoin": 61995,
  "logo-buffer": 61997,
  "logo-chrome": 61999,
  "logo-closed-captioning": 61701,
  "logo-codepen": 62000,
  "logo-css3": 62001,
  "logo-designernews": 62002,
  "logo-dribbble": 62003,
  "logo-dropbox": 62004,
  "logo-euro": 62005,
  "logo-facebook": 62006,
  "logo-flickr": 61703,
  "logo-foursquare": 62007,
  "logo-freebsd-devil": 62008,
  "logo-game-controller-a": 61755,
  "logo-game-controller-b": 61825,
  "logo-github": 62009,
  "logo-google": 62010,
  "logo-googleplus": 62011,
  "logo-hackernews": 62012,
  "logo-html5": 62013,
  "logo-instagram": 62014,
  "logo-ionic": 61776,
  "logo-ionitron": 61777,
  "logo-javascript": 62015,
  "logo-linkedin": 62016,
  "logo-markdown": 62017,
  "logo-model-s": 61779,
  "logo-no-smoking": 61705,
  "logo-nodejs": 62018,
  "logo-npm": 61845,
  "logo-octocat": 62019,
  "logo-pinterest": 62020,
  "logo-playstation": 62021,
  "logo-polymer": 61790,
  "logo-python": 62022,
  "logo-reddit": 62023,
  "logo-rss": 62024,
  "logo-sass": 62025,
  "logo-skype": 62026,
  "logo-slack": 61707,
  "logo-snapchat": 62027,
  "logo-steam": 62028,
  "logo-tumblr": 62029,
  "logo-tux": 62126,
  "logo-twitch": 62127,
  "logo-twitter": 62128,
  "logo-usd": 62129,
  "logo-vimeo": 62148,
  "logo-vk": 61709,
  "logo-whatsapp": 62149,
  "logo-windows": 62255,
  "logo-wordpress": 62256,
  "logo-xbox": 62284,
  "logo-xing": 61711,
  "logo-yahoo": 62285,
  "logo-yen": 62286,
  "logo-youtube": 62287,
  "md-add": 62067,
  "md-add-circle": 62066,
  "md-add-circle-outline": 61784,
  "md-airplane": 61786,
  "md-alarm": 62068,
  "md-albums": 62069,
  "md-alert": 62070,
  "md-american-football": 62071,
  "md-analytics": 62072,
  "md-aperture": 62073,
  "md-apps": 62074,
  "md-appstore": 62075,
  "md-archive": 62076,
  "md-arrow-back": 62077,
  "md-arrow-down": 62078,
  "md-arrow-dropdown": 62080,
  "md-arrow-dropdown-circle": 62079,
  "md-arrow-dropleft": 62082,
  "md-arrow-dropleft-circle": 62081,
  "md-arrow-dropright": 62084,
  "md-arrow-dropright-circle": 62083,
  "md-arrow-dropup": 62086,
  "md-arrow-dropup-circle": 62085,
  "md-arrow-forward": 62087,
  "md-arrow-round-back": 62088,
  "md-arrow-round-down": 62089,
  "md-arrow-round-forward": 62090,
  "md-arrow-round-up": 62091,
  "md-arrow-up": 62092,
  "md-at": 62093,
  "md-attach": 62094,
  "md-backspace": 62095,
  "md-barcode": 62096,
  "md-baseball": 62097,
  "md-basket": 62098,
  "md-basketball": 62099,
  "md-battery-charging": 62100,
  "md-battery-dead": 62101,
  "md-battery-full": 62102,
  "md-beaker": 62103,
  "md-bed": 61792,
  "md-beer": 62104,
  "md-bicycle": 62105,
  "md-bluetooth": 62106,
  "md-boat": 62107,
  "md-body": 62108,
  "md-bonfire": 62109,
  "md-book": 62110,
  "md-bookmark": 62111,
  "md-bookmarks": 62112,
  "md-bowtie": 62113,
  "md-briefcase": 62114,
  "md-browsers": 62115,
  "md-brush": 62116,
  "md-bug": 62117,
  "md-build": 62118,
  "md-bulb": 62119,
  "md-bus": 62120,
  "md-business": 61860,
  "md-cafe": 62121,
  "md-calculator": 62122,
  "md-calendar": 62123,
  "md-call": 62124,
  "md-camera": 62125,
  "md-car": 62130,
  "md-card": 62131,
  "md-cart": 62132,
  "md-cash": 62133,
  "md-cellular": 61796,
  "md-chatboxes": 62134,
  "md-chatbubbles": 62135,
  "md-checkbox": 62137,
  "md-checkbox-outline": 62136,
  "md-checkmark": 62140,
  "md-checkmark-circle": 62139,
  "md-checkmark-circle-outline": 62138,
  "md-clipboard": 62141,
  "md-clock": 62142,
  "md-close": 62144,
  "md-close-circle": 62143,
  "md-close-circle-outline": 61798,
  "md-cloud": 62153,
  "md-cloud-circle": 62146,
  "md-cloud-done": 62147,
  "md-cloud-download": 62150,
  "md-cloud-outline": 62151,
  "md-cloud-upload": 62152,
  "md-cloudy": 62155,
  "md-cloudy-night": 62154,
  "md-code": 62158,
  "md-code-download": 62156,
  "md-code-working": 62157,
  "md-cog": 62159,
  "md-color-fill": 62160,
  "md-color-filter": 62161,
  "md-color-palette": 62162,
  "md-color-wand": 62163,
  "md-compass": 62164,
  "md-construct": 62165,
  "md-contact": 62166,
  "md-contacts": 62167,
  "md-contract": 62168,
  "md-contrast": 62169,
  "md-copy": 62170,
  "md-create": 62171,
  "md-crop": 62172,
  "md-cube": 62173,
  "md-cut": 62174,
  "md-desktop": 62175,
  "md-disc": 62176,
  "md-document": 62177,
  "md-done-all": 62178,
  "md-download": 62179,
  "md-easel": 62180,
  "md-egg": 62181,
  "md-exit": 62182,
  "md-expand": 62183,
  "md-eye": 62185,
  "md-eye-off": 62184,
  "md-fastforward": 62186,
  "md-female": 62187,
  "md-filing": 62188,
  "md-film": 62189,
  "md-finger-print": 62190,
  "md-fitness": 61868,
  "md-flag": 62191,
  "md-flame": 62192,
  "md-flash": 62193,
  "md-flash-off": 61801,
  "md-flashlight": 61803,
  "md-flask": 62194,
  "md-flower": 62195,
  "md-folder": 62197,
  "md-folder-open": 62196,
  "md-football": 62198,
  "md-funnel": 62199,
  "md-gift": 61849,
  "md-git-branch": 62202,
  "md-git-commit": 62203,
  "md-git-compare": 62204,
  "md-git-merge": 62205,
  "md-git-network": 62206,
  "md-git-pull-request": 62207,
  "md-glasses": 62208,
  "md-globe": 62209,
  "md-grid": 62210,
  "md-hammer": 62211,
  "md-hand": 62212,
  "md-happy": 62213,
  "md-headset": 62214,
  "md-heart": 62216,
  "md-heart-dislike": 61799,
  "md-heart-empty": 61857,
  "md-heart-half": 61858,
  "md-help": 62219,
  "md-help-buoy": 62217,
  "md-help-circle": 62218,
  "md-help-circle-outline": 61805,
  "md-home": 62220,
  "md-hourglass": 61713,
  "md-ice-cream": 62221,
  "md-image": 62222,
  "md-images": 62223,
  "md-infinite": 62224,
  "md-information": 62226,
  "md-information-circle": 62225,
  "md-information-circle-outline": 61807,
  "md-jet": 62229,
  "md-journal": 61837,
  "md-key": 62230,
  "md-keypad": 62231,
  "md-laptop": 62232,
  "md-leaf": 62233,
  "md-link": 61998,
  "md-list": 62235,
  "md-list-box": 62234,
  "md-locate": 62236,
  "md-lock": 62237,
  "md-log-in": 62238,
  "md-log-out": 62239,
  "md-magnet": 62240,
  "md-mail": 62242,
  "md-mail-open": 62241,
  "md-mail-unread": 61810,
  "md-male": 62243,
  "md-man": 62244,
  "md-map": 62245,
  "md-medal": 62246,
  "md-medical": 62247,
  "md-medkit": 62248,
  "md-megaphone": 62249,
  "md-menu": 62250,
  "md-mic": 62252,
  "md-mic-off": 62251,
  "md-microphone": 62253,
  "md-moon": 62254,
  "md-more": 61897,
  "md-move": 62257,
  "md-musical-note": 62258,
  "md-musical-notes": 62259,
  "md-navigate": 62260,
  "md-notifications": 62264,
  "md-notifications-off": 62262,
  "md-notifications-outline": 62263,
  "md-nuclear": 62265,
  "md-nutrition": 62266,
  "md-open": 62267,
  "md-options": 62268,
  "md-outlet": 62269,
  "md-paper": 62271,
  "md-paper-plane": 62270,
  "md-partly-sunny": 62272,
  "md-pause": 62273,
  "md-paw": 62274,
  "md-people": 62275,
  "md-person": 62277,
  "md-person-add": 62276,
  "md-phone-landscape": 62278,
  "md-phone-portrait": 62279,
  "md-photos": 62280,
  "md-pie": 62281,
  "md-pin": 62282,
  "md-pint": 62283,
  "md-pizza": 62292,
  "md-planet": 62294,
  "md-play": 62295,
  "md-play-circle": 61812,
  "md-podium": 62296,
  "md-power": 62297,
  "md-pricetag": 62298,
  "md-pricetags": 62299,
  "md-print": 62300,
  "md-pulse": 62301,
  "md-qr-scanner": 62302,
  "md-quote": 62303,
  "md-radio": 62306,
  "md-radio-button-off": 62304,
  "md-radio-button-on": 62305,
  "md-rainy": 62307,
  "md-recording": 62308,
  "md-redo": 62309,
  "md-refresh": 62310,
  "md-refresh-circle": 61992,
  "md-remove": 62312,
  "md-remove-circle": 62311,
  "md-remove-circle-outline": 61814,
  "md-reorder": 62313,
  "md-repeat": 62314,
  "md-resize": 62315,
  "md-restaurant": 62316,
  "md-return-left": 62317,
  "md-return-right": 62318,
  "md-reverse-camera": 62319,
  "md-rewind": 62320,
  "md-ribbon": 62321,
  "md-rocket": 61817,
  "md-rose": 62322,
  "md-sad": 62323,
  "md-save": 61865,
  "md-school": 62324,
  "md-search": 62325,
  "md-send": 62326,
  "md-settings": 62327,
  "md-share": 62329,
  "md-share-alt": 62328,
  "md-shirt": 62330,
  "md-shuffle": 62331,
  "md-skip-backward": 62332,
  "md-skip-forward": 62333,
  "md-snow": 62334,
  "md-speedometer": 62335,
  "md-square": 62337,
  "md-square-outline": 62336,
  "md-star": 62340,
  "md-star-half": 62338,
  "md-star-outline": 62339,
  "md-stats": 62341,
  "md-stopwatch": 62342,
  "md-subway": 62343,
  "md-sunny": 62344,
  "md-swap": 62345,
  "md-switch": 62346,
  "md-sync": 62347,
  "md-tablet-landscape": 62348,
  "md-tablet-portrait": 62349,
  "md-tennisball": 62350,
  "md-text": 62351,
  "md-thermometer": 62352,
  "md-thumbs-down": 62353,
  "md-thumbs-up": 62354,
  "md-thunderstorm": 62355,
  "md-time": 62356,
  "md-timer": 62357,
  "md-today": 61821,
  "md-train": 62358,
  "md-transgender": 62359,
  "md-trash": 62360,
  "md-trending-down": 62361,
  "md-trending-up": 62362,
  "md-trophy": 62363,
  "md-tv": 61823,
  "md-umbrella": 62364,
  "md-undo": 62365,
  "md-unlock": 62366,
  "md-videocam": 62367,
  "md-volume-high": 61731,
  "md-volume-low": 61745,
  "md-volume-mute": 62369,
  "md-volume-off": 62370,
  "md-walk": 62372,
  "md-wallet": 61839,
  "md-warning": 62373,
  "md-watch": 62374,
  "md-water": 62375,
  "md-wifi": 62376,
  "md-wine": 62377,
  "md-woman": 62378
};
},775,[],"node_modules/react-native-vector-icons/glyphmaps/Ionicons.json");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _regenerator = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/regenerator"));

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf3 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "@babel/runtime/helpers/inherits"));

  var _react = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "react"));

  var _themes = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "../config/themes"));

  var _reactNative = _$$_REQUIRE(_dependencyMap[9], "react-native");

  var _jsxFileName = "/home/flummi/dev/f0ckapp/src/routes/home.js";

  var HomeScreen = function (_React$Component) {
    (0, _inherits2.default)(HomeScreen, _React$Component);

    function HomeScreen() {
      var _getPrototypeOf2;

      var _this;

      (0, _classCallCheck2.default)(this, HomeScreen);

      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
        args[_key] = arguments[_key];
      }

      _this = (0, _possibleConstructorReturn2.default)(this, (_getPrototypeOf2 = (0, _getPrototypeOf3.default)(HomeScreen)).call.apply(_getPrototypeOf2, [this].concat(args)));
      _this.state = {
        dataSource: [],
        columns: 1,
        debug: "0.00px"
      };

      _this.handleScroll = function (e) {
        var el = e.nativeEvent;
        return;

        _this.setState({
          debug: el.contentOffset.y.toFixed(2) + "px"
        });
      };

      _this.handleLayout = function _callee(e) {
        var h, w, columns, rows, eps, res, items;
        return _regenerator.default.async(function _callee$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                console.log(e.nativeEvent.layout);
                h = e.nativeEvent.layout.height;
                w = e.nativeEvent.layout.width;
                columns = ~~(w / 128);
                rows = ~~(h / 128);
                eps = 200;
                _context.t0 = _regenerator.default;
                _context.next = 9;
                return _regenerator.default.awrap(fetch("https://dev.f0ck.me/api/p?eps=" + eps));

              case 9:
                _context.t1 = _context.sent.json();
                _context.next = 12;
                return _context.t0.awrap.call(_context.t0, _context.t1);

              case 12:
                res = _context.sent;
                items = res.items.map(function (e) {
                  return {
                    id: e.id,
                    src: "https://f0ck.me/t/" + e.id + ".png"
                  };
                });

                _this.setState({
                  dataSource: items,
                  columns: columns,
                  debug: "c: " + columns + " r: " + rows + " eps: " + eps
                });

              case 15:
              case "end":
                return _context.stop();
            }
          }
        });
      };

      return _this;
    }

    (0, _createClass2.default)(HomeScreen, [{
      key: "componentDidMount",
      value: function componentDidMount() {
        return _regenerator.default.async(function componentDidMount$(_context2) {
          while (1) {
            switch (_context2.prev = _context2.next) {
              case 0:
                return _context2.abrupt("return", true);

              case 1:
              case "end":
                return _context2.stop();
            }
          }
        });
      }
    }, {
      key: "render",
      value: function render() {
        return _react.default.createElement(_reactNative.View, {
          style: {
            flex: 1,
            backgroundColor: _themes.default.background
          },
          __source: {
            fileName: _jsxFileName,
            lineNumber: 49
          }
        }, _react.default.createElement(_reactNative.Image, {
          source: {
            uri: _themes.default.logo
          },
          style: {
            width: 112,
            height: 28,
            marginTop: 8
          },
          __source: {
            fileName: _jsxFileName,
            lineNumber: 50
          }
        }), _react.default.createElement(_reactNative.Text, {
          style: {
            color: "#fff",
            fontWeight: "bold",
            textAlign: "right"
          },
          __source: {
            fileName: _jsxFileName,
            lineNumber: 51
          }
        }, this.state.debug), _react.default.createElement(_reactNative.FlatList, {
          data: this.state.dataSource,
          onScroll: this.handleScroll,
          onLayout: this.handleLayout,
          renderItem: function renderItem(_ref) {
            var item = _ref.item;
            return _react.default.createElement(_reactNative.View, {
              style: {
                flex: 1,
                flexDirection: "column",
                margin: 5
              },
              __source: {
                fileName: _jsxFileName,
                lineNumber: 58
              }
            }, _react.default.createElement(_reactNative.TouchableOpacity, {
              key: item.id,
              style: {
                flex: 1
              },
              __source: {
                fileName: _jsxFileName,
                lineNumber: 59
              }
            }, _react.default.createElement(_reactNative.Image, {
              style: {
                height: 128,
                width: 128
              },
              source: {
                uri: item.src
              },
              __source: {
                fileName: _jsxFileName,
                lineNumber: 60
              }
            })));
          },
          key: this.state.columns,
          numColumns: this.state.columns,
          keyExtractor: function keyExtractor(item, index) {
            return index.toString();
          },
          __source: {
            fileName: _jsxFileName,
            lineNumber: 53
          }
        }));
      }
    }]);
    return HomeScreen;
  }(_react.default.Component);

  exports.default = HomeScreen;
},776,[1,103,24,25,32,34,37,54,777,2],"src/routes/home.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _defineProperty2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/defineProperty"));

  var _syncStorage = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "sync-storage"));

  function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

  function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

  var global = {
    foreground: "#9f0"
  };
  var themes = {
    light: {
      background: "#fff"
    },
    dark: {
      logo: "https://f0ck.me/s/img/f0ckme.png",
      background: "#212529"
    }
  };

  var theme = _objectSpread({}, themes[_syncStorage.default.get("theme") ? _syncStorage.default.get("theme") : "dark"], {}, global);

  var _default = theme;
  exports.default = _default;
},777,[1,46,778],"src/config/themes.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _slicedToArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/slicedToArray"));

  var _toConsumableArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/toConsumableArray"));

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/createClass"));

  var _asyncStorage = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@react-native-community/async-storage"));

  var _handleError = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "./helpers/handleError"));

  var SyncStorage = function () {
    function SyncStorage() {
      (0, _classCallCheck2.default)(this, SyncStorage);
      this.data = new Map();
      this.loading = true;
    }

    (0, _createClass2.default)(SyncStorage, [{
      key: "init",
      value: function init() {
        var _this = this;

        return _asyncStorage.default.getAllKeys().then(function (keys) {
          return _asyncStorage.default.multiGet(keys).then(function (data) {
            data.forEach(_this.saveItem.bind(_this));
            return (0, _toConsumableArray2.default)(_this.data);
          });
        });
      }
    }, {
      key: "get",
      value: function get(key) {
        return this.data.get(key);
      }
    }, {
      key: "set",
      value: function set(key, value) {
        if (!key) return (0, _handleError.default)('set', 'a key');
        this.data.set(key, value);
        return _asyncStorage.default.setItem(key, JSON.stringify(value));
      }
    }, {
      key: "remove",
      value: function remove(key) {
        if (!key) return (0, _handleError.default)('remove', 'a key');
        this.data.delete(key);
        return _asyncStorage.default.removeItem(key);
      }
    }, {
      key: "saveItem",
      value: function saveItem(item) {
        var value;

        try {
          value = JSON.parse(item[1]);
        } catch (e) {
          var _item = (0, _slicedToArray2.default)(item, 2);

          value = _item[1];
        }

        this.data.set(item[0], value);
        this.loading = false;
      }
    }, {
      key: "getAllKeys",
      value: function getAllKeys() {
        return Array.from(this.data.keys());
      }
    }]);
    return SyncStorage;
  }();

  var syncStorage = new SyncStorage();
  var _default = syncStorage;
  exports.default = _default;
},778,[1,14,20,24,25,779,782],"node_modules/sync-storage/src/index.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  Object.defineProperty(exports, "useAsyncStorage", {
    enumerable: true,
    get: function get() {
      return _hooks.useAsyncStorage;
    }
  });
  exports.default = void 0;

  var _AsyncStorage = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./AsyncStorage"));

  var _hooks = _$$_REQUIRE(_dependencyMap[2], "./hooks");

  var _default = _AsyncStorage.default;
  exports.default = _default;
},779,[1,780,781],"node_modules/@react-native-community/async-storage/lib/index.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  'use strict';

  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _slicedToArray2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/slicedToArray"));

  var _require = _$$_REQUIRE(_dependencyMap[2], "react-native"),
      NativeModules = _require.NativeModules;

  var RCTAsyncStorage = NativeModules.PlatformLocalStorage || NativeModules.RNC_AsyncSQLiteDBStorage || NativeModules.RNCAsyncStorage;

  if (!RCTAsyncStorage) {
    throw new Error("[@RNC/AsyncStorage]: NativeModule: AsyncStorage is null.\n\nTo fix this issue try these steps:\n\n  \u2022 Run `react-native link @react-native-community/async-storage` in the project root.\n\n  \u2022 Rebuild and restart the app.\n\n  \u2022 Run the packager with `--clearCache` flag.\n\n  \u2022 If you are using CocoaPods on iOS, run `pod install` in the `ios` directory and then rebuild and re-run the app.\n\n  \u2022 If this happens while testing with Jest, check out docs how to integrate AsyncStorage with it: https://github.com/react-native-community/async-storage/blob/LEGACY/docs/Jest-integration.md\n\nIf none of these fix the issue, please open an issue on the Github repository: https://github.com/react-native-community/react-native-async-storage/issues \n");
  }

  function checkValidInput(usedKey, value) {
    var isValuePassed = arguments.length > 1;

    if (typeof usedKey !== 'string') {
      console.warn("[AsyncStorage] Using " + typeof usedKey + " type for key is not supported. This can lead to unexpected behavior/errors. Use string instead.\nKey passed: " + usedKey + "\n");
    }

    if (isValuePassed && typeof value !== 'string') {
      if (value == null) {
        throw new Error("[AsyncStorage] Passing null/undefined as value is not supported. If you want to remove value, Use .remove method instead.\nPassed value: " + value + "\nPassed key: " + usedKey + "\n");
      } else {
        console.warn("[AsyncStorage] The value for key \"" + usedKey + "\" is not a string. This can lead to unexpected behavior/errors. Consider stringifying it.\nPassed value: " + value + "\nPassed key: " + usedKey + "\n");
      }
    }
  }

  var AsyncStorage = {
    _getRequests: [],
    _getKeys: [],
    _immediate: null,
    getItem: function getItem(key, callback) {
      return new Promise(function (resolve, reject) {
        checkValidInput(key);
        RCTAsyncStorage.multiGet([key], function (errors, result) {
          var value = result && result[0] && result[0][1] ? result[0][1] : null;
          var errs = convertErrors(errors);
          callback && callback(errs && errs[0], value);

          if (errs) {
            reject(errs[0]);
          } else {
            resolve(value);
          }
        });
      });
    },
    setItem: function setItem(key, value, callback) {
      return new Promise(function (resolve, reject) {
        checkValidInput(key, value);
        RCTAsyncStorage.multiSet([[key, value]], function (errors) {
          var errs = convertErrors(errors);
          callback && callback(errs && errs[0]);

          if (errs) {
            reject(errs[0]);
          } else {
            resolve(null);
          }
        });
      });
    },
    removeItem: function removeItem(key, callback) {
      return new Promise(function (resolve, reject) {
        checkValidInput(key);
        RCTAsyncStorage.multiRemove([key], function (errors) {
          var errs = convertErrors(errors);
          callback && callback(errs && errs[0]);

          if (errs) {
            reject(errs[0]);
          } else {
            resolve(null);
          }
        });
      });
    },
    mergeItem: function mergeItem(key, value, callback) {
      return new Promise(function (resolve, reject) {
        checkValidInput(key, value);
        RCTAsyncStorage.multiMerge([[key, value]], function (errors) {
          var errs = convertErrors(errors);
          callback && callback(errs && errs[0]);

          if (errs) {
            reject(errs[0]);
          } else {
            resolve(null);
          }
        });
      });
    },
    clear: function clear(callback) {
      return new Promise(function (resolve, reject) {
        RCTAsyncStorage.clear(function (error) {
          var err = convertError(error);
          callback && callback(err);

          if (err) {
            reject(err);
          } else {
            resolve(null);
          }
        });
      });
    },
    getAllKeys: function getAllKeys(callback) {
      return new Promise(function (resolve, reject) {
        RCTAsyncStorage.getAllKeys(function (error, keys) {
          var err = convertError(error);
          callback && callback(err, keys);

          if (err) {
            reject(err);
          } else {
            resolve(keys);
          }
        });
      });
    },
    flushGetRequests: function flushGetRequests() {
      var getRequests = this._getRequests;
      var getKeys = this._getKeys;
      this._getRequests = [];
      this._getKeys = [];
      RCTAsyncStorage.multiGet(getKeys, function (errors, result) {
        var map = {};
        result && result.forEach(function (_ref) {
          var _ref2 = (0, _slicedToArray2.default)(_ref, 2),
              key = _ref2[0],
              value = _ref2[1];

          map[key] = value;
          return value;
        });
        var reqLength = getRequests.length;

        for (var i = 0; i < reqLength; i++) {
          var request = getRequests[i];
          var requestKeys = request.keys;
          var requestResult = requestKeys.map(function (key) {
            return [key, map[key]];
          });
          request.callback && request.callback(null, requestResult);
          request.resolve && request.resolve(requestResult);
        }
      });
    },
    multiGet: function multiGet(keys, callback) {
      var _this = this;

      if (!this._immediate) {
        this._immediate = setImmediate(function () {
          _this._immediate = null;

          _this.flushGetRequests();
        });
      }

      var getRequest = {
        keys: keys,
        callback: callback,
        keyIndex: this._getKeys.length,
        resolve: null,
        reject: null
      };
      var promiseResult = new Promise(function (resolve, reject) {
        getRequest.resolve = resolve;
        getRequest.reject = reject;
      });

      this._getRequests.push(getRequest);

      keys.forEach(function (key) {
        if (_this._getKeys.indexOf(key) === -1) {
          _this._getKeys.push(key);
        }
      });
      return promiseResult;
    },
    multiSet: function multiSet(keyValuePairs, callback) {
      return new Promise(function (resolve, reject) {
        keyValuePairs.forEach(function (_ref3) {
          var _ref4 = (0, _slicedToArray2.default)(_ref3, 2),
              key = _ref4[0],
              value = _ref4[1];

          checkValidInput(key, value);
        });
        RCTAsyncStorage.multiSet(keyValuePairs, function (errors) {
          var error = convertErrors(errors);
          callback && callback(error);

          if (error) {
            reject(error);
          } else {
            resolve(null);
          }
        });
      });
    },
    multiRemove: function multiRemove(keys, callback) {
      return new Promise(function (resolve, reject) {
        keys.forEach(function (key) {
          return checkValidInput(key);
        });
        RCTAsyncStorage.multiRemove(keys, function (errors) {
          var error = convertErrors(errors);
          callback && callback(error);

          if (error) {
            reject(error);
          } else {
            resolve(null);
          }
        });
      });
    },
    multiMerge: function multiMerge(keyValuePairs, callback) {
      return new Promise(function (resolve, reject) {
        RCTAsyncStorage.multiMerge(keyValuePairs, function (errors) {
          var error = convertErrors(errors);
          callback && callback(error);

          if (error) {
            reject(error);
          } else {
            resolve(null);
          }
        });
      });
    }
  };

  if (!RCTAsyncStorage.multiMerge) {
    delete AsyncStorage.mergeItem;
    delete AsyncStorage.multiMerge;
  }

  function convertErrors(errs) {
    if (!errs) {
      return null;
    }

    return (Array.isArray(errs) ? errs : [errs]).map(function (e) {
      return convertError(e);
    });
  }

  function convertError(error) {
    if (!error) {
      return null;
    }

    var out = new Error(error.message);
    out.key = error.key;
    return out;
  }

  var _default = AsyncStorage;
  exports.default = _default;
},780,[1,14,2],"node_modules/@react-native-community/async-storage/lib/AsyncStorage.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.useAsyncStorage = useAsyncStorage;

  var _AsyncStorage = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./AsyncStorage"));

  function useAsyncStorage(key) {
    return {
      getItem: function getItem() {
        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
          args[_key] = arguments[_key];
        }

        return _AsyncStorage.default.getItem.apply(_AsyncStorage.default, [key].concat(args));
      },
      setItem: function setItem() {
        for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
          args[_key2] = arguments[_key2];
        }

        return _AsyncStorage.default.setItem.apply(_AsyncStorage.default, [key].concat(args));
      },
      mergeItem: function mergeItem() {
        for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
          args[_key3] = arguments[_key3];
        }

        return _AsyncStorage.default.mergeItem.apply(_AsyncStorage.default, [key].concat(args));
      },
      removeItem: function removeItem() {
        for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
          args[_key4] = arguments[_key4];
        }

        return _AsyncStorage.default.removeItem.apply(_AsyncStorage.default, [key].concat(args));
      }
    };
  }
},781,[1,780],"node_modules/@react-native-community/async-storage/lib/hooks.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  function handleError(func, param) {
    var message;

    if (!param) {
      message = func;
    } else {
      message = func + "() requires at least " + param + " as its first parameter.";
    }

    console.warn(message);
    return Promise.reject(message);
  }

  var _default = handleError;
  exports.default = _default;
},782,[],"node_modules/sync-storage/src/helpers/handleError.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits"));

  var _react = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "react"));

  var _themes = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "../config/themes"));

  var _reactNative = _$$_REQUIRE(_dependencyMap[8], "react-native");

  var _jsxFileName = "/home/flummi/dev/f0ckapp/src/routes/help.js";

  var HelpScreen = function (_React$Component) {
    (0, _inherits2.default)(HelpScreen, _React$Component);

    function HelpScreen() {
      (0, _classCallCheck2.default)(this, HelpScreen);
      return (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(HelpScreen).apply(this, arguments));
    }

    (0, _createClass2.default)(HelpScreen, [{
      key: "render",
      value: function render() {
        return _react.default.createElement(_reactNative.View, {
          style: {
            flex: 1,
            backgroundColor: _themes.default.background
          },
          __source: {
            fileName: _jsxFileName,
            lineNumber: 10
          }
        }, _react.default.createElement(_reactNative.Image, {
          source: {
            uri: _themes.default.logo
          },
          style: {
            width: 112,
            height: 28,
            marginTop: 16
          },
          __source: {
            fileName: _jsxFileName,
            lineNumber: 11
          }
        }), _react.default.createElement(_reactNative.Text, {
          __source: {
            fileName: _jsxFileName,
            lineNumber: 12
          }
        }, "irc.n0xy.net +6697 (ssl only) #f0ck More information: n0xy.net IRC Rules Constitution: \xA7 1 The dignity of the IRCd is inviolable. \xA7 2 The distribution of Child Pornography is strictly prohibited in any of our networks and will lead to an immediate ban. \xA7 3 Do not attack users in this network in any way, shape, or form. \xA7 4 Do not transmit any personal/financial information without permission. \xA7 5 Do not share any malware on this network. f0ck specific rules: Animal cruelty is forbidden and will lead to an immediate ban how the f0ck to f0ck, you ask? f0ck will f0ck any media link posted in the channel ending with: jpg|gif|png|webm|mp3|mp4|ogg|flac If you don't want f0ck to f0ck it put !ignore behind your link. Example: https://retard-journal.com/stupidshit.png !ignore f0ck will only f0ck media links with the maximum size of 80MB"));
      }
    }]);
    return HelpScreen;
  }(_react.default.Component);

  exports.default = HelpScreen;
},783,[1,24,25,32,34,37,54,777,2],"src/routes/help.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits"));

  var _react = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "react"));

  var _themes = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "../config/themes"));

  var _reactNative = _$$_REQUIRE(_dependencyMap[8], "react-native");

  var _jsxFileName = "/home/flummi/dev/f0ckapp/src/routes/contact.js";

  var ContactScreen = function (_React$Component) {
    (0, _inherits2.default)(ContactScreen, _React$Component);

    function ContactScreen() {
      (0, _classCallCheck2.default)(this, ContactScreen);
      return (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(ContactScreen).apply(this, arguments));
    }

    (0, _createClass2.default)(ContactScreen, [{
      key: "render",
      value: function render() {
        return _react.default.createElement(_reactNative.View, {
          style: {
            flex: 1,
            backgroundColor: _themes.default.background
          },
          __source: {
            fileName: _jsxFileName,
            lineNumber: 10
          }
        }, _react.default.createElement(_reactNative.Image, {
          source: {
            uri: _themes.default.logo
          },
          style: {
            width: 112,
            height: 28,
            marginTop: 16
          },
          __source: {
            fileName: _jsxFileName,
            lineNumber: 11
          }
        }), _react.default.createElement(_reactNative.Text, {
          __source: {
            fileName: _jsxFileName,
            lineNumber: 12
          }
        }, "Got a problem? We have the answer: admin@f0ck.space"));
      }
    }]);
    return ContactScreen;
  }(_react.default.Component);

  exports.default = ContactScreen;
},784,[1,24,25,32,34,37,54,777,2],"src/routes/contact.js");
__d(function (global, _$$_REQUIRE, _$$_IMPORT_DEFAULT, _$$_IMPORT_ALL, module, exports, _dependencyMap) {
  var _interopRequireDefault = _$$_REQUIRE(_dependencyMap[0], "@babel/runtime/helpers/interopRequireDefault");

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _classCallCheck2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "@babel/runtime/helpers/classCallCheck"));

  var _createClass2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "@babel/runtime/helpers/createClass"));

  var _possibleConstructorReturn2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[3], "@babel/runtime/helpers/possibleConstructorReturn"));

  var _getPrototypeOf2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "@babel/runtime/helpers/getPrototypeOf"));

  var _inherits2 = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[5], "@babel/runtime/helpers/inherits"));

  var _react = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[6], "react"));

  var _themes = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "../config/themes"));

  var _syncStorage = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[8], "sync-storage"));

  var _reactNative = _$$_REQUIRE(_dependencyMap[9], "react-native");

  var _jsxFileName = "/home/flummi/dev/f0ckapp/src/routes/settings.js";

  var _theme = _syncStorage.default.get("theme") === "dark";

  var SettingScreen = function (_React$Component) {
    (0, _inherits2.default)(SettingScreen, _React$Component);

    function SettingScreen() {
      (0, _classCallCheck2.default)(this, SettingScreen);
      return (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(SettingScreen).apply(this, arguments));
    }

    (0, _createClass2.default)(SettingScreen, [{
      key: "render",
      value: function render() {
        return _react.default.createElement(_reactNative.View, {
          style: {
            flex: 1,
            backgroundColor: _themes.default.background
          },
          __source: {
            fileName: _jsxFileName,
            lineNumber: 13
          }
        }, _react.default.createElement(_reactNative.Image, {
          source: {
            uri: _themes.default.logo
          },
          style: {
            width: 112,
            height: 28,
            marginTop: 16
          },
          __source: {
            fileName: _jsxFileName,
            lineNumber: 14
          }
        }), _react.default.createElement(_reactNative.Text, {
          __source: {
            fileName: _jsxFileName,
            lineNumber: 15
          }
        }, "Dark?"), _react.default.createElement(_reactNative.Switch, {
          value: "{_theme}",
          __source: {
            fileName: _jsxFileName,
            lineNumber: 16
          }
        }));
      }
    }]);
    return SettingScreen;
  }(_react.default.Component);

  exports.default = SettingScreen;
},785,[1,24,25,32,34,37,54,777,778,2],"src/routes/settings.js");
__d(function(global, require, _aUnused, _bUnused, module, exports, _cUnused) {
  module.exports = {
  "name": "f0ckapp",
  "displayName": "f0ckapp"
};
},786,[],"app.json");
__r(91);
__r(0);
//# sourceMappingURL=index.map