react-native-video/examples/embed-and-fullscreen/.vscode/.react/index.ios.bundle

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

  var PRINT_REQUIRE_PATHS = false;
  global.require = metroRequire;
  global.__d = define;
  var modules = typeof __NUM_MODULES__ === 'number' ? Array(__NUM_MODULES__ | 0) : Object.create(null);

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

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

        if (inverseDependencies) {
          global.__accept(moduleId, factory, dependencyMap, inverseDependencies);
        } else {
          console.warn("Trying to define twice module ID " + moduleId + " in the same bundle");
        }
      }

      return;
    }

    modules[moduleId] = {
      dependencyMap: dependencyMap,
      exports: undefined,
      factory: factory,
      hasError: false,
      isInitialized: false
    };

    if (PRINT_REQUIRE_PATHS) {
      var path = arguments[4];

      if (path) {
        modules[moduleId].path = path;
      } else {
        throw new Error('path not set on module with PRINT_REQUIRE_PATHS true. Make sure ' + 'PASS_MODULE_PATHS_TO_DEFINE is true and restart Metro or rebuild bundle');
      }
    }

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

      if (verboseName) {
        modules[moduleId].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;
    var module = modules[moduleIdReallyIsNumber];
    return module && module.isInitialized ? module.exports : guardedLoadModule(moduleIdReallyIsNumber, module);
  }

  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;

  function loadModuleImplementation(moduleId, module) {
    var nativeRequire = global.nativeRequire;

    if (!module && nativeRequire) {
      var _unpackModuleId = unpackModuleId(moduleId);

      var segmentId = _unpackModuleId.segmentId,
          localId = _unpackModuleId.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;
    }

    module.isInitialized = true;
    var exports = module.exports = {};
    var _module = module;
    var factory = _module.factory,
        dependencyMap = _module.dependencyMap;

    try {
      if (PRINT_REQUIRE_PATHS) {
        console.log("require file path " + (module.path || 'unknown'));
      }

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

      var moduleObject = {
        exports: exports
      };

      if (__DEV__ && module.hot) {
        moduleObject.hot = module.hot;
      }

      factory(global, metroRequire, moduleObject, exports, dependencyMap);

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

      if (__DEV__) {
        Systrace.endEvent();
      }

      return module.exports = moduleObject.exports;
    } catch (e) {
      module.hasError = true;
      module.error = e;
      module.isInitialized = false;
      module.exports = undefined;
      throw e;
    }
  }

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

    if (__DEV__) {
      message += 'If you are sure the module is there, try restarting Metro Bundler. ' + 'You may also want to run `yarn`, or `npm install` (depending on your environment).';
    }

    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,
        accept: function accept(callback) {
          hot.acceptCallback = callback;
        },
        disposeCallback: null,
        dispose: function dispose(callback) {
          hot.disposeCallback = callback;
        }
      };
      return hot;
    };

    var metroAcceptAll = function metroAcceptAll(dependentModules, inverseDependencies, patchedModules) {
      if (!dependentModules || dependentModules.length === 0) {
        return true;
      }

      var notAccepted = dependentModules.filter(function (module) {
        return !metroAccept(module, undefined, undefined, inverseDependencies, patchedModules);
      });
      var parents = [];

      for (var i = 0; i < notAccepted.length; i++) {
        if (inverseDependencies[notAccepted[i]].length === 0) {
          return false;
        }

        parents.push.apply(parents, inverseDependencies[notAccepted[i]]);
      }

      return parents.length == 0;
    };

    var metroAccept = function metroAccept(id, factory, dependencyMap, inverseDependencies) {
      var patchedModules = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : {};

      if (id in patchedModules) {
        return true;
      }

      patchedModules[id] = true;
      var mod = modules[id];

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

      var hot = mod.hot;

      if (!hot) {
        console.warn('Cannot accept module because Hot Module Replacement ' + 'API was not installed.');
        return false;
      }

      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.isInitialized = false;
      metroRequire(id);

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

      if (!inverseDependencies) {
        throw new Error('Undefined `inverseDependencies`');
      }

      return metroAcceptAll(inverseDependencies[id], inverseDependencies, patchedModules);
    };

    global.__accept = metroAccept;
  }
})(this);
(function (global) {
  Object.assign = function (target, sources) {
    if (__DEV__) {
      if (target == null) {
        throw new TypeError('Object.assign target cannot be null or undefined');
      }

      if (typeof target !== 'object' && typeof target !== 'function') {
        throw new TypeError('In this environment the target of assign MUST be an object. ' + 'This error is a performance optimization and not spec compliant.');
      }
    }

    for (var nextIndex = 1; nextIndex < arguments.length; nextIndex++) {
      var nextSource = arguments[nextIndex];

      if (nextSource == null) {
        continue;
      }

      if (__DEV__) {
        if (typeof nextSource !== 'object' && typeof nextSource !== 'function') {
          throw new TypeError('In this environment the sources for assign MUST be an object. ' + 'This error is a performance optimization and not spec compliant.');
        }
      }

      for (var key in nextSource) {
        if (__DEV__) {
          var hasOwnProperty = Object.prototype.hasOwnProperty;

          if (!hasOwnProperty.call(nextSource, key)) {
            throw new TypeError('One of the sources for assign has an enumerable key on the ' + 'prototype chain. Are you trying to assign a prototype property? ' + "We don't allow it, as this is an edge case that we do not support. " + 'This error is a performance optimization and not spec compliant.');
          }
        }

        target[key] = nextSource[key];
      }
    }

    return target;
  };
})(this);
(function (global) {
  var inspect = function () {
    function inspect(obj, opts) {
      var ctx = {
        seen: [],
        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) {
      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 isPrimitive(arg) {
      return arg === null || typeof arg === 'boolean' || typeof arg === 'number' || typeof arg === 'string' || typeof arg === 'symbol' || typeof arg === 'undefined';
    }

    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);
      }

      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);
  }

  if (global.nativeLoggingHook) {
    var originalConsole = global.console;
    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
    };

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

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

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

        if (originalConsole[methodName]) {
          console[methodName] = function () {
            originalConsole[methodName].apply(originalConsole, arguments);
            reactNativeMethod.apply(console, 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
    };
  }
})(this);
(function (global) {
  var _inGuard = 0;

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

  var ErrorUtils = {
    setGlobalHandler: function setGlobalHandler(fun) {
      _globalHandler = fun;
    },
    getGlobalHandler: function getGlobalHandler() {
      return _globalHandler;
    },
    reportError: function reportError(error) {
      _globalHandler && _globalHandler(error);
    },
    reportFatalError: function reportFatalError(error) {
      _globalHandler && _globalHandler(error, true);
    },
    applyWithGuard: function applyWithGuard(fun, context, args) {
      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) {
      if (typeof fun !== 'function') {
        console.warn('A function must be passed to ErrorUtils.guard, got ', fun);
        return null;
      }

      name = name || fun.name || '<generated guard>';

      function guarded() {
        return ErrorUtils.applyWithGuard(fun, context || this, arguments, null, name);
      }

      return guarded;
    }
  };
  global.ErrorUtils = ErrorUtils;
})(this);
(function (global) {
  if (Number.EPSILON === undefined) {
    Object.defineProperty(Number, 'EPSILON', {
      value: Math.pow(2, -52)
    });
  }

  if (Number.MAX_SAFE_INTEGER === undefined) {
    Object.defineProperty(Number, 'MAX_SAFE_INTEGER', {
      value: Math.pow(2, 53) - 1
    });
  }

  if (Number.MIN_SAFE_INTEGER === undefined) {
    Object.defineProperty(Number, 'MIN_SAFE_INTEGER', {
      value: -(Math.pow(2, 53) - 1)
    });
  }

  if (!Number.isNaN) {
    var globalIsNaN = global.isNaN;
    Object.defineProperty(Number, 'isNaN', {
      configurable: true,
      enumerable: false,
      value: function isNaN(value) {
        return typeof value === 'number' && globalIsNaN(value);
      },
      writable: true
    });
  }
})(this);
(function (global) {
  if (!String.prototype.startsWith) {
    String.prototype.startsWith = function (search) {
      'use strict';

      if (this == null) {
        throw TypeError();
      }

      var string = String(this);
      var pos = arguments.length > 1 ? Number(arguments[1]) || 0 : 0;
      var start = Math.min(Math.max(pos, 0), string.length);
      return string.indexOf(String(search), pos) === start;
    };
  }

  if (!String.prototype.endsWith) {
    String.prototype.endsWith = function (search) {
      'use strict';

      if (this == null) {
        throw TypeError();
      }

      var string = String(this);
      var stringLength = string.length;
      var searchString = String(search);
      var pos = arguments.length > 1 ? Number(arguments[1]) || 0 : stringLength;
      var end = Math.min(Math.max(pos, 0), stringLength);
      var start = end - searchString.length;

      if (start < 0) {
        return false;
      }

      return string.lastIndexOf(searchString, start) === start;
    };
  }

  if (!String.prototype.repeat) {
    String.prototype.repeat = function (count) {
      'use strict';

      if (this == null) {
        throw TypeError();
      }

      var string = String(this);
      count = Number(count) || 0;

      if (count < 0 || count === Infinity) {
        throw RangeError();
      }

      if (count === 1) {
        return string;
      }

      var result = '';

      while (count) {
        if (count & 1) {
          result += string;
        }

        if (count >>= 1) {
          string += string;
        }
      }

      return result;
    };
  }

  if (!String.prototype.includes) {
    String.prototype.includes = function (search, start) {
      'use strict';

      if (typeof start !== 'number') {
        start = 0;
      }

      if (start + search.length > this.length) {
        return false;
      } else {
        return this.indexOf(search, start) !== -1;
      }
    };
  }

  if (!String.prototype.codePointAt) {
    String.prototype.codePointAt = function (position) {
      if (this == null) {
        throw TypeError();
      }

      var string = String(this);
      var size = string.length;
      var index = position ? Number(position) : 0;

      if (Number.isNaN(index)) {
        index = 0;
      }

      if (index < 0 || index >= size) {
        return undefined;
      }

      var first = string.charCodeAt(index);
      var second;

      if (first >= 0xd800 && first <= 0xdbff && size > index + 1) {
          second = string.charCodeAt(index + 1);

          if (second >= 0xdc00 && second <= 0xdfff) {
            return (first - 0xd800) * 0x400 + second - 0xdc00 + 0x10000;
          }
        }

      return first;
    };
  }
})(this);
(function (global) {
  function findIndex(predicate, context) {
    if (this == null) {
      throw new TypeError('Array.prototype.findIndex called on null or undefined');
    }

    if (typeof predicate !== 'function') {
      throw new TypeError('predicate must be a function');
    }

    var list = Object(this);
    var length = list.length >>> 0;

    for (var i = 0; i < length; i++) {
      if (predicate.call(context, list[i], i, list)) {
        return i;
      }
    }

    return -1;
  }

  if (!Array.prototype.findIndex) {
    Object.defineProperty(Array.prototype, 'findIndex', {
      enumerable: false,
      writable: true,
      configurable: true,
      value: findIndex
    });
  }

  if (!Array.prototype.find) {
    Object.defineProperty(Array.prototype, 'find', {
      enumerable: false,
      writable: true,
      configurable: true,
      value: function value(predicate, context) {
        if (this == null) {
          throw new TypeError('Array.prototype.find called on null or undefined');
        }

        var index = findIndex.call(this, predicate, context);
        return index === -1 ? undefined : this[index];
      }
    });
  }

  if (!Array.prototype.includes) {
    Object.defineProperty(Array.prototype, 'includes', {
      enumerable: false,
      writable: true,
      configurable: true,
      value: function value(searchElement) {
        var O = Object(this);
        var len = parseInt(O.length) || 0;

        if (len === 0) {
          return false;
        }

        var n = parseInt(arguments[1]) || 0;
        var k;

        if (n >= 0) {
          k = n;
        } else {
          k = len + n;

          if (k < 0) {
            k = 0;
          }
        }

        var currentElement;

        while (k < len) {
          currentElement = O[k];

          if (searchElement === currentElement || searchElement !== searchElement && currentElement !== currentElement) {
            return true;
          }

          k++;
        }

        return false;
      }
    });
  }
})(this);
(function (global) {
  if (!Array.from) {
    Array.from = function (arrayLike) {
      if (arrayLike == null) {
        throw new TypeError('Object is null or undefined');
      }

      var mapFn = arguments[1];
      var thisArg = arguments[2];
      var C = this;
      var items = Object(arrayLike);
      var symbolIterator = typeof Symbol === 'function' ? typeof Symbol === "function" ? Symbol.iterator : "@@iterator" : '@@iterator';
      var mapping = typeof mapFn === 'function';
      var usingIterator = typeof items[symbolIterator] === 'function';
      var key = 0;
      var ret;
      var value;

      if (usingIterator) {
        ret = typeof C === 'function' ? new C() : [];
        var it = items[symbolIterator]();
        var next;

        while (!(next = it.next()).done) {
          value = next.value;

          if (mapping) {
            value = mapFn.call(thisArg, value, key);
          }

          ret[key] = value;
          key += 1;
        }

        ret.length = key;
        return ret;
      }

      var len = items.length;

      if (isNaN(len) || len < 0) {
        len = 0;
      }

      ret = typeof C === 'function' ? new C(len) : new Array(len);

      while (key < len) {
        value = items[key];

        if (mapping) {
          value = mapFn.call(thisArg, value, key);
        }

        ret[key] = value;
        key += 1;
      }

      ret.length = key;
      return ret;
    };
  }
})(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;
      };
    }
  })();
})(this);
(function (global) {
  'use strict';

  var babelHelpers = global.babelHelpers = {};

  function _classCallCheck(instance, Constructor) {
    if (!(instance instanceof Constructor)) {
      throw new TypeError('Cannot call a class as a function');
    }
  }

  babelHelpers.classCallCheck = _classCallCheck;

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

  babelHelpers.createClass = _createClass;

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

  babelHelpers.defineProperty = _defineProperty;

  function _extends() {
    babelHelpers.extends = _extends = Object.assign || function (target) {
      for (var i = 1; i < arguments.length; i++) {
        var source = arguments[i];

        for (var key in source) {
          if (Object.prototype.hasOwnProperty.call(source, key)) {
            target[key] = source[key];
          }
        }
      }

      return target;
    };

    return _extends.apply(this, arguments);
  }

  babelHelpers.extends = _extends;

  function _setPrototypeOf(o, p) {
    babelHelpers.setPrototypeOf = _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
      o.__proto__ = p;
      return o;
    };

    return _setPrototypeOf(o, p);
  }

  babelHelpers.setPrototypeOf = _setPrototypeOf;

  function _superPropBase(object, property) {
    while (!Object.prototype.hasOwnProperty.call(object, property)) {
      object = babelHelpers.getPrototypeOf(object);

      if (object === null) {
        break;
      }
    }

    return object;
  }

  babelHelpers.superPropBase = _superPropBase;

  babelHelpers.get = function _get(target, property) {
    var receiver = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : target;
    var base = babelHelpers.superPropBase(target, property);

    if (!base) {
      return;
    }

    var desc = Object.getOwnPropertyDescriptor(base, property);

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

    return desc.value;
  };

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

    babelHelpers.setPrototypeOf(subClass.prototype, superClass && superClass.prototype);

    if (superClass) {
      babelHelpers.setPrototypeOf(subClass, superClass);
    }
  }

  babelHelpers.inherits = _inherits;

  function _construct(Parent, args, Class) {
    babelHelpers.construct = _construct = function _construct(Parent, args, Class) {
      var a = [null];
      a.push.apply(a, args);
      var Constructor = Parent.bind.apply(Parent, a);
      var instance = new Constructor();

      if (Class) {
        babelHelpers.setPrototypeOf(instance, Class.prototype);
      }

      return instance;
    };

    return _construct.apply(null, arguments);
  }

  babelHelpers.construct = _construct;

  function _getPrototypeOf(o) {
    babelHelpers.getPrototypeOf = _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) {
      return o.__proto__;
    };

    return _getPrototypeOf(o);
  }

  babelHelpers.getPrototypeOf = _getPrototypeOf;

  function _assertThisInitialized(self) {
    if (self === void 0) {
      throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
    }

    return self;
  }

  babelHelpers.assertThisInitialized = _assertThisInitialized;

  function _wrapNativeSuper(Class) {
    var _cache = typeof Map === 'function' ? new Map() : undefined;

    babelHelpers.wrapNativeSuper = _wrapNativeSuper = function _wrapNativeSuper(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 babelHelpers.setPrototypeOf(Wrapper, babelHelpers.setPrototypeOf(function Super() {
        return babelHelpers.construct(Class, arguments, babelHelpers.getPrototypeOf(this).constructor);
      }, Class));
    };

    return _wrapNativeSuper(Class);
  }

  babelHelpers.wrapNativeSuper = _wrapNativeSuper;

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  babelHelpers.interopRequireDefault = _interopRequireDefault;

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

  babelHelpers.interopRequireWildcard = _interopRequireWildcard;

  function _objectWithoutProperties(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];
    }

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

  babelHelpers.objectWithoutProperties = _objectWithoutProperties;

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

    return babelHelpers.assertThisInitialized(self);
  }

  babelHelpers.possibleConstructorReturn = _possibleConstructorReturn;

  function _arrayWithHoles(arr) {
    if (Array.isArray(arr)) {
      return arr;
    }
  }

  babelHelpers.arrayWithHoles = _arrayWithHoles;

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

  babelHelpers.arrayWithoutHoles = _arrayWithoutHoles;

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

  babelHelpers.iterableToArrayLimit = _iterableToArrayLimit;

  function _nonIterableRest() {
    throw new TypeError('Invalid attempt to destructure non-iterable instance');
  }

  babelHelpers.nonIterableRest = _nonIterableRest;

  function _nonIterableSpread() {
    throw new TypeError('Invalid attempt to spread non-iterable instance');
  }

  babelHelpers.nonIterableSpread = _nonIterableSpread;

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

  babelHelpers.slicedToArray = _slicedToArray;

  function _taggedTemplateLiteral(strings, raw) {
    if (!raw) {
      raw = strings.slice(0);
    }

    return Object.freeze(Object.defineProperties(strings, {
      raw: {
        value: Object.freeze(raw)
      }
    }));
  }

  babelHelpers.taggedTemplateLiteral = _taggedTemplateLiteral;

  function _toArray(arr) {
    return babelHelpers.arrayWithHoles(arr) || babelHelpers.iterableToArray(arr) || babelHelpers.nonIterableRest();
  }

  babelHelpers.toArray = _toArray;

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

  babelHelpers.toConsumableArray = _toConsumableArray;

  function _taggedTemplateLiteralLoose(strings, raw) {
    if (!raw) {
      raw = strings.slice(0);
    }

    strings.raw = raw;
    return strings;
  }

  babelHelpers.taggedTemplateLiteralLoose = _taggedTemplateLiteralLoose;

  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) {
        babelHelpers.defineProperty(target, key, source[key]);
      });
    }

    return target;
  }

  babelHelpers.objectSpread = _objectSpread;

  function _iterableToArray(iter) {
    if ((typeof Symbol === "function" ? Symbol.iterator : "@@iterator") in Object(iter) || Object.prototype.toString.call(iter) === '[object Arguments]') {
      return Array.from(iter);
    }
  }

  babelHelpers.iterableToArray = _iterableToArray;
})(this);
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

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

  var _react = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "react"));

  var _index = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./node_modules/react-transform-hmr/lib/index.js"));

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

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

  var _reactNativeVideo = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "react-native-video"));

  var _jsxFileName = "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/index.ios.js";

  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

  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 _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

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

  function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }

  var _components = {
    VideoPlayer: {
      displayName: "VideoPlayer"
    }
  };

  var _node_modulesReactTransformHmrLibIndexJs2 = (0, _index.default)({
    filename: "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/index.ios.js",
    components: _components,
    locals: [module],
    imports: [_react.default]
  });

  function _wrapComponent(id) {
    return function (Component) {
      return _node_modulesReactTransformHmrLibIndexJs2(Component, id);
    };
  }

  var VideoPlayer = _wrapComponent("VideoPlayer")(function (_Component) {
    function VideoPlayer(props) {
      var _this;

      _classCallCheck(this, VideoPlayer);

      _this = _possibleConstructorReturn(this, _getPrototypeOf(VideoPlayer).call(this, props));
      _this.onLayout = _this.onLayout.bind(_assertThisInitialized(_assertThisInitialized(_this)));
      return _this;
    }

    _createClass(VideoPlayer, [{
      key: "componentWillMount",
      value: function componentWillMount() {
        this.resizeVideoPlayer();
      }
    }, {
      key: "render",
      value: function render() {
        var _this2 = this;

        return _react.default.createElement(_reactNative.View, {
          onLayout: this.onLayout,
          style: styles.container,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 30
          }
        }, _react.default.createElement(_reactNative.Text, {
          __source: {
            fileName: _jsxFileName,
            lineNumber: 33
          }
        }, "Here's some pre-Text"), _react.default.createElement(_reactNativeVideo.default, {
          ref: function ref(p) {
            _this2.videoPlayer = p;
          },
          source: _$$_REQUIRE(_dependencyMap[5], './broadchurch.mp4'),
          style: {
            width: this.state.orientationWidth,
            height: this.state.orientationHeight
          },
          controls: false,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 34
          }
        }), _react.default.createElement(_reactNative.Button, {
          title: "full screen",
          onPress: this.onPress.bind(this),
          __source: {
            fileName: _jsxFileName,
            lineNumber: 40
          }
        }));
      }
    }, {
      key: "onPress",
      value: function onPress() {
        if (this.videoPlayer != null) this.videoPlayer.presentFullscreenPlayer();
      }
    }, {
      key: "resizeVideoPlayer",
      value: function resizeVideoPlayer() {
        var _Dimensions$get = _reactNative.Dimensions.get('window'),
            width = _Dimensions$get.width,
            height = _Dimensions$get.height;

        if (_Utils.default.isPortrait()) {
          this.setState({
            orientationWidth: width * 0.8,
            orientationHeight: width * 0.8 * 0.56
          });
        } else {
          this.setState({
            orientationHeight: height * 0.8,
            orientationWidth: height * 0.8 * 1.77
          });
        }
      }
    }, {
      key: "onLayout",
      value: function onLayout(e) {
        console.log('on layout called');
        this.resizeVideoPlayer();
      }
    }]);

    _inherits(VideoPlayer, _Component);

    return VideoPlayer;
  }(_react.Component));

  var _default2 = VideoPlayer;
  exports.default = _default2;

  var styles = _reactNative.StyleSheet.create({
    container: {
      flex: 1,
      justifyContent: 'center',
      alignItems: 'center',
      backgroundColor: 'white'
    }
  });

  _reactNative.AppRegistry.registerComponent('VideoPlayer', function () {
    return VideoPlayer;
  });
},0,[1,11,165,507,508,513],"index.ios.js");
__d(function (global, _$$_REQUIRE, 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');
  }
},1,[2,7],"node_modules/react/index.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  /** @license React v16.4.1
   * react.production.min.js
   *
   * Copyright (c) 2013-present, Facebook, Inc.
   *
   * 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 k = _$$_REQUIRE(_dependencyMap[0], "object-assign"),
      n = _$$_REQUIRE(_dependencyMap[1], "fbjs/lib/invariant"),
      p = _$$_REQUIRE(_dependencyMap[2], "fbjs/lib/emptyObject"),
      q = _$$_REQUIRE(_dependencyMap[3], "fbjs/lib/emptyFunction"),
      r = "function" === typeof Symbol && (typeof Symbol === "function" ? Symbol.for : "@@for"),
      t = r ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.element") : 60103,
      u = r ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.portal") : 60106,
      v = r ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.fragment") : 60107,
      w = r ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.strict_mode") : 60108,
      x = r ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.profiler") : 60114,
      y = r ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.provider") : 60109,
      z = r ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.context") : 60110,
      A = r ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.async_mode") : 60111,
      B = r ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.forward_ref") : 60112;

  r && (typeof Symbol === "function" ? Symbol.for : "@@for")("react.timeout");
  var C = "function" === typeof Symbol && (typeof Symbol === "function" ? Symbol.iterator : "@@iterator");

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

    n(!1, "Minified React error #" + a + "; visit %s for the full message or use the non-minified dev environment for full errors and additional helpful warnings. ", e);
  }

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

  function F(a, b, e) {
    this.props = a;
    this.context = b;
    this.refs = p;
    this.updater = e || E;
  }

  F.prototype.isReactComponent = {};

  F.prototype.setState = function (a, b) {
    "object" !== typeof a && "function" !== typeof a && null != a ? D("85") : void 0;
    this.updater.enqueueSetState(this, a, b, "setState");
  };

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

  function G() {}

  G.prototype = F.prototype;

  function H(a, b, e) {
    this.props = a;
    this.context = b;
    this.refs = p;
    this.updater = e || E;
  }

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

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

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

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

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

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

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

    return {
      result: a,
      keyPrefix: b,
      func: e,
      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, e, c) {
    var d = typeof a;
    if ("undefined" === d || "boolean" === d) a = null;
    var g = !1;
    if (null === a) g = !0;else switch (d) {
      case "string":
      case "number":
        g = !0;
        break;

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

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

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

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

  function V(a, b, e) {
    var c = a.result,
        d = a.keyPrefix;
    a = a.func.call(a.context, b, a.count++);
    Array.isArray(a) ? W(a, c, e, q.thatReturnsArgument) : null != a && (N(a) && (b = d + (!a.key || b && b.key === a.key ? "" : ("" + a.key).replace(O, "$&/") + "/") + e, a = {
      $$typeof: t,
      type: a.type,
      key: b,
      ref: a.ref,
      props: a.props,
      _owner: a._owner
    }), c.push(a));
  }

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

  var X = {
    Children: {
      map: function map(a, b, e) {
        if (null == a) return a;
        var c = [];
        W(a, c, null, b, e);
        return c;
      },
      forEach: function forEach(a, b, e) {
        if (null == a) return a;
        b = Q(null, null, b, e);
        null == a || S(a, "", U, b);
        R(b);
      },
      count: function count(a) {
        return null == a ? 0 : S(a, "", q.thatReturnsNull, null);
      },
      toArray: function toArray(a) {
        var b = [];
        W(a, b, null, q.thatReturnsArgument);
        return b;
      },
      only: function only(a) {
        N(a) ? void 0 : D("143");
        return a;
      }
    },
    createRef: function createRef() {
      return {
        current: null
      };
    },
    Component: F,
    PureComponent: H,
    createContext: function createContext(a, b) {
      void 0 === b && (b = null);
      a = {
        $$typeof: z,
        _calculateChangedBits: b,
        _defaultValue: a,
        _currentValue: a,
        _currentValue2: a,
        _changedBits: 0,
        _changedBits2: 0,
        Provider: null,
        Consumer: null
      };
      a.Provider = {
        $$typeof: y,
        _context: a
      };
      return a.Consumer = a;
    },
    forwardRef: function forwardRef(a) {
      return {
        $$typeof: B,
        render: a
      };
    },
    Fragment: v,
    StrictMode: w,
    unstable_AsyncMode: A,
    unstable_Profiler: x,
    createElement: M,
    cloneElement: function cloneElement(a, b, e) {
      null === a || void 0 === a ? D("267", a) : void 0;
      var c = void 0,
          d = k({}, a.props),
          g = a.key,
          h = a.ref,
          f = a._owner;

      if (null != b) {
        void 0 !== b.ref && (h = 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) && (d[c] = void 0 === b[c] && void 0 !== l ? l[c] : b[c]);
        }
      }

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

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

        d.children = l;
      }
      return {
        $$typeof: t,
        type: a.type,
        key: g,
        ref: h,
        props: d,
        _owner: f
      };
    },
    createFactory: function createFactory(a) {
      var b = M.bind(null, a);
      b.type = a;
      return b;
    },
    isValidElement: N,
    version: "16.4.1",
    __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED: {
      ReactCurrentOwner: J,
      assign: k
    }
  },
      Y = {
    default: X
  },
      Z = Y && X || Y;
  module.exports = Z.default ? Z.default : Z;
},2,[3,4,5,6],"node_modules/react/cjs/react.production.min.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  /*
  object-assign
  (c) Sindre Sorhus
  @license MIT
  */
  'use strict';

  function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

  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;
  };
},3,[],"node_modules/object-assign/index.js");
__d(function (global, _$$_REQUIRE, 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;
},4,[],"node_modules/fbjs/lib/invariant.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var emptyObject = {};

  if (process.env.NODE_ENV !== 'production') {
    Object.freeze(emptyObject);
  }

  module.exports = emptyObject;
},5,[],"node_modules/fbjs/lib/emptyObject.js");
__d(function (global, _$$_REQUIRE, 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, module, exports, _dependencyMap) {
  /** @license React v16.4.1
   * react.development.js
   *
   * Copyright (c) 2013-present, Facebook, Inc.
   *
   * 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 invariant = _$$_REQUIRE(_dependencyMap[1], 'fbjs/lib/invariant');

      var emptyObject = _$$_REQUIRE(_dependencyMap[2], 'fbjs/lib/emptyObject');

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

      var emptyFunction = _$$_REQUIRE(_dependencyMap[4], 'fbjs/lib/emptyFunction');

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

      var ReactVersion = '16.4.1';
      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_FORWARD_REF_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.forward_ref') : 0xead0;
      var REACT_TIMEOUT_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")('react.timeout') : 0xead1;
      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 === 'undefined') {
          return null;
        }

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

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

        return null;
      }

      var enableSuspense = false;

      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('`warning(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 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;
          }

          warning(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');
        }
      };

      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) {
        !(typeof partialState === 'object' || typeof partialState === 'function' || partialState == null) ? invariant(false, 'setState(...): takes an object of state variables to update or a function which returns an object of state variables.') : void 0;
        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 ReactCurrentOwner = {
        current: null
      };
      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;
            warning(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;
            warning(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 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) {
            if (typeof props.$$typeof === 'undefined' || props.$$typeof !== REACT_ELEMENT_TYPE) {
              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) {
        !!(element === null || element === undefined) ? invariant(false, 'React.cloneElement(...): The argument must be a React element, but you passed %s.', element) : void 0;
        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 ReactDebugCurrentFrame = {};
      {
        ReactDebugCurrentFrame.getCurrentStack = null;

        ReactDebugCurrentFrame.getStackAddendum = function () {
          var impl = ReactDebugCurrentFrame.getCurrentStack;

          if (impl) {
            return impl();
          }

          return null;
        };
      }
      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(false, 'Using Maps as children is unsupported and will likely yield ' + 'unexpected results. Convert it to a sequence/iterable of keyed ' + 'ReactElements instead.%s', ReactDebugCurrentFrame.getStackAddendum()) : 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;
            invariant(false, 'Objects are not valid as a React child (found: %s).%s', 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, emptyFunction.thatReturnsArgument);
        } 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, emptyFunction.thatReturnsNull, null);
      }

      function toArray(children) {
        var result = [];
        mapIntoWithKeyPrefixInternal(children, result, null, emptyFunction.thatReturnsArgument);
        return result;
      }

      function onlyChild(children) {
        !isValidElement(children) ? invariant(false, 'React.Children.only expected to receive a single React element child.') : void 0;
        return children;
      }

      function createContext(defaultValue, calculateChangedBits) {
        if (calculateChangedBits === undefined) {
          calculateChangedBits = null;
        } else {
          {
            !(calculateChangedBits === null || typeof calculateChangedBits === 'function') ? warning(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,
          _defaultValue: defaultValue,
          _currentValue: defaultValue,
          _currentValue2: defaultValue,
          _changedBits: 0,
          _changedBits2: 0,
          Provider: null,
          Consumer: null
        };
        context.Provider = {
          $$typeof: REACT_PROVIDER_TYPE,
          _context: context
        };
        context.Consumer = context;
        {
          context._currentRenderer = null;
          context._currentRenderer2 = null;
        }
        return context;
      }

      function forwardRef(render) {
        {
          !(typeof render === 'function') ? warning(false, 'forwardRef requires a render function but was given %s.', render === null ? 'null' : typeof render) : void 0;

          if (render != null) {
            !(render.defaultProps == null && render.propTypes == null) ? warning(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
        };
      }

      var describeComponentFrame = function describeComponentFrame(name, source, ownerName) {
        return '\n    in ' + (name || 'Unknown') + (source ? ' (at ' + source.fileName.replace(/^.*[\\\/]/, '') + ':' + source.lineNumber + ')' : ownerName ? ' (created by ' + ownerName + ')' : '');
      };

      function isValidElementType(type) {
        return typeof type === 'string' || typeof type === 'function' || type === REACT_FRAGMENT_TYPE || type === REACT_ASYNC_MODE_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_TIMEOUT_TYPE || typeof type === 'object' && type !== null && (type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE);
      }

      function getComponentName(fiber) {
        var type = fiber.type;

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

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

        switch (type) {
          case REACT_ASYNC_MODE_TYPE:
            return 'AsyncMode';

          case REACT_CONTEXT_TYPE:
            return 'Context.Consumer';

          case REACT_FRAGMENT_TYPE:
            return 'ReactFragment';

          case REACT_PORTAL_TYPE:
            return 'ReactPortal';

          case REACT_PROFILER_TYPE:
            return 'Profiler(' + fiber.pendingProps.id + ')';

          case REACT_PROVIDER_TYPE:
            return 'Context.Provider';

          case REACT_STRICT_MODE_TYPE:
            return 'StrictMode';

          case REACT_TIMEOUT_TYPE:
            return 'Timeout';
        }

        if (typeof type === 'object' && type !== null) {
          switch (type.$$typeof) {
            case REACT_FORWARD_REF_TYPE:
              var functionName = type.render.displayName || type.render.name || '';
              return functionName !== '' ? 'ForwardRef(' + functionName + ')' : 'ForwardRef';
          }
        }

        return null;
      }

      var currentlyValidatingElement = void 0;
      var propTypesMisspellWarningShown = void 0;

      var getDisplayName = function getDisplayName() {};

      var getStackAddendum = function getStackAddendum() {};

      {
        currentlyValidatingElement = null;
        propTypesMisspellWarningShown = false;

        getDisplayName = function getDisplayName(element) {
          if (element == null) {
            return '#empty';
          } else if (typeof element === 'string' || typeof element === 'number') {
            return '#text';
          } else if (typeof element.type === 'string') {
            return element.type;
          }

          var type = element.type;

          if (type === REACT_FRAGMENT_TYPE) {
            return 'React.Fragment';
          } else if (typeof type === 'object' && type !== null && type.$$typeof === REACT_FORWARD_REF_TYPE) {
            var functionName = type.render.displayName || type.render.name || '';
            return functionName !== '' ? 'ForwardRef(' + functionName + ')' : 'ForwardRef';
          } else {
            return type.displayName || type.name || 'Unknown';
          }
        };

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

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

          stack += ReactDebugCurrentFrame.getStackAddendum() || '';
          return stack;
        };
      }

      function getDeclarationErrorAddendum() {
        if (ReactCurrentOwner.current) {
          var name = getComponentName(ReactCurrentOwner.current);

          if (name) {
            return '\n\nCheck the render method of `' + name + '`.';
          }
        }

        return '';
      }

      function getSourceInfoErrorAddendum(elementProps) {
        if (elementProps !== null && elementProps !== undefined && elementProps.__source !== undefined) {
          var source = elementProps.__source;
          var fileName = source.fileName.replace(/^.*[\\\/]/, '');
          var lineNumber = source.lineNumber;
          return '\n\nCheck your code at ' + fileName + ':' + lineNumber + '.';
        }

        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) + '.';
        }

        currentlyValidatingElement = element;
        {
          warning(false, 'Each child in an array or iterator should have a unique "key" prop.' + '%s%s See https://fb.me/react-warning-keys for more information.%s', currentComponentErrorInfo, childOwner, getStackAddendum());
        }
        currentlyValidatingElement = 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;
        var name = void 0,
            propTypes = void 0;

        if (typeof type === 'function') {
          name = type.displayName || type.name;
          propTypes = type.propTypes;
        } else if (typeof type === 'object' && type !== null && type.$$typeof === REACT_FORWARD_REF_TYPE) {
          var functionName = type.render.displayName || type.render.name || '';
          name = functionName !== '' ? 'ForwardRef(' + functionName + ')' : 'ForwardRef';
          propTypes = type.propTypes;
        } else {
          return;
        }

        if (propTypes) {
          currentlyValidatingElement = element;
          checkPropTypes(propTypes, element.props, 'prop', name, getStackAddendum);
          currentlyValidatingElement = null;
        } else if (type.PropTypes !== undefined && !propTypesMisspellWarningShown) {
          propTypesMisspellWarningShown = true;
          warning(false, 'Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?', name || 'Unknown');
        }

        if (typeof type.getDefaultProps === 'function') {
          !type.getDefaultProps.isReactClassApproved ? warning(false, 'getDefaultProps is only used on classic React.createClass ' + 'definitions. Use a static property named `defaultProps` instead.') : void 0;
        }
      }

      function validateFragmentProps(fragment) {
        currentlyValidatingElement = 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(false, 'Invalid prop `%s` supplied to `React.Fragment`. ' + 'React.Fragment can only have `key` and `children` props.%s', key, getStackAddendum());
            break;
          }
        }

        if (fragment.ref !== null) {
          warning(false, 'Invalid attribute `ref` supplied to `React.Fragment`.%s', getStackAddendum());
        }

        currentlyValidatingElement = null;
      }

      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 = getSourceInfoErrorAddendum(props);

          if (sourceInfo) {
            info += sourceInfo;
          } else {
            info += getDeclarationErrorAddendum();
          }

          info += getStackAddendum() || '';
          var typeString = void 0;

          if (type === null) {
            typeString = 'null';
          } else if (Array.isArray(type)) {
            typeString = 'array';
          } else {
            typeString = typeof type;
          }

          warning(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 React = {
        Children: {
          map: mapChildren,
          forEach: forEachChildren,
          count: countChildren,
          toArray: toArray,
          only: onlyChild
        },
        createRef: createRef,
        Component: Component,
        PureComponent: PureComponent,
        createContext: createContext,
        forwardRef: forwardRef,
        Fragment: REACT_FRAGMENT_TYPE,
        StrictMode: REACT_STRICT_MODE_TYPE,
        unstable_AsyncMode: REACT_ASYNC_MODE_TYPE,
        unstable_Profiler: REACT_PROFILER_TYPE,
        createElement: createElementWithValidation,
        cloneElement: cloneElementWithValidation,
        createFactory: createFactoryWithValidation,
        isValidElement: isValidElement,
        version: ReactVersion,
        __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED: {
          ReactCurrentOwner: ReactCurrentOwner,
          assign: _assign
        }
      };

      if (enableSuspense) {
        React.Timeout = REACT_TIMEOUT_TYPE;
      }

      {
        _assign(React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED, {
          ReactDebugCurrentFrame: ReactDebugCurrentFrame,
          ReactComponentTreeHook: {}
        });
      }
      var React$2 = Object.freeze({
        default: React
      });
      var React$3 = React$2 && React || React$2;
      var react = React$3.default ? React$3.default : React$3;
      module.exports = react;
    })();
  }
},7,[3,4,5,8,6,9],"node_modules/react/cjs/react.development.js");
__d(function (global, _$$_REQUIRE, 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;
},8,[6],"node_modules/fbjs/lib/warning.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var printWarning = function printWarning() {};

  if (process.env.NODE_ENV !== 'production') {
    var ReactPropTypesSecret = _$$_REQUIRE(_dependencyMap[0], './lib/ReactPropTypesSecret');

    var loggedTypeFailures = {};

    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 (typeSpecs.hasOwnProperty(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 : ''));
          }
        }
      }
    }
  }

  module.exports = checkPropTypes;
},9,[10],"node_modules/prop-types/checkPropTypes.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';
  module.exports = ReactPropTypesSecret;
},10,[],"node_modules/prop-types/lib/ReactPropTypesSecret.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  Object.defineProperty(exports, '__esModule', {
    value: true
  });

  var _slicedToArray = function () {
    function sliceIterator(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']) _i['return']();
        } finally {
          if (_d) throw _e;
        }
      }

      return _arr;
    }

    return function (arr, i) {
      if (Array.isArray(arr)) {
        return arr;
      } else if ((typeof Symbol === "function" ? Symbol.iterator : "@@iterator") in Object(arr)) {
        return sliceIterator(arr, i);
      } else {
        throw new TypeError('Invalid attempt to destructure non-iterable instance');
      }
    };
  }();

  exports['default'] = proxyReactComponents;

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      'default': obj
    };
  }

  var _reactProxy = _$$_REQUIRE(_dependencyMap[0], 'react-proxy');

  var _globalWindow = _$$_REQUIRE(_dependencyMap[1], 'global/window');

  var _globalWindow2 = _interopRequireDefault(_globalWindow);

  var componentProxies = undefined;

  if (_globalWindow2['default'].__reactComponentProxies) {
    componentProxies = _globalWindow2['default'].__reactComponentProxies;
  } else {
    componentProxies = {};
    Object.defineProperty(_globalWindow2['default'], '__reactComponentProxies', {
      configurable: true,
      enumerable: false,
      writable: false,
      value: componentProxies
    });
  }

  function proxyReactComponents(_ref) {
    var filename = _ref.filename;
    var components = _ref.components;
    var imports = _ref.imports;
    var locals = _ref.locals;

    var _imports = _slicedToArray(imports, 1);

    var React = _imports[0];

    var _locals = _slicedToArray(locals, 1);

    var hot = _locals[0].hot;

    if (!React.Component) {
      throw new Error('imports[0] for react-transform-hmr does not look like React.');
    }

    if (!hot || typeof hot.accept !== 'function') {
      throw new Error('locals[0] does not appear to be a `module` object with Hot Module ' + 'replacement API enabled. You should disable react-transform-hmr in ' + 'production by using `env` section in Babel configuration. See the ' + 'example in README: https://github.com/gaearon/react-transform-hmr');
    }

    if (Object.keys(components).some(function (key) {
      return !components[key].isInFunction;
    })) {
      hot.accept(function (err) {
        if (err) {
          console.warn('[React Transform HMR] There was an error updating ' + filename + ':');
          console.error(err);
        }
      });
    }

    var forceUpdate = (0, _reactProxy.getForceUpdate)(React);
    return function wrapWithProxy(ReactClass, uniqueId) {
      var _components$uniqueId = components[uniqueId];
      var _components$uniqueId$isInFunction = _components$uniqueId.isInFunction;
      var isInFunction = _components$uniqueId$isInFunction === undefined ? false : _components$uniqueId$isInFunction;
      var _components$uniqueId$displayName = _components$uniqueId.displayName;
      var displayName = _components$uniqueId$displayName === undefined ? uniqueId : _components$uniqueId$displayName;

      if (isInFunction) {
        return ReactClass;
      }

      var globalUniqueId = filename + '$' + uniqueId;

      if (componentProxies[globalUniqueId]) {
        (function () {
          console.info('[React Transform HMR] Patching ' + displayName);
          var instances = componentProxies[globalUniqueId].update(ReactClass);
          setTimeout(function () {
            return instances.forEach(forceUpdate);
          });
        })();
      } else {
        componentProxies[globalUniqueId] = (0, _reactProxy.createProxy)(ReactClass);
      }

      return componentProxies[globalUniqueId].get();
    };
  }

  module.exports = exports['default'];
},11,[12,164],"node_modules/react-transform-hmr/lib/index.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.getForceUpdate = exports.createProxy = undefined;

  var _supportsProtoAssignment = _$$_REQUIRE(_dependencyMap[0], './supportsProtoAssignment');

  var _supportsProtoAssignment2 = _interopRequireDefault(_supportsProtoAssignment);

  var _createClassProxy = _$$_REQUIRE(_dependencyMap[1], './createClassProxy');

  var _createClassProxy2 = _interopRequireDefault(_createClassProxy);

  var _reactDeepForceUpdate = _$$_REQUIRE(_dependencyMap[2], 'react-deep-force-update');

  var _reactDeepForceUpdate2 = _interopRequireDefault(_reactDeepForceUpdate);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  if (!(0, _supportsProtoAssignment2.default)()) {
    console.warn('This JavaScript environment does not support __proto__. ' + 'This means that react-proxy is unable to proxy React components. ' + 'Features that rely on react-proxy, such as react-transform-hmr, ' + 'will not function as expected.');
  }

  exports.createProxy = _createClassProxy2.default;
  exports.getForceUpdate = _reactDeepForceUpdate2.default;
},12,[13,14,163],"node_modules/react-proxy/modules/index.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  "use strict";

  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = supportsProtoAssignment;
  var x = {};
  var y = {
    supports: true
  };

  try {
    x.__proto__ = y;
  } catch (err) {}

  function supportsProtoAssignment() {
    return x.supports || false;
  }

  ;
},13,[],"node_modules/react-proxy/modules/supportsProtoAssignment.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

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

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

  var _slicedToArray = function () {
    function sliceIterator(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"]) _i["return"]();
        } finally {
          if (_d) throw _e;
        }
      }

      return _arr;
    }

    return function (arr, i) {
      if (Array.isArray(arr)) {
        return arr;
      } else if ((typeof Symbol === "function" ? Symbol.iterator : "@@iterator") in Object(arr)) {
        return sliceIterator(arr, i);
      } else {
        throw new TypeError("Invalid attempt to destructure non-iterable instance");
      }
    };
  }();

  exports.default = proxyClass;
  exports.default = createClassProxy;

  var _find = _$$_REQUIRE(_dependencyMap[0], 'lodash/find');

  var _find2 = _interopRequireDefault(_find);

  var _createPrototypeProxy = _$$_REQUIRE(_dependencyMap[1], './createPrototypeProxy');

  var _createPrototypeProxy2 = _interopRequireDefault(_createPrototypeProxy);

  var _bindAutoBindMethods = _$$_REQUIRE(_dependencyMap[2], './bindAutoBindMethods');

  var _bindAutoBindMethods2 = _interopRequireDefault(_bindAutoBindMethods);

  var _deleteUnknownAutoBindMethods = _$$_REQUIRE(_dependencyMap[3], './deleteUnknownAutoBindMethods');

  var _deleteUnknownAutoBindMethods2 = _interopRequireDefault(_deleteUnknownAutoBindMethods);

  var _supportsProtoAssignment = _$$_REQUIRE(_dependencyMap[4], './supportsProtoAssignment');

  var _supportsProtoAssignment2 = _interopRequireDefault(_supportsProtoAssignment);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  function _toConsumableArray(arr) {
    if (Array.isArray(arr)) {
      for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) {
        arr2[i] = arr[i];
      }

      return arr2;
    } else {
      return Array.from(arr);
    }
  }

  var RESERVED_STATICS = ['length', 'name', 'arguments', 'caller', 'prototype', 'toString'];

  function isEqualDescriptor(a, b) {
    if (!a && !b) {
      return true;
    }

    if (!a || !b) {
      return false;
    }

    for (var key in a) {
      if (a[key] !== b[key]) {
        return false;
      }
    }

    return true;
  }

  var allProxies = [];

  function findProxy(Component) {
    var pair = (0, _find2.default)(allProxies, function (_ref) {
      var _ref2 = _slicedToArray(_ref, 1);

      var key = _ref2[0];
      return key === Component;
    });
    return pair ? pair[1] : null;
  }

  function addProxy(Component, proxy) {
    allProxies.push([Component, proxy]);
  }

  function proxyClass(InitialComponent) {
    var existingProxy = findProxy(InitialComponent);

    if (existingProxy) {
      return existingProxy;
    }

    var prototypeProxy = (0, _createPrototypeProxy2.default)();
    var CurrentComponent = undefined;
    var ProxyComponent = undefined;
    var staticDescriptors = {};

    function wasStaticModifiedByUser(key) {
      var currentDescriptor = Object.getOwnPropertyDescriptor(ProxyComponent, key);
      return !isEqualDescriptor(staticDescriptors[key], currentDescriptor);
    }

    function instantiate(factory, context, params) {
      var component = factory();

      try {
        return component.apply(context, params);
      } catch (err) {
        (function () {
          var instance = new (Function.prototype.bind.apply(component, [null].concat(_toConsumableArray(params))))();
          Object.keys(instance).forEach(function (key) {
            if (RESERVED_STATICS.indexOf(key) > -1) {
              return;
            }

            context[key] = instance[key];
          });
        })();
      }
    }

    try {
      ProxyComponent = new Function('factory', 'instantiate', 'return function ' + (InitialComponent.name || 'ProxyComponent') + '() {\n         return instantiate(factory, this, arguments);\n      }')(function () {
        return CurrentComponent;
      }, instantiate);
    } catch (err) {
      ProxyComponent = function ProxyComponent() {
        return instantiate(function () {
          return CurrentComponent;
        }, this, arguments);
      };
    }

    ProxyComponent.prototype = prototypeProxy.get();

    ProxyComponent.toString = function toString() {
      return CurrentComponent.toString();
    };

    function update(NextComponent) {
      if (typeof NextComponent !== 'function') {
        throw new Error('Expected a constructor.');
      }

      var existingProxy = findProxy(NextComponent);

      if (existingProxy) {
        return update(existingProxy.__getCurrent());
      }

      CurrentComponent = NextComponent;
      var mountedInstances = prototypeProxy.update(NextComponent.prototype);
      ProxyComponent.prototype.constructor = ProxyComponent;
      ProxyComponent.__proto__ = NextComponent.__proto__;
      Object.getOwnPropertyNames(NextComponent).forEach(function (key) {
        if (RESERVED_STATICS.indexOf(key) > -1) {
          return;
        }

        var staticDescriptor = _extends({}, Object.getOwnPropertyDescriptor(NextComponent, key), {
          configurable: true
        });

        if (!wasStaticModifiedByUser(key)) {
          Object.defineProperty(ProxyComponent, key, staticDescriptor);
          staticDescriptors[key] = staticDescriptor;
        }
      });
      Object.getOwnPropertyNames(ProxyComponent).forEach(function (key) {
        if (RESERVED_STATICS.indexOf(key) > -1) {
          return;
        }

        if (NextComponent.hasOwnProperty(key)) {
          return;
        }

        var descriptor = Object.getOwnPropertyDescriptor(ProxyComponent, key);

        if (descriptor && !descriptor.configurable) {
          return;
        }

        if (!wasStaticModifiedByUser(key)) {
          delete ProxyComponent[key];
          delete staticDescriptors[key];
        }
      });
      ProxyComponent.displayName = NextComponent.displayName || NextComponent.name;
      mountedInstances.forEach(_bindAutoBindMethods2.default);
      mountedInstances.forEach(_deleteUnknownAutoBindMethods2.default);
      return mountedInstances;
    }

    ;

    function get() {
      return ProxyComponent;
    }

    function getCurrent() {
      return CurrentComponent;
    }

    update(InitialComponent);
    var proxy = {
      get: get,
      update: update
    };
    addProxy(ProxyComponent, proxy);
    Object.defineProperty(proxy, '__getCurrent', {
      configurable: false,
      writable: false,
      enumerable: false,
      value: getCurrent
    });
    return proxy;
  }

  function createFallback(Component) {
    var CurrentComponent = Component;
    return {
      get: function get() {
        return CurrentComponent;
      },
      update: function update(NextComponent) {
        CurrentComponent = NextComponent;
      }
    };
  }

  function createClassProxy(Component) {
    return Component.__proto__ && (0, _supportsProtoAssignment2.default)() ? proxyClass(Component) : createFallback(Component);
  }
},14,[15,136,161,162,13],"node_modules/react-proxy/modules/createClassProxy.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  var createFind = _$$_REQUIRE(_dependencyMap[0], './_createFind'),
      findIndex = _$$_REQUIRE(_dependencyMap[1], './findIndex');

  var find = createFind(findIndex);
  module.exports = find;
},15,[16,131],"node_modules/lodash/find.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  var baseIteratee = _$$_REQUIRE(_dependencyMap[0], './_baseIteratee'),
      isArrayLike = _$$_REQUIRE(_dependencyMap[1], './isArrayLike'),
      keys = _$$_REQUIRE(_dependencyMap[2], './keys');

  function createFind(findIndexFunc) {
    return function (collection, predicate, fromIndex) {
      var iterable = Object(collection);

      if (!isArrayLike(collection)) {
        var iteratee = baseIteratee(predicate, 3);
        collection = keys(collection);

        predicate = function predicate(key) {
          return iteratee(iterable[key], key, iterable);
        };
      }

      var index = findIndexFunc(collection, predicate, fromIndex);
      return index > -1 ? iterable[iteratee ? collection[index] : index] : undefined;
    };
  }

  module.exports = createFind;
},16,[17,102,84],"node_modules/lodash/_createFind.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  var baseMatches = _$$_REQUIRE(_dependencyMap[0], './_baseMatches'),
      baseMatchesProperty = _$$_REQUIRE(_dependencyMap[1], './_baseMatchesProperty'),
      identity = _$$_REQUIRE(_dependencyMap[2], './identity'),
      isArray = _$$_REQUIRE(_dependencyMap[3], './isArray'),
      property = _$$_REQUIRE(_dependencyMap[4], './property');

  function baseIteratee(value) {
    if (typeof value == 'function') {
      return value;
    }

    if (value == null) {
      return identity;
    }

    if (typeof value == 'object') {
      return isArray(value) ? baseMatchesProperty(value[0], value[1]) : baseMatches(value);
    }

    return property(value);
  }

  module.exports = baseIteratee;
},17,[18,111,127,80,128],"node_modules/lodash/_baseIteratee.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  var baseIsMatch = _$$_REQUIRE(_dependencyMap[0], './_baseIsMatch'),
      getMatchData = _$$_REQUIRE(_dependencyMap[1], './_getMatchData'),
      matchesStrictComparable = _$$_REQUIRE(_dependencyMap[2], './_matchesStrictComparable');

  function baseMatches(source) {
    var matchData = getMatchData(source);

    if (matchData.length == 1 && matchData[0][2]) {
      return matchesStrictComparable(matchData[0][0], matchData[0][1]);
    }

    return function (object) {
      return object === source || baseIsMatch(object, source, matchData);
    };
  }

  module.exports = baseMatches;
},18,[19,108,110],"node_modules/lodash/_baseMatches.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  var Stack = _$$_REQUIRE(_dependencyMap[0], './_Stack'),
      baseIsEqual = _$$_REQUIRE(_dependencyMap[1], './_baseIsEqual');

  var COMPARE_PARTIAL_FLAG = 1,
      COMPARE_UNORDERED_FLAG = 2;

  function baseIsMatch(object, source, matchData, customizer) {
    var index = matchData.length,
        length = index,
        noCustomizer = !customizer;

    if (object == null) {
      return !length;
    }

    object = Object(object);

    while (index--) {
      var data = matchData[index];

      if (noCustomizer && data[2] ? data[1] !== object[data[0]] : !(data[0] in object)) {
        return false;
      }
    }

    while (++index < length) {
      data = matchData[index];
      var key = data[0],
          objValue = object[key],
          srcValue = data[1];

      if (noCustomizer && data[2]) {
        if (objValue === undefined && !(key in object)) {
          return false;
        }
      } else {
        var stack = new Stack();

        if (customizer) {
          var result = customizer(objValue, srcValue, key, object, source, stack);
        }

        if (!(result === undefined ? baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG, customizer, stack) : result)) {
          return false;
        }
      }
    }

    return true;
  }

  module.exports = baseIsMatch;
},19,[20,64],"node_modules/lodash/_baseIsMatch.js");
__d(function (global, _$$_REQUIRE, 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;
},20,[21,29,30,31,32,33],"node_modules/lodash/_Stack.js");
__d(function (global, _$$_REQUIRE, 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;
},21,[22,23,26,27,28],"node_modules/lodash/_ListCache.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  function listCacheClear() {
    this.__data__ = [];
    this.size = 0;
  }

  module.exports = listCacheClear;
},22,[],"node_modules/lodash/_listCacheClear.js");
__d(function (global, _$$_REQUIRE, 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;
},23,[24],"node_modules/lodash/_listCacheDelete.js");
__d(function (global, _$$_REQUIRE, 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;
},24,[25],"node_modules/lodash/_assocIndexOf.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  function eq(value, other) {
    return value === other || value !== value && other !== other;
  }

  module.exports = eq;
},25,[],"node_modules/lodash/eq.js");
__d(function (global, _$$_REQUIRE, 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;
},26,[24],"node_modules/lodash/_listCacheGet.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  var assocIndexOf = _$$_REQUIRE(_dependencyMap[0], './_assocIndexOf');

  function listCacheHas(key) {
    return assocIndexOf(this.__data__, key) > -1;
  }

  module.exports = listCacheHas;
},27,[24],"node_modules/lodash/_listCacheHas.js");
__d(function (global, _$$_REQUIRE, 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;
},28,[24],"node_modules/lodash/_listCacheSet.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  var ListCache = _$$_REQUIRE(_dependencyMap[0], './_ListCache');

  function stackClear() {
    this.__data__ = new ListCache();
    this.size = 0;
  }

  module.exports = stackClear;
},29,[21],"node_modules/lodash/_stackClear.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  function stackDelete(key) {
    var data = this.__data__,
        result = data['delete'](key);
    this.size = data.size;
    return result;
  }

  module.exports = stackDelete;
},30,[],"node_modules/lodash/_stackDelete.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  function stackGet(key) {
    return this.__data__.get(key);
  }

  module.exports = stackGet;
},31,[],"node_modules/lodash/_stackGet.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  function stackHas(key) {
    return this.__data__.has(key);
  }

  module.exports = stackHas;
},32,[],"node_modules/lodash/_stackHas.js");
__d(function (global, _$$_REQUIRE, 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;
},33,[21,34,49],"node_modules/lodash/_stackSet.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  var getNative = _$$_REQUIRE(_dependencyMap[0], './_getNative'),
      root = _$$_REQUIRE(_dependencyMap[1], './_root');

  var Map = getNative(root, 'Map');
  module.exports = Map;
},34,[35,40],"node_modules/lodash/_Map.js");
__d(function (global, _$$_REQUIRE, 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;
},35,[36,48],"node_modules/lodash/_getNative.js");
__d(function (global, _$$_REQUIRE, 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;
},36,[37,45,44,47],"node_modules/lodash/_baseIsNative.js");
__d(function (global, _$$_REQUIRE, 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;
},37,[38,44],"node_modules/lodash/isFunction.js");
__d(function (global, _$$_REQUIRE, 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;
},38,[39,42,43],"node_modules/lodash/_baseGetTag.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  var root = _$$_REQUIRE(_dependencyMap[0], './_root');

  var Symbol = root.Symbol;
  module.exports = Symbol;
},39,[40],"node_modules/lodash/_Symbol.js");
__d(function (global, _$$_REQUIRE, 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;
},40,[41],"node_modules/lodash/_root.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;
  module.exports = freeGlobal;
},41,[],"node_modules/lodash/_freeGlobal.js");
__d(function (global, _$$_REQUIRE, 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;
},42,[39],"node_modules/lodash/_getRawTag.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  var objectProto = Object.prototype;
  var nativeObjectToString = objectProto.toString;

  function objectToString(value) {
    return nativeObjectToString.call(value);
  }

  module.exports = objectToString;
},43,[],"node_modules/lodash/_objectToString.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  function isObject(value) {
    var type = typeof value;
    return value != null && (type == 'object' || type == 'function');
  }

  module.exports = isObject;
},44,[],"node_modules/lodash/isObject.js");
__d(function (global, _$$_REQUIRE, 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;
},45,[46],"node_modules/lodash/_isMasked.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  var root = _$$_REQUIRE(_dependencyMap[0], './_root');

  var coreJsData = root['__core-js_shared__'];
  module.exports = coreJsData;
},46,[40],"node_modules/lodash/_coreJsData.js");
__d(function (global, _$$_REQUIRE, 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;
},47,[],"node_modules/lodash/_toSource.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  function getValue(object, key) {
    return object == null ? undefined : object[key];
  }

  module.exports = getValue;
},48,[],"node_modules/lodash/_getValue.js");
__d(function (global, _$$_REQUIRE, 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;
},49,[50,58,61,62,63],"node_modules/lodash/_MapCache.js");
__d(function (global, _$$_REQUIRE, 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;
},50,[51,21,34],"node_modules/lodash/_mapCacheClear.js");
__d(function (global, _$$_REQUIRE, 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;
},51,[52,54,55,56,57],"node_modules/lodash/_Hash.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  var nativeCreate = _$$_REQUIRE(_dependencyMap[0], './_nativeCreate');

  function hashClear() {
    this.__data__ = nativeCreate ? nativeCreate(null) : {};
    this.size = 0;
  }

  module.exports = hashClear;
},52,[53],"node_modules/lodash/_hashClear.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  var getNative = _$$_REQUIRE(_dependencyMap[0], './_getNative');

  var nativeCreate = getNative(Object, 'create');
  module.exports = nativeCreate;
},53,[35],"node_modules/lodash/_nativeCreate.js");
__d(function (global, _$$_REQUIRE, 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;
},54,[],"node_modules/lodash/_hashDelete.js");
__d(function (global, _$$_REQUIRE, 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;
},55,[53],"node_modules/lodash/_hashGet.js");
__d(function (global, _$$_REQUIRE, 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;
},56,[53],"node_modules/lodash/_hashHas.js");
__d(function (global, _$$_REQUIRE, 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;
},57,[53],"node_modules/lodash/_hashSet.js");
__d(function (global, _$$_REQUIRE, 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;
},58,[59],"node_modules/lodash/_mapCacheDelete.js");
__d(function (global, _$$_REQUIRE, 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;
},59,[60],"node_modules/lodash/_getMapData.js");
__d(function (global, _$$_REQUIRE, 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;
},60,[],"node_modules/lodash/_isKeyable.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  var getMapData = _$$_REQUIRE(_dependencyMap[0], './_getMapData');

  function mapCacheGet(key) {
    return getMapData(this, key).get(key);
  }

  module.exports = mapCacheGet;
},61,[59],"node_modules/lodash/_mapCacheGet.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  var getMapData = _$$_REQUIRE(_dependencyMap[0], './_getMapData');

  function mapCacheHas(key) {
    return getMapData(this, key).has(key);
  }

  module.exports = mapCacheHas;
},62,[59],"node_modules/lodash/_mapCacheHas.js");
__d(function (global, _$$_REQUIRE, 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;
},63,[59],"node_modules/lodash/_mapCacheSet.js");
__d(function (global, _$$_REQUIRE, 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;
},64,[65,89],"node_modules/lodash/_baseIsEqual.js");
__d(function (global, _$$_REQUIRE, 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;
},65,[20,66,72,76,103,80,90,93],"node_modules/lodash/_baseIsEqualDeep.js");
__d(function (global, _$$_REQUIRE, 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;
},66,[67,70,71],"node_modules/lodash/_equalArrays.js");
__d(function (global, _$$_REQUIRE, 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;
},67,[49,68,69],"node_modules/lodash/_SetCache.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  var HASH_UNDEFINED = '__lodash_hash_undefined__';

  function setCacheAdd(value) {
    this.__data__.set(value, HASH_UNDEFINED);

    return this;
  }

  module.exports = setCacheAdd;
},68,[],"node_modules/lodash/_setCacheAdd.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  function setCacheHas(value) {
    return this.__data__.has(value);
  }

  module.exports = setCacheHas;
},69,[],"node_modules/lodash/_setCacheHas.js");
__d(function (global, _$$_REQUIRE, 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;
},70,[],"node_modules/lodash/_arraySome.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  function cacheHas(cache, key) {
    return cache.has(key);
  }

  module.exports = cacheHas;
},71,[],"node_modules/lodash/_cacheHas.js");
__d(function (global, _$$_REQUIRE, 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;
},72,[39,73,25,66,74,75],"node_modules/lodash/_equalByTag.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  var root = _$$_REQUIRE(_dependencyMap[0], './_root');

  var Uint8Array = root.Uint8Array;
  module.exports = Uint8Array;
},73,[40],"node_modules/lodash/_Uint8Array.js");
__d(function (global, _$$_REQUIRE, 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;
},74,[],"node_modules/lodash/_mapToArray.js");
__d(function (global, _$$_REQUIRE, 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;
},75,[],"node_modules/lodash/_setToArray.js");
__d(function (global, _$$_REQUIRE, 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;
},76,[77],"node_modules/lodash/_equalObjects.js");
__d(function (global, _$$_REQUIRE, 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;
},77,[78,81,84],"node_modules/lodash/_getAllKeys.js");
__d(function (global, _$$_REQUIRE, 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;
},78,[79,80],"node_modules/lodash/_baseGetAllKeys.js");
__d(function (global, _$$_REQUIRE, 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;
},79,[],"node_modules/lodash/_arrayPush.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  var isArray = Array.isArray;
  module.exports = isArray;
},80,[],"node_modules/lodash/isArray.js");
__d(function (global, _$$_REQUIRE, 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;
},81,[82,83],"node_modules/lodash/_getSymbols.js");
__d(function (global, _$$_REQUIRE, 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;
},82,[],"node_modules/lodash/_arrayFilter.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  function stubArray() {
    return [];
  }

  module.exports = stubArray;
},83,[],"node_modules/lodash/stubArray.js");
__d(function (global, _$$_REQUIRE, 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;
},84,[85,98,102],"node_modules/lodash/keys.js");
__d(function (global, _$$_REQUIRE, 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;
},85,[86,87,80,90,92,93],"node_modules/lodash/_arrayLikeKeys.js");
__d(function (global, _$$_REQUIRE, 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;
},86,[],"node_modules/lodash/_baseTimes.js");
__d(function (global, _$$_REQUIRE, 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;
},87,[88,89],"node_modules/lodash/isArguments.js");
__d(function (global, _$$_REQUIRE, 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;
},88,[38,89],"node_modules/lodash/_baseIsArguments.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  function isObjectLike(value) {
    return value != null && typeof value == 'object';
  }

  module.exports = isObjectLike;
},89,[],"node_modules/lodash/isObjectLike.js");
__d(function (global, _$$_REQUIRE, 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;
},90,[40,91],"node_modules/lodash/isBuffer.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  function stubFalse() {
    return false;
  }

  module.exports = stubFalse;
},91,[],"node_modules/lodash/stubFalse.js");
__d(function (global, _$$_REQUIRE, 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;
},92,[],"node_modules/lodash/_isIndex.js");
__d(function (global, _$$_REQUIRE, 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;
},93,[94,96,97],"node_modules/lodash/isTypedArray.js");
__d(function (global, _$$_REQUIRE, 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;
},94,[38,95,89],"node_modules/lodash/_baseIsTypedArray.js");
__d(function (global, _$$_REQUIRE, 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;
},95,[],"node_modules/lodash/isLength.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  function baseUnary(func) {
    return function (value) {
      return func(value);
    };
  }

  module.exports = baseUnary;
},96,[],"node_modules/lodash/_baseUnary.js");
__d(function (global, _$$_REQUIRE, 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;
},97,[41],"node_modules/lodash/_nodeUtil.js");
__d(function (global, _$$_REQUIRE, 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;
},98,[99,100],"node_modules/lodash/_baseKeys.js");
__d(function (global, _$$_REQUIRE, 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;
},99,[],"node_modules/lodash/_isPrototype.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  var overArg = _$$_REQUIRE(_dependencyMap[0], './_overArg');

  var nativeKeys = overArg(Object.keys, Object);
  module.exports = nativeKeys;
},100,[101],"node_modules/lodash/_nativeKeys.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  function overArg(func, transform) {
    return function (arg) {
      return func(transform(arg));
    };
  }

  module.exports = overArg;
},101,[],"node_modules/lodash/_overArg.js");
__d(function (global, _$$_REQUIRE, 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;
},102,[37,95],"node_modules/lodash/isArrayLike.js");
__d(function (global, _$$_REQUIRE, 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;
},103,[104,34,105,106,107,38,47],"node_modules/lodash/_getTag.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  var getNative = _$$_REQUIRE(_dependencyMap[0], './_getNative'),
      root = _$$_REQUIRE(_dependencyMap[1], './_root');

  var DataView = getNative(root, 'DataView');
  module.exports = DataView;
},104,[35,40],"node_modules/lodash/_DataView.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  var getNative = _$$_REQUIRE(_dependencyMap[0], './_getNative'),
      root = _$$_REQUIRE(_dependencyMap[1], './_root');

  var Promise = getNative(root, 'Promise');
  module.exports = Promise;
},105,[35,40],"node_modules/lodash/_Promise.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  var getNative = _$$_REQUIRE(_dependencyMap[0], './_getNative'),
      root = _$$_REQUIRE(_dependencyMap[1], './_root');

  var Set = getNative(root, 'Set');
  module.exports = Set;
},106,[35,40],"node_modules/lodash/_Set.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  var getNative = _$$_REQUIRE(_dependencyMap[0], './_getNative'),
      root = _$$_REQUIRE(_dependencyMap[1], './_root');

  var WeakMap = getNative(root, 'WeakMap');
  module.exports = WeakMap;
},107,[35,40],"node_modules/lodash/_WeakMap.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  var isStrictComparable = _$$_REQUIRE(_dependencyMap[0], './_isStrictComparable'),
      keys = _$$_REQUIRE(_dependencyMap[1], './keys');

  function getMatchData(object) {
    var result = keys(object),
        length = result.length;

    while (length--) {
      var key = result[length],
          value = object[key];
      result[length] = [key, value, isStrictComparable(value)];
    }

    return result;
  }

  module.exports = getMatchData;
},108,[109,84],"node_modules/lodash/_getMatchData.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  var isObject = _$$_REQUIRE(_dependencyMap[0], './isObject');

  function isStrictComparable(value) {
    return value === value && !isObject(value);
  }

  module.exports = isStrictComparable;
},109,[44],"node_modules/lodash/_isStrictComparable.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  function matchesStrictComparable(key, srcValue) {
    return function (object) {
      if (object == null) {
        return false;
      }

      return object[key] === srcValue && (srcValue !== undefined || key in Object(object));
    };
  }

  module.exports = matchesStrictComparable;
},110,[],"node_modules/lodash/_matchesStrictComparable.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  var baseIsEqual = _$$_REQUIRE(_dependencyMap[0], './_baseIsEqual'),
      get = _$$_REQUIRE(_dependencyMap[1], './get'),
      hasIn = _$$_REQUIRE(_dependencyMap[2], './hasIn'),
      isKey = _$$_REQUIRE(_dependencyMap[3], './_isKey'),
      isStrictComparable = _$$_REQUIRE(_dependencyMap[4], './_isStrictComparable'),
      matchesStrictComparable = _$$_REQUIRE(_dependencyMap[5], './_matchesStrictComparable'),
      toKey = _$$_REQUIRE(_dependencyMap[6], './_toKey');

  var COMPARE_PARTIAL_FLAG = 1,
      COMPARE_UNORDERED_FLAG = 2;

  function baseMatchesProperty(path, srcValue) {
    if (isKey(path) && isStrictComparable(srcValue)) {
      return matchesStrictComparable(toKey(path), srcValue);
    }

    return function (object) {
      var objValue = get(object, path);
      return objValue === undefined && objValue === srcValue ? hasIn(object, path) : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);
    };
  }

  module.exports = baseMatchesProperty;
},111,[64,112,124,115,109,110,123],"node_modules/lodash/_baseMatchesProperty.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  var baseGet = _$$_REQUIRE(_dependencyMap[0], './_baseGet');

  function get(object, path, defaultValue) {
    var result = object == null ? undefined : baseGet(object, path);
    return result === undefined ? defaultValue : result;
  }

  module.exports = get;
},112,[113],"node_modules/lodash/get.js");
__d(function (global, _$$_REQUIRE, 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;
},113,[114,123],"node_modules/lodash/_baseGet.js");
__d(function (global, _$$_REQUIRE, 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;
},114,[80,115,117,120],"node_modules/lodash/_castPath.js");
__d(function (global, _$$_REQUIRE, 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;
},115,[80,116],"node_modules/lodash/_isKey.js");
__d(function (global, _$$_REQUIRE, 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;
},116,[38,89],"node_modules/lodash/isSymbol.js");
__d(function (global, _$$_REQUIRE, 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;
},117,[118],"node_modules/lodash/_stringToPath.js");
__d(function (global, _$$_REQUIRE, 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;
},118,[119],"node_modules/lodash/_memoizeCapped.js");
__d(function (global, _$$_REQUIRE, 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;
},119,[49],"node_modules/lodash/memoize.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  var baseToString = _$$_REQUIRE(_dependencyMap[0], './_baseToString');

  function toString(value) {
    return value == null ? '' : baseToString(value);
  }

  module.exports = toString;
},120,[121],"node_modules/lodash/toString.js");
__d(function (global, _$$_REQUIRE, 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;
},121,[39,122,80,116],"node_modules/lodash/_baseToString.js");
__d(function (global, _$$_REQUIRE, 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;
},122,[],"node_modules/lodash/_arrayMap.js");
__d(function (global, _$$_REQUIRE, 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;
},123,[116],"node_modules/lodash/_toKey.js");
__d(function (global, _$$_REQUIRE, 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;
},124,[125,126],"node_modules/lodash/hasIn.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  function baseHasIn(object, key) {
    return object != null && key in Object(object);
  }

  module.exports = baseHasIn;
},125,[],"node_modules/lodash/_baseHasIn.js");
__d(function (global, _$$_REQUIRE, 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;
},126,[114,87,80,92,95,123],"node_modules/lodash/_hasPath.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  function identity(value) {
    return value;
  }

  module.exports = identity;
},127,[],"node_modules/lodash/identity.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  var baseProperty = _$$_REQUIRE(_dependencyMap[0], './_baseProperty'),
      basePropertyDeep = _$$_REQUIRE(_dependencyMap[1], './_basePropertyDeep'),
      isKey = _$$_REQUIRE(_dependencyMap[2], './_isKey'),
      toKey = _$$_REQUIRE(_dependencyMap[3], './_toKey');

  function property(path) {
    return isKey(path) ? baseProperty(toKey(path)) : basePropertyDeep(path);
  }

  module.exports = property;
},128,[129,130,115,123],"node_modules/lodash/property.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  function baseProperty(key) {
    return function (object) {
      return object == null ? undefined : object[key];
    };
  }

  module.exports = baseProperty;
},129,[],"node_modules/lodash/_baseProperty.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  var baseGet = _$$_REQUIRE(_dependencyMap[0], './_baseGet');

  function basePropertyDeep(path) {
    return function (object) {
      return baseGet(object, path);
    };
  }

  module.exports = basePropertyDeep;
},130,[113],"node_modules/lodash/_basePropertyDeep.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  var baseFindIndex = _$$_REQUIRE(_dependencyMap[0], './_baseFindIndex'),
      baseIteratee = _$$_REQUIRE(_dependencyMap[1], './_baseIteratee'),
      toInteger = _$$_REQUIRE(_dependencyMap[2], './toInteger');

  var nativeMax = Math.max;

  function findIndex(array, predicate, fromIndex) {
    var length = array == null ? 0 : array.length;

    if (!length) {
      return -1;
    }

    var index = fromIndex == null ? 0 : toInteger(fromIndex);

    if (index < 0) {
      index = nativeMax(length + index, 0);
    }

    return baseFindIndex(array, baseIteratee(predicate, 3), index);
  }

  module.exports = findIndex;
},131,[132,17,133],"node_modules/lodash/findIndex.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  function baseFindIndex(array, predicate, fromIndex, fromRight) {
    var length = array.length,
        index = fromIndex + (fromRight ? 1 : -1);

    while (fromRight ? index-- : ++index < length) {
      if (predicate(array[index], index, array)) {
        return index;
      }
    }

    return -1;
  }

  module.exports = baseFindIndex;
},132,[],"node_modules/lodash/_baseFindIndex.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  var toFinite = _$$_REQUIRE(_dependencyMap[0], './toFinite');

  function toInteger(value) {
    var result = toFinite(value),
        remainder = result % 1;
    return result === result ? remainder ? result - remainder : result : 0;
  }

  module.exports = toInteger;
},133,[134],"node_modules/lodash/toInteger.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  var toNumber = _$$_REQUIRE(_dependencyMap[0], './toNumber');

  var INFINITY = 1 / 0,
      MAX_INTEGER = 1.7976931348623157e+308;

  function toFinite(value) {
    if (!value) {
      return value === 0 ? value : 0;
    }

    value = toNumber(value);

    if (value === INFINITY || value === -INFINITY) {
      var sign = value < 0 ? -1 : 1;
      return sign * MAX_INTEGER;
    }

    return value === value ? value : 0;
  }

  module.exports = toFinite;
},134,[135],"node_modules/lodash/toFinite.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  var isObject = _$$_REQUIRE(_dependencyMap[0], './isObject'),
      isSymbol = _$$_REQUIRE(_dependencyMap[1], './isSymbol');

  var NAN = 0 / 0;
  var reTrim = /^\s+|\s+$/g;
  var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
  var reIsBinary = /^0b[01]+$/i;
  var reIsOctal = /^0o[0-7]+$/i;
  var freeParseInt = parseInt;

  function toNumber(value) {
    if (typeof value == 'number') {
      return value;
    }

    if (isSymbol(value)) {
      return NAN;
    }

    if (isObject(value)) {
      var other = typeof value.valueOf == 'function' ? value.valueOf() : value;
      value = isObject(other) ? other + '' : other;
    }

    if (typeof value != 'string') {
      return value === 0 ? value : +value;
    }

    value = value.replace(reTrim, '');
    var isBinary = reIsBinary.test(value);
    return isBinary || reIsOctal.test(value) ? freeParseInt(value.slice(2), isBinary ? 2 : 8) : reIsBadHex.test(value) ? NAN : +value;
  }

  module.exports = toNumber;
},135,[44,116],"node_modules/lodash/toNumber.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

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

  var _assign = _$$_REQUIRE(_dependencyMap[0], 'lodash/assign');

  var _assign2 = _interopRequireDefault(_assign);

  var _difference = _$$_REQUIRE(_dependencyMap[1], 'lodash/difference');

  var _difference2 = _interopRequireDefault(_difference);

  function _interopRequireDefault(obj) {
    return obj && obj.__esModule ? obj : {
      default: obj
    };
  }

  function createPrototypeProxy() {
    var proxy = {};
    var current = null;
    var mountedInstances = [];

    function proxyToString(name) {
      return function toString() {
        if (typeof current[name] === 'function') {
          return current[name].toString();
        } else {
          return '<method was deleted>';
        }
      };
    }

    function proxyMethod(name) {
      var proxiedMethod = function proxiedMethod() {
        if (typeof current[name] === 'function') {
          return current[name].apply(this, arguments);
        }
      };

      (0, _assign2.default)(proxiedMethod, current[name]);
      proxiedMethod.toString = proxyToString(name);
      return proxiedMethod;
    }

    function proxiedComponentDidMount() {
      mountedInstances.push(this);

      if (typeof current.componentDidMount === 'function') {
        return current.componentDidMount.apply(this, arguments);
      }
    }

    proxiedComponentDidMount.toString = proxyToString('componentDidMount');

    function proxiedComponentWillUnmount() {
      var index = mountedInstances.indexOf(this);

      if (index !== -1) {
        mountedInstances.splice(index, 1);
      }

      if (typeof current.componentWillUnmount === 'function') {
        return current.componentWillUnmount.apply(this, arguments);
      }
    }

    proxiedComponentWillUnmount.toString = proxyToString('componentWillUnmount');

    function defineProxyProperty(name, descriptor) {
      Object.defineProperty(proxy, name, descriptor);
    }

    function defineProxyPropertyWithValue(name, value) {
      var _ref = Object.getOwnPropertyDescriptor(current, name) || {};

      var _ref$enumerable = _ref.enumerable;
      var enumerable = _ref$enumerable === undefined ? false : _ref$enumerable;
      var _ref$writable = _ref.writable;
      var writable = _ref$writable === undefined ? true : _ref$writable;
      defineProxyProperty(name, {
        configurable: true,
        enumerable: enumerable,
        writable: writable,
        value: value
      });
    }

    function createAutoBindMap() {
      if (!current.__reactAutoBindMap) {
        return;
      }

      var __reactAutoBindMap = {};

      for (var name in current.__reactAutoBindMap) {
        if (typeof proxy[name] === 'function' && current.__reactAutoBindMap.hasOwnProperty(name)) {
          __reactAutoBindMap[name] = proxy[name];
        }
      }

      return __reactAutoBindMap;
    }

    function createAutoBindPairs() {
      var __reactAutoBindPairs = [];

      for (var i = 0; i < current.__reactAutoBindPairs.length; i += 2) {
        var name = current.__reactAutoBindPairs[i];
        var method = proxy[name];

        if (typeof method === 'function') {
          __reactAutoBindPairs.push(name, method);
        }
      }

      return __reactAutoBindPairs;
    }

    function update(next) {
      current = next;
      var currentNames = Object.getOwnPropertyNames(current);
      var previousName = Object.getOwnPropertyNames(proxy);
      var removedNames = (0, _difference2.default)(previousName, currentNames);
      removedNames.forEach(function (name) {
        delete proxy[name];
      });
      currentNames.forEach(function (name) {
        var descriptor = Object.getOwnPropertyDescriptor(current, name);

        if (typeof descriptor.value === 'function') {
          defineProxyPropertyWithValue(name, proxyMethod(name));
        } else {
          defineProxyProperty(name, descriptor);
        }
      });
      defineProxyPropertyWithValue('componentDidMount', proxiedComponentDidMount);
      defineProxyPropertyWithValue('componentWillUnmount', proxiedComponentWillUnmount);

      if (current.hasOwnProperty('__reactAutoBindMap')) {
        defineProxyPropertyWithValue('__reactAutoBindMap', createAutoBindMap());
      }

      if (current.hasOwnProperty('__reactAutoBindPairs')) {
        defineProxyPropertyWithValue('__reactAutoBindPairs', createAutoBindPairs());
      }

      proxy.__proto__ = next;
      return mountedInstances;
    }

    function get() {
      return proxy;
    }

    return {
      update: update,
      get: get
    };
  }

  ;
},136,[137,151],"node_modules/react-proxy/modules/createPrototypeProxy.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  var assignValue = _$$_REQUIRE(_dependencyMap[0], './_assignValue'),
      copyObject = _$$_REQUIRE(_dependencyMap[1], './_copyObject'),
      createAssigner = _$$_REQUIRE(_dependencyMap[2], './_createAssigner'),
      isArrayLike = _$$_REQUIRE(_dependencyMap[3], './isArrayLike'),
      isPrototype = _$$_REQUIRE(_dependencyMap[4], './_isPrototype'),
      keys = _$$_REQUIRE(_dependencyMap[5], './keys');

  var objectProto = Object.prototype;
  var hasOwnProperty = objectProto.hasOwnProperty;
  var assign = createAssigner(function (object, source) {
    if (isPrototype(source) || isArrayLike(source)) {
      copyObject(source, keys(source), object);
      return;
    }

    for (var key in source) {
      if (hasOwnProperty.call(source, key)) {
        assignValue(object, key, source[key]);
      }
    }
  });
  module.exports = assign;
},137,[138,141,142,102,99,84],"node_modules/lodash/assign.js");
__d(function (global, _$$_REQUIRE, 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;
},138,[139,25],"node_modules/lodash/_assignValue.js");
__d(function (global, _$$_REQUIRE, 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;
},139,[140],"node_modules/lodash/_baseAssignValue.js");
__d(function (global, _$$_REQUIRE, 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;
},140,[35],"node_modules/lodash/_defineProperty.js");
__d(function (global, _$$_REQUIRE, 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;
},141,[138,139],"node_modules/lodash/_copyObject.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  var baseRest = _$$_REQUIRE(_dependencyMap[0], './_baseRest'),
      isIterateeCall = _$$_REQUIRE(_dependencyMap[1], './_isIterateeCall');

  function createAssigner(assigner) {
    return baseRest(function (object, sources) {
      var index = -1,
          length = sources.length,
          customizer = length > 1 ? sources[length - 1] : undefined,
          guard = length > 2 ? sources[2] : undefined;
      customizer = assigner.length > 3 && typeof customizer == 'function' ? (length--, customizer) : undefined;

      if (guard && isIterateeCall(sources[0], sources[1], guard)) {
        customizer = length < 3 ? undefined : customizer;
        length = 1;
      }

      object = Object(object);

      while (++index < length) {
        var source = sources[index];

        if (source) {
          assigner(object, source, index, customizer);
        }
      }

      return object;
    });
  }

  module.exports = createAssigner;
},142,[143,150],"node_modules/lodash/_createAssigner.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  var identity = _$$_REQUIRE(_dependencyMap[0], './identity'),
      overRest = _$$_REQUIRE(_dependencyMap[1], './_overRest'),
      setToString = _$$_REQUIRE(_dependencyMap[2], './_setToString');

  function baseRest(func, start) {
    return setToString(overRest(func, start, identity), func + '');
  }

  module.exports = baseRest;
},143,[127,144,146],"node_modules/lodash/_baseRest.js");
__d(function (global, _$$_REQUIRE, 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;
},144,[145],"node_modules/lodash/_overRest.js");
__d(function (global, _$$_REQUIRE, 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;
},145,[],"node_modules/lodash/_apply.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  var baseSetToString = _$$_REQUIRE(_dependencyMap[0], './_baseSetToString'),
      shortOut = _$$_REQUIRE(_dependencyMap[1], './_shortOut');

  var setToString = shortOut(baseSetToString);
  module.exports = setToString;
},146,[147,149],"node_modules/lodash/_setToString.js");
__d(function (global, _$$_REQUIRE, 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;
},147,[148,140,127],"node_modules/lodash/_baseSetToString.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  function constant(value) {
    return function () {
      return value;
    };
  }

  module.exports = constant;
},148,[],"node_modules/lodash/constant.js");
__d(function (global, _$$_REQUIRE, 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;
},149,[],"node_modules/lodash/_shortOut.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  var eq = _$$_REQUIRE(_dependencyMap[0], './eq'),
      isArrayLike = _$$_REQUIRE(_dependencyMap[1], './isArrayLike'),
      isIndex = _$$_REQUIRE(_dependencyMap[2], './_isIndex'),
      isObject = _$$_REQUIRE(_dependencyMap[3], './isObject');

  function isIterateeCall(value, index, object) {
    if (!isObject(object)) {
      return false;
    }

    var type = typeof index;

    if (type == 'number' ? isArrayLike(object) && isIndex(index, object.length) : type == 'string' && index in object) {
      return eq(object[index], value);
    }

    return false;
  }

  module.exports = isIterateeCall;
},150,[25,102,92,44],"node_modules/lodash/_isIterateeCall.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  var baseDifference = _$$_REQUIRE(_dependencyMap[0], './_baseDifference'),
      baseFlatten = _$$_REQUIRE(_dependencyMap[1], './_baseFlatten'),
      baseRest = _$$_REQUIRE(_dependencyMap[2], './_baseRest'),
      isArrayLikeObject = _$$_REQUIRE(_dependencyMap[3], './isArrayLikeObject');

  var difference = baseRest(function (array, values) {
    return isArrayLikeObject(array) ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true)) : [];
  });
  module.exports = difference;
},151,[152,158,143,160],"node_modules/lodash/difference.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  var SetCache = _$$_REQUIRE(_dependencyMap[0], './_SetCache'),
      arrayIncludes = _$$_REQUIRE(_dependencyMap[1], './_arrayIncludes'),
      arrayIncludesWith = _$$_REQUIRE(_dependencyMap[2], './_arrayIncludesWith'),
      arrayMap = _$$_REQUIRE(_dependencyMap[3], './_arrayMap'),
      baseUnary = _$$_REQUIRE(_dependencyMap[4], './_baseUnary'),
      cacheHas = _$$_REQUIRE(_dependencyMap[5], './_cacheHas');

  var LARGE_ARRAY_SIZE = 200;

  function baseDifference(array, values, iteratee, comparator) {
    var index = -1,
        includes = arrayIncludes,
        isCommon = true,
        length = array.length,
        result = [],
        valuesLength = values.length;

    if (!length) {
      return result;
    }

    if (iteratee) {
      values = arrayMap(values, baseUnary(iteratee));
    }

    if (comparator) {
      includes = arrayIncludesWith;
      isCommon = false;
    } else if (values.length >= LARGE_ARRAY_SIZE) {
      includes = cacheHas;
      isCommon = false;
      values = new SetCache(values);
    }

    outer: while (++index < length) {
      var value = array[index],
          computed = iteratee == null ? value : iteratee(value);
      value = comparator || value !== 0 ? value : 0;

      if (isCommon && computed === computed) {
        var valuesIndex = valuesLength;

        while (valuesIndex--) {
          if (values[valuesIndex] === computed) {
            continue outer;
          }
        }

        result.push(value);
      } else if (!includes(values, computed, comparator)) {
        result.push(value);
      }
    }

    return result;
  }

  module.exports = baseDifference;
},152,[67,153,157,122,96,71],"node_modules/lodash/_baseDifference.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  var baseIndexOf = _$$_REQUIRE(_dependencyMap[0], './_baseIndexOf');

  function arrayIncludes(array, value) {
    var length = array == null ? 0 : array.length;
    return !!length && baseIndexOf(array, value, 0) > -1;
  }

  module.exports = arrayIncludes;
},153,[154],"node_modules/lodash/_arrayIncludes.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  var baseFindIndex = _$$_REQUIRE(_dependencyMap[0], './_baseFindIndex'),
      baseIsNaN = _$$_REQUIRE(_dependencyMap[1], './_baseIsNaN'),
      strictIndexOf = _$$_REQUIRE(_dependencyMap[2], './_strictIndexOf');

  function baseIndexOf(array, value, fromIndex) {
    return value === value ? strictIndexOf(array, value, fromIndex) : baseFindIndex(array, baseIsNaN, fromIndex);
  }

  module.exports = baseIndexOf;
},154,[132,155,156],"node_modules/lodash/_baseIndexOf.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  function baseIsNaN(value) {
    return value !== value;
  }

  module.exports = baseIsNaN;
},155,[],"node_modules/lodash/_baseIsNaN.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  function strictIndexOf(array, value, fromIndex) {
    var index = fromIndex - 1,
        length = array.length;

    while (++index < length) {
      if (array[index] === value) {
        return index;
      }
    }

    return -1;
  }

  module.exports = strictIndexOf;
},156,[],"node_modules/lodash/_strictIndexOf.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  function arrayIncludesWith(array, value, comparator) {
    var index = -1,
        length = array == null ? 0 : array.length;

    while (++index < length) {
      if (comparator(value, array[index])) {
        return true;
      }
    }

    return false;
  }

  module.exports = arrayIncludesWith;
},157,[],"node_modules/lodash/_arrayIncludesWith.js");
__d(function (global, _$$_REQUIRE, 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;
},158,[79,159],"node_modules/lodash/_baseFlatten.js");
__d(function (global, _$$_REQUIRE, 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;
},159,[39,87,80],"node_modules/lodash/_isFlattenable.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  var isArrayLike = _$$_REQUIRE(_dependencyMap[0], './isArrayLike'),
      isObjectLike = _$$_REQUIRE(_dependencyMap[1], './isObjectLike');

  function isArrayLikeObject(value) {
    return isObjectLike(value) && isArrayLike(value);
  }

  module.exports = isArrayLikeObject;
},160,[102,89],"node_modules/lodash/isArrayLikeObject.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

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

  function bindAutoBindMethod(component, method) {
    var boundMethod = method.bind(component);
    boundMethod.__reactBoundContext = component;
    boundMethod.__reactBoundMethod = method;
    boundMethod.__reactBoundArguments = null;
    var componentName = component.constructor.displayName,
        _bind = boundMethod.bind;

    boundMethod.bind = function (newThis) {
      var args = Array.prototype.slice.call(arguments, 1);

      if (newThis !== component && newThis !== null) {
        console.warn('bind(): React component methods may only be bound to the ' + 'component instance. See ' + componentName);
      } else if (!args.length) {
        console.warn('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 ' + componentName);
        return boundMethod;
      }

      var reboundMethod = _bind.apply(boundMethod, arguments);

      reboundMethod.__reactBoundContext = component;
      reboundMethod.__reactBoundMethod = method;
      reboundMethod.__reactBoundArguments = args;
      return reboundMethod;
    };

    return boundMethod;
  }

  function bindAutoBindMethodsFromMap(component) {
    for (var autoBindKey in component.__reactAutoBindMap) {
      if (!component.__reactAutoBindMap.hasOwnProperty(autoBindKey)) {
        return;
      }

      if (component.hasOwnProperty(autoBindKey) && component[autoBindKey].__reactBoundContext === component) {
        continue;
      }

      var method = component.__reactAutoBindMap[autoBindKey];
      component[autoBindKey] = bindAutoBindMethod(component, method);
    }
  }

  function bindAutoBindMethods(component) {
    if (component.__reactAutoBindPairs) {
      bindAutoBindMethodsFromArray(component);
    } else if (component.__reactAutoBindMap) {
      bindAutoBindMethodsFromMap(component);
    }
  }

  function bindAutoBindMethodsFromArray(component) {
    var pairs = component.__reactAutoBindPairs;

    if (!pairs) {
      return;
    }

    for (var i = 0; i < pairs.length; i += 2) {
      var autoBindKey = pairs[i];

      if (component.hasOwnProperty(autoBindKey) && component[autoBindKey].__reactBoundContext === component) {
        continue;
      }

      var method = pairs[i + 1];
      component[autoBindKey] = bindAutoBindMethod(component, method);
    }
  }
},161,[],"node_modules/react-proxy/modules/bindAutoBindMethods.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

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

  function shouldDeleteClassicInstanceMethod(component, name) {
    if (component.__reactAutoBindMap && component.__reactAutoBindMap.hasOwnProperty(name)) {
      return false;
    }

    if (component.__reactAutoBindPairs && component.__reactAutoBindPairs.indexOf(name) >= 0) {
      return false;
    }

    if (component[name].__reactBoundArguments !== null) {
      return false;
    }

    return true;
  }

  function shouldDeleteModernInstanceMethod(component, name) {
    var prototype = component.constructor.prototype;
    var prototypeDescriptor = Object.getOwnPropertyDescriptor(prototype, name);

    if (!prototypeDescriptor || !prototypeDescriptor.get) {
      return false;
    }

    if (prototypeDescriptor.get().length !== component[name].length) {
      return false;
    }

    return true;
  }

  function shouldDeleteInstanceMethod(component, name) {
    var descriptor = Object.getOwnPropertyDescriptor(component, name);

    if (typeof descriptor.value !== 'function') {
      return;
    }

    if (component.__reactAutoBindMap || component.__reactAutoBindPairs) {
      return shouldDeleteClassicInstanceMethod(component, name);
    } else {
      return shouldDeleteModernInstanceMethod(component, name);
    }
  }

  function deleteUnknownAutoBindMethods(component) {
    var names = Object.getOwnPropertyNames(component);
    names.forEach(function (name) {
      if (shouldDeleteInstanceMethod(component, name)) {
        delete component[name];
      }
    });
  }
},162,[],"node_modules/react-proxy/modules/deleteUnknownAutoBindMethods.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  exports.__esModule = true;
  exports['default'] = getForceUpdate;

  function traverseRenderedChildren(internalInstance, callback, argument) {
    callback(internalInstance, argument);

    if (internalInstance._renderedComponent) {
      traverseRenderedChildren(internalInstance._renderedComponent, callback, argument);
    } else {
      for (var key in internalInstance._renderedChildren) {
        if (internalInstance._renderedChildren.hasOwnProperty(key)) {
          traverseRenderedChildren(internalInstance._renderedChildren[key], callback, argument);
        }
      }
    }
  }

  function setPendingForceUpdate(internalInstance) {
    if (internalInstance._pendingForceUpdate === false) {
      internalInstance._pendingForceUpdate = true;
    }
  }

  function forceUpdateIfPending(internalInstance, React) {
    if (internalInstance._pendingForceUpdate === true) {
      var publicInstance = internalInstance._instance;
      React.Component.prototype.forceUpdate.call(publicInstance);
    }
  }

  function deepForceUpdateStack(instance, React) {
    var internalInstance = instance._reactInternalInstance;
    traverseRenderedChildren(internalInstance, setPendingForceUpdate);
    traverseRenderedChildren(internalInstance, forceUpdateIfPending, React);
  }

  function deepForceUpdate(instance, React) {
    var root = instance._reactInternalFiber || instance._reactInternalInstance;

    if (typeof root.tag !== 'number') {
      return deepForceUpdateStack(instance, React);
    }

    var node = root;

    while (true) {
      if (node.stateNode !== null && typeof node.type === 'function') {
        var publicInstance = node.stateNode;
        var updater = publicInstance.updater;

        if (typeof publicInstance.forceUpdate === 'function') {
          publicInstance.forceUpdate();
        } else if (updater && typeof updater.enqueueForceUpdate === 'function') {
          updater.enqueueForceUpdate(publicInstance);
        }
      }

      if (node.child) {
        node.child['return'] = node;
        node = node.child;
        continue;
      }

      if (node === root) {
        return undefined;
      }

      while (!node.sibling) {
        if (!node['return'] || node['return'] === root) {
          return undefined;
        }

        node = node['return'];
      }

      node.sibling['return'] = node['return'];
      node = node.sibling;
    }
  }

  function getForceUpdate(React) {
    return function (instance) {
      deepForceUpdate(instance, React);
    };
  }

  module.exports = exports['default'];
},163,[],"node_modules/react-deep-force-update/lib/index.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  var win;

  if (typeof window !== "undefined") {
    win = window;
  } else if (typeof global !== "undefined") {
    win = global;
  } else if (typeof self !== "undefined") {
    win = self;
  } else {
    win = {};
  }

  module.exports = win;
},164,[],"node_modules/global/window.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

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

  var ReactNative = {
    get AccessibilityInfo() {
      return _$$_REQUIRE(_dependencyMap[1], 'AccessibilityInfo');
    },

    get ActivityIndicator() {
      return _$$_REQUIRE(_dependencyMap[2], 'ActivityIndicator');
    },

    get ART() {
      return _$$_REQUIRE(_dependencyMap[3], 'ReactNativeART');
    },

    get Button() {
      return _$$_REQUIRE(_dependencyMap[4], 'Button');
    },

    get CheckBox() {
      return _$$_REQUIRE(_dependencyMap[5], 'CheckBox');
    },

    get DatePickerIOS() {
      return _$$_REQUIRE(_dependencyMap[6], 'DatePickerIOS');
    },

    get DrawerLayoutAndroid() {
      return _$$_REQUIRE(_dependencyMap[7], 'DrawerLayoutAndroid');
    },

    get FlatList() {
      return _$$_REQUIRE(_dependencyMap[8], 'FlatList');
    },

    get Image() {
      return _$$_REQUIRE(_dependencyMap[9], 'Image');
    },

    get ImageBackground() {
      return _$$_REQUIRE(_dependencyMap[10], 'ImageBackground');
    },

    get ImageEditor() {
      return _$$_REQUIRE(_dependencyMap[11], 'ImageEditor');
    },

    get ImageStore() {
      return _$$_REQUIRE(_dependencyMap[12], 'ImageStore');
    },

    get InputAccessoryView() {
      return _$$_REQUIRE(_dependencyMap[13], 'InputAccessoryView');
    },

    get KeyboardAvoidingView() {
      return _$$_REQUIRE(_dependencyMap[14], 'KeyboardAvoidingView');
    },

    get ListView() {
      return _$$_REQUIRE(_dependencyMap[15], 'ListView');
    },

    get MaskedViewIOS() {
      return _$$_REQUIRE(_dependencyMap[16], 'MaskedViewIOS');
    },

    get Modal() {
      return _$$_REQUIRE(_dependencyMap[17], 'Modal');
    },

    get NavigatorIOS() {
      return _$$_REQUIRE(_dependencyMap[18], 'NavigatorIOS');
    },

    get Picker() {
      return _$$_REQUIRE(_dependencyMap[19], 'Picker');
    },

    get PickerIOS() {
      return _$$_REQUIRE(_dependencyMap[20], 'PickerIOS');
    },

    get ProgressBarAndroid() {
      return _$$_REQUIRE(_dependencyMap[21], 'ProgressBarAndroid');
    },

    get ProgressViewIOS() {
      return _$$_REQUIRE(_dependencyMap[22], 'ProgressViewIOS');
    },

    get SafeAreaView() {
      return _$$_REQUIRE(_dependencyMap[23], 'SafeAreaView');
    },

    get ScrollView() {
      return _$$_REQUIRE(_dependencyMap[24], 'ScrollView');
    },

    get SectionList() {
      return _$$_REQUIRE(_dependencyMap[25], 'SectionList');
    },

    get SegmentedControlIOS() {
      return _$$_REQUIRE(_dependencyMap[26], 'SegmentedControlIOS');
    },

    get Slider() {
      return _$$_REQUIRE(_dependencyMap[27], 'Slider');
    },

    get SnapshotViewIOS() {
      return _$$_REQUIRE(_dependencyMap[28], 'SnapshotViewIOS');
    },

    get Switch() {
      return _$$_REQUIRE(_dependencyMap[29], 'Switch');
    },

    get RefreshControl() {
      return _$$_REQUIRE(_dependencyMap[30], 'RefreshControl');
    },

    get StatusBar() {
      return _$$_REQUIRE(_dependencyMap[31], 'StatusBar');
    },

    get SwipeableFlatList() {
      return _$$_REQUIRE(_dependencyMap[32], 'SwipeableFlatList');
    },

    get SwipeableListView() {
      return _$$_REQUIRE(_dependencyMap[33], 'SwipeableListView');
    },

    get TabBarIOS() {
      return _$$_REQUIRE(_dependencyMap[34], 'TabBarIOS');
    },

    get Text() {
      return _$$_REQUIRE(_dependencyMap[35], 'Text');
    },

    get TextInput() {
      return _$$_REQUIRE(_dependencyMap[36], 'TextInput');
    },

    get ToastAndroid() {
      return _$$_REQUIRE(_dependencyMap[37], 'ToastAndroid');
    },

    get ToolbarAndroid() {
      return _$$_REQUIRE(_dependencyMap[38], 'ToolbarAndroid');
    },

    get Touchable() {
      return _$$_REQUIRE(_dependencyMap[39], 'Touchable');
    },

    get TouchableHighlight() {
      return _$$_REQUIRE(_dependencyMap[40], 'TouchableHighlight');
    },

    get TouchableNativeFeedback() {
      return _$$_REQUIRE(_dependencyMap[41], 'TouchableNativeFeedback');
    },

    get TouchableOpacity() {
      return _$$_REQUIRE(_dependencyMap[42], 'TouchableOpacity');
    },

    get TouchableWithoutFeedback() {
      return _$$_REQUIRE(_dependencyMap[43], 'TouchableWithoutFeedback');
    },

    get View() {
      return _$$_REQUIRE(_dependencyMap[44], 'View');
    },

    get ViewPagerAndroid() {
      return _$$_REQUIRE(_dependencyMap[45], 'ViewPagerAndroid');
    },

    get VirtualizedList() {
      return _$$_REQUIRE(_dependencyMap[46], 'VirtualizedList');
    },

    get WebView() {
      return _$$_REQUIRE(_dependencyMap[47], 'WebView');
    },

    get ActionSheetIOS() {
      return _$$_REQUIRE(_dependencyMap[48], 'ActionSheetIOS');
    },

    get Alert() {
      return _$$_REQUIRE(_dependencyMap[49], 'Alert');
    },

    get AlertIOS() {
      return _$$_REQUIRE(_dependencyMap[50], 'AlertIOS');
    },

    get Animated() {
      return _$$_REQUIRE(_dependencyMap[51], 'Animated');
    },

    get AppRegistry() {
      return _$$_REQUIRE(_dependencyMap[52], 'AppRegistry');
    },

    get AppState() {
      return _$$_REQUIRE(_dependencyMap[53], 'AppState');
    },

    get AsyncStorage() {
      return _$$_REQUIRE(_dependencyMap[54], 'AsyncStorage');
    },

    get BackAndroid() {
      return _$$_REQUIRE(_dependencyMap[55], 'BackAndroid');
    },

    get BackHandler() {
      return _$$_REQUIRE(_dependencyMap[56], 'BackHandler');
    },

    get CameraRoll() {
      return _$$_REQUIRE(_dependencyMap[57], 'CameraRoll');
    },

    get Clipboard() {
      return _$$_REQUIRE(_dependencyMap[58], 'Clipboard');
    },

    get DatePickerAndroid() {
      return _$$_REQUIRE(_dependencyMap[59], 'DatePickerAndroid');
    },

    get DeviceInfo() {
      return _$$_REQUIRE(_dependencyMap[60], 'DeviceInfo');
    },

    get Dimensions() {
      return _$$_REQUIRE(_dependencyMap[61], 'Dimensions');
    },

    get Easing() {
      return _$$_REQUIRE(_dependencyMap[62], 'Easing');
    },

    get findNodeHandle() {
      return _$$_REQUIRE(_dependencyMap[63], 'ReactNative').findNodeHandle;
    },

    get I18nManager() {
      return _$$_REQUIRE(_dependencyMap[64], 'I18nManager');
    },

    get ImagePickerIOS() {
      return _$$_REQUIRE(_dependencyMap[65], 'ImagePickerIOS');
    },

    get InteractionManager() {
      return _$$_REQUIRE(_dependencyMap[66], 'InteractionManager');
    },

    get Keyboard() {
      return _$$_REQUIRE(_dependencyMap[67], 'Keyboard');
    },

    get LayoutAnimation() {
      return _$$_REQUIRE(_dependencyMap[68], 'LayoutAnimation');
    },

    get Linking() {
      return _$$_REQUIRE(_dependencyMap[69], 'Linking');
    },

    get NativeEventEmitter() {
      return _$$_REQUIRE(_dependencyMap[70], 'NativeEventEmitter');
    },

    get NetInfo() {
      return _$$_REQUIRE(_dependencyMap[71], 'NetInfo');
    },

    get PanResponder() {
      return _$$_REQUIRE(_dependencyMap[72], 'PanResponder');
    },

    get PermissionsAndroid() {
      return _$$_REQUIRE(_dependencyMap[73], 'PermissionsAndroid');
    },

    get PixelRatio() {
      return _$$_REQUIRE(_dependencyMap[74], 'PixelRatio');
    },

    get PushNotificationIOS() {
      return _$$_REQUIRE(_dependencyMap[75], 'PushNotificationIOS');
    },

    get Settings() {
      return _$$_REQUIRE(_dependencyMap[76], 'Settings');
    },

    get Share() {
      return _$$_REQUIRE(_dependencyMap[77], 'Share');
    },

    get StatusBarIOS() {
      return _$$_REQUIRE(_dependencyMap[78], 'StatusBarIOS');
    },

    get StyleSheet() {
      return _$$_REQUIRE(_dependencyMap[79], 'StyleSheet');
    },

    get Systrace() {
      return _$$_REQUIRE(_dependencyMap[80], 'Systrace');
    },

    get TimePickerAndroid() {
      return _$$_REQUIRE(_dependencyMap[81], 'TimePickerAndroid');
    },

    get TVEventHandler() {
      return _$$_REQUIRE(_dependencyMap[82], 'TVEventHandler');
    },

    get UIManager() {
      return _$$_REQUIRE(_dependencyMap[83], 'UIManager');
    },

    get unstable_batchedUpdates() {
      return _$$_REQUIRE(_dependencyMap[63], 'ReactNative').unstable_batchedUpdates;
    },

    get Vibration() {
      return _$$_REQUIRE(_dependencyMap[84], 'Vibration');
    },

    get VibrationIOS() {
      return _$$_REQUIRE(_dependencyMap[85], 'VibrationIOS');
    },

    get YellowBox() {
      return _$$_REQUIRE(_dependencyMap[86], 'YellowBox');
    },

    get DeviceEventEmitter() {
      return _$$_REQUIRE(_dependencyMap[87], 'RCTDeviceEventEmitter');
    },

    get NativeAppEventEmitter() {
      return _$$_REQUIRE(_dependencyMap[88], 'RCTNativeAppEventEmitter');
    },

    get NativeModules() {
      return _$$_REQUIRE(_dependencyMap[89], 'NativeModules');
    },

    get Platform() {
      return _$$_REQUIRE(_dependencyMap[90], 'Platform');
    },

    get processColor() {
      return _$$_REQUIRE(_dependencyMap[91], 'processColor');
    },

    get requireNativeComponent() {
      return _$$_REQUIRE(_dependencyMap[92], 'requireNativeComponent');
    },

    get takeSnapshot() {
      return _$$_REQUIRE(_dependencyMap[93], 'takeSnapshot');
    },

    get ColorPropType() {
      return _$$_REQUIRE(_dependencyMap[94], 'ColorPropType');
    },

    get EdgeInsetsPropType() {
      return _$$_REQUIRE(_dependencyMap[95], 'EdgeInsetsPropType');
    },

    get PointPropType() {
      return _$$_REQUIRE(_dependencyMap[96], 'PointPropType');
    },

    get ViewPropTypes() {
      return _$$_REQUIRE(_dependencyMap[97], 'ViewPropTypes');
    },

    get Navigator() {
      invariant(false, 'Navigator is deprecated and has been removed from this package. It can now be installed ' + 'and imported from `react-native-deprecated-custom-components` instead of `react-native`. ' + 'Learn about alternative navigation solutions at http://facebook.github.io/react-native/docs/navigation.html');
    }

  };
  module.exports = ReactNative;
},165,[166,167,199,241,251,385,386,387,388,361,402,404,405,406,407,390,408,409,446,448,449,239,451,429,367,452,454,455,456,457,396,458,459,463,465,252,467,474,475,257,420,330,331,383,227,476,397,477,481,299,300,332,482,317,492,493,487,494,495,496,204,203,358,261,445,497,340,371,372,478,286,498,461,303,202,499,500,501,502,201,172,503,327,218,504,505,427,194,307,168,176,221,229,506,207,254,368,376],"node_modules/react-native/Libraries/react-native/react-native-implementation.js");
__d(function (global, _$$_REQUIRE, 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;
},166,[],"node_modules/react-native/node_modules/fbjs/lib/invariant.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var NativeModules = _$$_REQUIRE(_dependencyMap[0], 'NativeModules');

  var Promise = _$$_REQUIRE(_dependencyMap[1], 'Promise');

  var RCTDeviceEventEmitter = _$$_REQUIRE(_dependencyMap[2], 'RCTDeviceEventEmitter');

  var AccessibilityManager = NativeModules.AccessibilityManager;
  var VOICE_OVER_EVENT = 'voiceOverDidChange';
  var ANNOUNCEMENT_DID_FINISH_EVENT = 'announcementDidFinish';

  var _subscriptions = new Map();

  var AccessibilityInfo = {
    fetch: function fetch() {
      return new Promise(function (resolve, reject) {
        AccessibilityManager.getCurrentVoiceOverState(resolve, reject);
      });
    },
    addEventListener: function addEventListener(eventName, handler) {
      var listener;

      if (eventName === 'change') {
        listener = RCTDeviceEventEmitter.addListener(VOICE_OVER_EVENT, handler);
      } else if (eventName === 'announcementFinished') {
        listener = RCTDeviceEventEmitter.addListener(ANNOUNCEMENT_DID_FINISH_EVENT, handler);
      }

      _subscriptions.set(handler, listener);

      return {
        remove: AccessibilityInfo.removeEventListener.bind(null, eventName, handler)
      };
    },
    setAccessibilityFocus: function setAccessibilityFocus(reactTag) {
      AccessibilityManager.setAccessibilityFocus(reactTag);
    },
    announceForAccessibility: function announceForAccessibility(announcement) {
      AccessibilityManager.announceForAccessibility(announcement);
    },
    removeEventListener: function removeEventListener(eventName, handler) {
      var listener = _subscriptions.get(handler);

      if (!listener) {
        return;
      }

      listener.remove();

      _subscriptions.delete(handler);
    }
  };
  module.exports = AccessibilityInfo;
},167,[168,186,194],"node_modules/react-native/Libraries/Components/AccessibilityInfo/AccessibilityInfo.ios.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function _objectWithoutProperties(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]; } 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; }

  function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

  function _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 BatchedBridge = _$$_REQUIRE(_dependencyMap[0], 'BatchedBridge');

  var invariant = _$$_REQUIRE(_dependencyMap[1], 'fbjs/lib/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 (__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];
        }

        return new Promise(function (resolve, reject) {
          BatchedBridge.enqueueNativeCall(moduleID, methodID, args, function (data) {
            return resolve(data);
          }, function (errorData) {
            return reject(createErrorFromErrorData(errorData));
          });
        });
      };
    } else if (type === 'sync') {
      fn = function fn() {
        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.');
        }

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

        return global.nativeCallSyncHook(moduleID, methodID, args);
      };
    } else {
      fn = function fn() {
        for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
          args[_key3] = arguments[_key3];
        }

        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);
        BatchedBridge.enqueueNativeCall(moduleID, methodID, args, onFail, onSuccess);
      };
    }

    fn.type = type;
    return fn;
  }

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

  function createErrorFromErrorData(errorData) {
    var _ref = errorData || {},
        message = _ref.message,
        extraErrorInfo = _objectWithoutProperties(_ref, ["message"]);

    var error = new Error(message);
    error.framesToPop = 1;
    return _extends(error, extraErrorInfo);
  }

  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[2], '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;
},168,[169,166,185],"node_modules/react-native/Libraries/BatchedBridge/NativeModules.js");
__d(function (global, _$$_REQUIRE, 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;
},169,[170],"node_modules/react-native/Libraries/BatchedBridge/BatchedBridge.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }

  function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); }

  function _iterableToArray(iter) { if ((typeof Symbol === "function" ? Symbol.iterator : "@@iterator") in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); }

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

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  var ErrorUtils = _$$_REQUIRE(_dependencyMap[0], 'ErrorUtils');

  var Systrace = _$$_REQUIRE(_dependencyMap[1], 'Systrace');

  var deepFreezeAndThrowOnMutationInDev = _$$_REQUIRE(_dependencyMap[2], 'deepFreezeAndThrowOnMutationInDev');

  var invariant = _$$_REQUIRE(_dependencyMap[3], 'fbjs/lib/invariant');

  var stringifySafe = _$$_REQUIRE(_dependencyMap[4], 'stringifySafe');

  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 JSTimers = null;

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

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

      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 new Date().getTime() - 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: "enqueueNativeCall",
      value: function enqueueNativeCall(moduleID, methodID, params, onFail, onSucc) {
        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];
            }
          }

          onFail && params.push(this._callID << 1);
          onSucc && params.push(this._callID << 1 | 1);
          this._successCallbacks[this._callID] = onSucc;
          this._failureCallbacks[this._callID] = onFail;
        }

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

        this._callID++;

        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 === 'number' || t === 'string') {
              return true;
            }

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

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

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

        var now = new Date().getTime();

        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: "__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 (!JSTimers) {
          JSTimers = _$$_REQUIRE(_dependencyMap[5], 'JSTimers');
        }

        JSTimers.callImmediates();
        Systrace.endEvent();
      }
    }, {
      key: "__callFunction",
      value: function __callFunction(module, method, args) {
        this._lastFlush = new Date().getTime();
        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 = new Date().getTime();
        this._eventLoopStartTime = this._lastFlush;
        var callID = cbID >>> 1;
        var isSuccess = cbID & 1;
        var callback = isSuccess ? this._successCallbacks[callID] : this._failureCallbacks[callID];

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

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

          var _method = debug && this._remoteMethodTable[debug[0]][debug[1]];

          if (!callback) {
            var errorMessage = "Callback with id " + cbID + ": " + _module + "." + _method + "() not found";

            if (_method) {
              errorMessage = "The callback " + _method + "() exists in module " + _module + ", " + 'but only one callback may be registered to a function in a native module.';
            }

            invariant(callback, errorMessage);
          }

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

        delete this._successCallbacks[callID];
        delete this._failureCallbacks[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;
},170,[171,172,173,166,174,175],"node_modules/react-native/Libraries/BatchedBridge/MessageQueue.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  module.exports = global.ErrorUtils;
},171,[],"node_modules/react-native/Libraries/vendor/core/ErrorUtils.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var invariant = _$$_REQUIRE(_dependencyMap[0], 'fbjs/lib/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;
},172,[166],"node_modules/react-native/Libraries/Performance/Systrace.js");
__d(function (global, _$$_REQUIRE, 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;
},173,[],"node_modules/react-native/Libraries/Utilities/deepFreezeAndThrowOnMutationInDev.js");
__d(function (global, _$$_REQUIRE, 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 {
      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;
},174,[],"node_modules/react-native/Libraries/Utilities/stringifySafe.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var Platform = _$$_REQUIRE(_dependencyMap[0], 'Platform');

  var Systrace = _$$_REQUIRE(_dependencyMap[1], 'Systrace');

  var invariant = _$$_REQUIRE(_dependencyMap[2], 'fbjs/lib/invariant');

  var _require = _$$_REQUIRE(_dependencyMap[3], 'NativeModules'),
      Timing = _require.Timing;

  var _performanceNow = null;

  function performanceNow() {
    if (!_performanceNow) {
      _performanceNow = _$$_REQUIRE(_dependencyMap[4], '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 = Platform.OS === '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[5], '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[6], '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') {
        Timing.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');

      Timing.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');

      Timing.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');

      Timing.createTimer(id, 1, Date.now(), false);
      return id;
    },
    requestIdleCallback: function requestIdleCallback(func, options) {
      if (requestIdleCallbacks.length === 0) {
        Timing.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) {
            Timing.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) {
        Timing.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) {
        Timing.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);
    }
  };
  var ExportedJSTimers;

  if (!Timing) {
    console.warn("Timing native module is not available, can't set timers.");
    ExportedJSTimers = {
      callImmediates: JSTimers.callImmediates,
      setImmediate: JSTimers.setImmediate
    };
  } else {
    ExportedJSTimers = JSTimers;
  }

  module.exports = ExportedJSTimers;
},175,[176,172,166,168,177,180,183],"node_modules/react-native/Libraries/Core/Timers/JSTimers.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var NativeModules = _$$_REQUIRE(_dependencyMap[0], 'NativeModules');

  var Platform = {
    OS: 'ios',

    get Version() {
      var constants = NativeModules.PlatformConstants;
      return constants && constants.osVersion;
    },

    get isPad() {
      var constants = NativeModules.PlatformConstants;
      return constants ? constants.interfaceIdiom === 'pad' : false;
    },

    get isTVOS() {
      return Platform.isTV;
    },

    get isTV() {
      var constants = NativeModules.PlatformConstants;
      return constants ? constants.interfaceIdiom === 'tv' : false;
    },

    get isTesting() {
      var constants = NativeModules.PlatformConstants;
      return constants && constants.isTesting;
    },

    select: function select(obj) {
      return 'ios' in obj ? obj.ios : obj.default;
    }
  };
  module.exports = Platform;
},176,[168],"node_modules/react-native/Libraries/Utilities/Platform.ios.js");
__d(function (global, _$$_REQUIRE, 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;
},177,[178],"node_modules/react-native/node_modules/fbjs/lib/performanceNow.js");
__d(function (global, _$$_REQUIRE, 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 || {};
},178,[179],"node_modules/react-native/node_modules/fbjs/lib/performance.js");
__d(function (global, _$$_REQUIRE, 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;
},179,[],"node_modules/react-native/node_modules/fbjs/lib/ExecutionEnvironment.js");
__d(function (global, _$$_REQUIRE, 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;
},180,[181],"node_modules/react-native/Libraries/Core/Devtools/parseErrorStack.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  module.exports = _$$_REQUIRE(_dependencyMap[0], './lib/stacktrace-parser.js');
},181,[182],"node_modules/stacktrace-parser/index.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  var UNKNOWN_FUNCTION = '<unknown>';
  var StackTraceParser = {
    parse: function parse(stackString) {
      var chrome = /^\s*at (?:(?:(?:Anonymous function)?|((?:\[object object\])?\S+(?: \[as \S+\])?)) )?\(?((?:file|http|https):.*?):(\d+)(?::(\d+))?\)?\s*$/i,
          gecko = /^(?:\s*([^@]*)(?:\((.*?)\))?@)?(\S.*?):(\d+)(?::(\d+))?\s*$/i,
          node = /^\s*at (?:((?:\[object object\])?\S+(?: \[as \S+\])?) )?\(?(.*?):(\d+)(?::(\d+))?\)?\s*$/i,
          lines = stackString.split('\n'),
          stack = [],
          parts,
          element;

      for (var i = 0, j = lines.length; i < j; ++i) {
        if (parts = gecko.exec(lines[i])) {
          element = {
            'file': parts[3],
            'methodName': parts[1] || UNKNOWN_FUNCTION,
            'lineNumber': +parts[4],
            'column': parts[5] ? +parts[5] : null
          };
        } else if (parts = chrome.exec(lines[i])) {
          element = {
            'file': parts[2],
            'methodName': parts[1] || UNKNOWN_FUNCTION,
            'lineNumber': +parts[3],
            'column': parts[4] ? +parts[4] : null
          };
        } else if (parts = node.exec(lines[i])) {
          element = {
            'file': parts[2],
            'methodName': parts[1] || UNKNOWN_FUNCTION,
            'lineNumber': +parts[3],
            'column': parts[4] ? +parts[4] : null
          };
        } else {
          continue;
        }

        stack.push(element);
      }

      return stack;
    }
  };
  module.exports = StackTraceParser;
},182,[],"node_modules/stacktrace-parser/lib/stacktrace-parser.js");
__d(function (global, _$$_REQUIRE, 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;
},183,[184],"node_modules/react-native/node_modules/fbjs/lib/warning.js");
__d(function (global, _$$_REQUIRE, 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;
},184,[],"node_modules/react-native/node_modules/fbjs/lib/emptyFunction.js");
__d(function (global, _$$_REQUIRE, 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;
},185,[],"node_modules/react-native/Libraries/Utilities/defineLazyObjectProperty.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var Promise = _$$_REQUIRE(_dependencyMap[0], 'fbjs/lib/Promise.native');

  if (__DEV__) {
    _$$_REQUIRE(_dependencyMap[1], '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[2], '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;
},186,[187,191,192],"node_modules/react-native/Libraries/Promise.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var Promise = _$$_REQUIRE(_dependencyMap[0], 'promise/setimmediate/es6-extensions');

  _$$_REQUIRE(_dependencyMap[1], 'promise/setimmediate/done');

  Promise.prototype['finally'] = function (onSettled) {
    return this.then(onSettled, onSettled);
  };

  module.exports = Promise;
},187,[188,190],"node_modules/react-native/node_modules/fbjs/lib/Promise.native.js");
__d(function (global, _$$_REQUIRE, 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);
  };
},188,[189],"node_modules/promise/setimmediate/es6-extensions.js");
__d(function (global, _$$_REQUIRE, 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);
    }
  }
},189,[],"node_modules/promise/setimmediate/core.js");
__d(function (global, _$$_REQUIRE, 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);
    });
  };
},190,[189],"node_modules/promise/setimmediate/done.js");
__d(function (global, _$$_REQUIRE, 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;
    });
  }
},191,[189],"node_modules/promise/setimmediate/rejection-tracking.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var printString = _$$_REQUIRE(_dependencyMap[0], './printString');

  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 SYMBOL_REGEXP = /^Symbol\((.*)\)(.*)$/;
  var NEWLINE_REGEXP = /\n/ig;

  var getSymbols = Object.getOwnPropertySymbols || function (obj) {
    return [];
  };

  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) {
    if (val != +val) return 'NaN';
    var isNegativeZero = val === 0 && 1 / val < 0;
    return isNegativeZero ? '-0' : '' + val;
  }

  function printFunction(val, printFunctionName) {
    if (!printFunctionName) {
      return '[Function]';
    } else if (val.name === '') {
      return '[Function anonymous]';
    } else {
      return '[Function ' + val.name + ']';
    }
  }

  function printSymbol(val) {
    return symbolToString.call(val).replace(SYMBOL_REGEXP, 'Symbol($1)');
  }

  function printError(val) {
    return '[' + errorToString.call(val) + ']';
  }

  function printBasicValue(val, printFunctionName, escapeRegex) {
    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 === 'string') return '"' + printString(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 toISOString.call(val);
    if (toStringed === '[object Error]') return printError(val);

    if (toStringed === '[object RegExp]') {
      if (escapeRegex) {
        return printString(regExpToString.call(val));
      }

      return regExpToString.call(val);
    }

    ;
    if (toStringed === '[object Arguments]' && val.length === 0) return 'Arguments []';
    if (isToStringedArrayType(toStringed) && val.length === 0) return val.constructor.name + ' []';
    if (val instanceof Error) return printError(val);
    return false;
  }

  function printList(list, indent, prevIndent, spacing, edgeSpacing, refs, maxDepth, currentDepth, plugins, min, callToJSON, printFunctionName, escapeRegex) {
    var body = '';

    if (list.length) {
      body += edgeSpacing;
      var innerIndent = prevIndent + indent;

      for (var i = 0; i < list.length; i++) {
        body += innerIndent + print(list[i], indent, innerIndent, spacing, edgeSpacing, refs, maxDepth, currentDepth, plugins, min, callToJSON, printFunctionName, escapeRegex);

        if (i < list.length - 1) {
          body += ',' + spacing;
        }
      }

      body += (min ? '' : ',') + edgeSpacing + prevIndent;
    }

    return '[' + body + ']';
  }

  function printArguments(val, indent, prevIndent, spacing, edgeSpacing, refs, maxDepth, currentDepth, plugins, min, callToJSON, printFunctionName, escapeRegex) {
    return (min ? '' : 'Arguments ') + printList(val, indent, prevIndent, spacing, edgeSpacing, refs, maxDepth, currentDepth, plugins, min, callToJSON, printFunctionName, escapeRegex);
  }

  function printArray(val, indent, prevIndent, spacing, edgeSpacing, refs, maxDepth, currentDepth, plugins, min, callToJSON, printFunctionName, escapeRegex) {
    return (min ? '' : val.constructor.name + ' ') + printList(val, indent, prevIndent, spacing, edgeSpacing, refs, maxDepth, currentDepth, plugins, min, callToJSON, printFunctionName, escapeRegex);
  }

  function printMap(val, indent, prevIndent, spacing, edgeSpacing, refs, maxDepth, currentDepth, plugins, min, callToJSON, printFunctionName, escapeRegex) {
    var result = 'Map {';
    var iterator = val.entries();
    var current = iterator.next();

    if (!current.done) {
      result += edgeSpacing;
      var innerIndent = prevIndent + indent;

      while (!current.done) {
        var key = print(current.value[0], indent, innerIndent, spacing, edgeSpacing, refs, maxDepth, currentDepth, plugins, min, callToJSON, printFunctionName, escapeRegex);
        var value = print(current.value[1], indent, innerIndent, spacing, edgeSpacing, refs, maxDepth, currentDepth, plugins, min, callToJSON, printFunctionName, escapeRegex);
        result += innerIndent + key + ' => ' + value;
        current = iterator.next();

        if (!current.done) {
          result += ',' + spacing;
        }
      }

      result += (min ? '' : ',') + edgeSpacing + prevIndent;
    }

    return result + '}';
  }

  function printObject(val, indent, prevIndent, spacing, edgeSpacing, refs, maxDepth, currentDepth, plugins, min, callToJSON, printFunctionName, escapeRegex) {
    var constructor = min ? '' : val.constructor ? val.constructor.name + ' ' : 'Object ';
    var result = constructor + '{';
    var keys = Object.keys(val).sort();
    var symbols = getSymbols(val);

    if (symbols.length) {
      keys = keys.filter(function (key) {
        return !(typeof key === 'symbol' || toString.call(key) === '[object Symbol]');
      }).concat(symbols);
    }

    if (keys.length) {
      result += edgeSpacing;
      var innerIndent = prevIndent + indent;

      for (var i = 0; i < keys.length; i++) {
        var key = keys[i];
        var name = print(key, indent, innerIndent, spacing, edgeSpacing, refs, maxDepth, currentDepth, plugins, min, callToJSON, printFunctionName, escapeRegex);
        var value = print(val[key], indent, innerIndent, spacing, edgeSpacing, refs, maxDepth, currentDepth, plugins, min, callToJSON, printFunctionName, escapeRegex);
        result += innerIndent + name + ': ' + value;

        if (i < keys.length - 1) {
          result += ',' + spacing;
        }
      }

      result += (min ? '' : ',') + edgeSpacing + prevIndent;
    }

    return result + '}';
  }

  function printSet(val, indent, prevIndent, spacing, edgeSpacing, refs, maxDepth, currentDepth, plugins, min, callToJSON, printFunctionName, escapeRegex) {
    var result = 'Set {';
    var iterator = val.entries();
    var current = iterator.next();

    if (!current.done) {
      result += edgeSpacing;
      var innerIndent = prevIndent + indent;

      while (!current.done) {
        result += innerIndent + print(current.value[1], indent, innerIndent, spacing, edgeSpacing, refs, maxDepth, currentDepth, plugins, min, callToJSON, printFunctionName, escapeRegex);
        current = iterator.next();

        if (!current.done) {
          result += ',' + spacing;
        }
      }

      result += (min ? '' : ',') + edgeSpacing + prevIndent;
    }

    return result + '}';
  }

  function printComplexValue(val, indent, prevIndent, spacing, edgeSpacing, refs, maxDepth, currentDepth, plugins, min, callToJSON, printFunctionName, escapeRegex) {
    refs = refs.slice();

    if (refs.indexOf(val) > -1) {
      return '[Circular]';
    } else {
      refs.push(val);
    }

    currentDepth++;
    var hitMaxDepth = currentDepth > maxDepth;

    if (callToJSON && !hitMaxDepth && val.toJSON && typeof val.toJSON === 'function') {
      return print(val.toJSON(), indent, prevIndent, spacing, edgeSpacing, refs, maxDepth, currentDepth, plugins, min, callToJSON, printFunctionName, escapeRegex);
    }

    var toStringed = toString.call(val);

    if (toStringed === '[object Arguments]') {
      return hitMaxDepth ? '[Arguments]' : printArguments(val, indent, prevIndent, spacing, edgeSpacing, refs, maxDepth, currentDepth, plugins, min, callToJSON, printFunctionName, escapeRegex);
    } else if (isToStringedArrayType(toStringed)) {
      return hitMaxDepth ? '[Array]' : printArray(val, indent, prevIndent, spacing, edgeSpacing, refs, maxDepth, currentDepth, plugins, min, callToJSON, printFunctionName, escapeRegex);
    } else if (toStringed === '[object Map]') {
      return hitMaxDepth ? '[Map]' : printMap(val, indent, prevIndent, spacing, edgeSpacing, refs, maxDepth, currentDepth, plugins, min, callToJSON, printFunctionName, escapeRegex);
    } else if (toStringed === '[object Set]') {
      return hitMaxDepth ? '[Set]' : printSet(val, indent, prevIndent, spacing, edgeSpacing, refs, maxDepth, currentDepth, plugins, min, callToJSON, printFunctionName, escapeRegex);
    } else if (typeof val === 'object') {
      return hitMaxDepth ? '[Object]' : printObject(val, indent, prevIndent, spacing, edgeSpacing, refs, maxDepth, currentDepth, plugins, min, callToJSON, printFunctionName, escapeRegex);
    }
  }

  function printPlugin(val, indent, prevIndent, spacing, edgeSpacing, refs, maxDepth, currentDepth, plugins, min, callToJSON, printFunctionName, escapeRegex) {
    var match = false;
    var plugin;

    for (var p = 0; p < plugins.length; p++) {
      plugin = plugins[p];

      if (plugin.test(val)) {
        match = true;
        break;
      }
    }

    if (!match) {
      return false;
    }

    function boundPrint(val) {
      return print(val, indent, prevIndent, spacing, edgeSpacing, refs, maxDepth, currentDepth, plugins, min, callToJSON, printFunctionName, escapeRegex);
    }

    function boundIndent(str) {
      var indentation = prevIndent + indent;
      return indentation + str.replace(NEWLINE_REGEXP, '\n' + indentation);
    }

    return plugin.print(val, boundPrint, boundIndent, {
      edgeSpacing: edgeSpacing,
      spacing: spacing
    });
  }

  function print(val, indent, prevIndent, spacing, edgeSpacing, refs, maxDepth, currentDepth, plugins, min, callToJSON, printFunctionName, escapeRegex) {
    var basic = printBasicValue(val, printFunctionName, escapeRegex);
    if (basic) return basic;
    var plugin = printPlugin(val, indent, prevIndent, spacing, edgeSpacing, refs, maxDepth, currentDepth, plugins, min, callToJSON, printFunctionName, escapeRegex);
    if (plugin) return plugin;
    return printComplexValue(val, indent, prevIndent, spacing, edgeSpacing, refs, maxDepth, currentDepth, plugins, min, callToJSON, printFunctionName, escapeRegex);
  }

  var DEFAULTS = {
    callToJSON: true,
    indent: 2,
    maxDepth: Infinity,
    min: false,
    plugins: [],
    printFunctionName: true,
    escapeRegex: false
  };

  function validateOptions(opts) {
    Object.keys(opts).forEach(function (key) {
      if (!DEFAULTS.hasOwnProperty(key)) {
        throw new Error('prettyFormat: Invalid option: ' + key);
      }
    });

    if (opts.min && opts.indent !== undefined && opts.indent !== 0) {
      throw new Error('prettyFormat: Cannot run with min option and indent');
    }
  }

  function normalizeOptions(opts) {
    var result = {};
    Object.keys(DEFAULTS).forEach(function (key) {
      return result[key] = opts.hasOwnProperty(key) ? opts[key] : DEFAULTS[key];
    });

    if (result.min) {
      result.indent = 0;
    }

    return result;
  }

  function createIndent(indent) {
    return new Array(indent + 1).join(' ');
  }

  function prettyFormat(val, opts) {
    if (!opts) {
      opts = DEFAULTS;
    } else {
      validateOptions(opts);
      opts = normalizeOptions(opts);
    }

    var indent;
    var refs;
    var prevIndent = '';
    var currentDepth = 0;
    var spacing = opts.min ? ' ' : '\n';
    var edgeSpacing = opts.min ? '' : '\n';

    if (opts && opts.plugins.length) {
      indent = createIndent(opts.indent);
      refs = [];
      var pluginsResult = printPlugin(val, indent, prevIndent, spacing, edgeSpacing, refs, opts.maxDepth, currentDepth, opts.plugins, opts.min, opts.callToJSON, opts.printFunctionName, opts.escapeRegex);
      if (pluginsResult) return pluginsResult;
    }

    var basicResult = printBasicValue(val, opts.printFunctionName, opts.escapeRegex);
    if (basicResult) return basicResult;
    if (!indent) indent = createIndent(opts.indent);
    if (!refs) refs = [];
    return printComplexValue(val, indent, prevIndent, spacing, edgeSpacing, refs, opts.maxDepth, currentDepth, opts.plugins, opts.min, opts.callToJSON, opts.printFunctionName, opts.escapeRegex);
  }

  module.exports = prettyFormat;
},192,[193],"node_modules/pretty-format/index.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var ESCAPED_CHARACTERS = /(\\|\"|\')/g;

  module.exports = function printString(val) {
    return val.replace(ESCAPED_CHARACTERS, '\\$1');
  };
},193,[],"node_modules/pretty-format/printString.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _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); }

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

  function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var EventEmitter = _$$_REQUIRE(_dependencyMap[0], 'EventEmitter');

  var EventSubscriptionVendor = _$$_REQUIRE(_dependencyMap[1], '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) {
    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);
        }
      }
    }]);

    _inherits(RCTDeviceEventEmitter, _EventEmitter);

    return RCTDeviceEventEmitter;
  }(EventEmitter);

  module.exports = new RCTDeviceEventEmitter();
},194,[195,198],"node_modules/react-native/Libraries/EventEmitter/RCTDeviceEventEmitter.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  var EmitterSubscription = _$$_REQUIRE(_dependencyMap[0], 'EmitterSubscription');

  var EventSubscriptionVendor = _$$_REQUIRE(_dependencyMap[1], 'EventSubscriptionVendor');

  var emptyFunction = _$$_REQUIRE(_dependencyMap[2], 'fbjs/lib/emptyFunction');

  var invariant = _$$_REQUIRE(_dependencyMap[3], 'fbjs/lib/invariant');

  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(emptyFunction.thatReturnsTrue).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) {
              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;
},195,[196,198,184,166],"node_modules/react-native/Libraries/vendor/emitter/EventEmitter.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var EventSubscription = _$$_REQUIRE(_dependencyMap[0], 'EventSubscription');

  var EmitterSubscription = function (_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);
      }
    }]);

    _inherits(EmitterSubscription, _EventSubscription);

    return EmitterSubscription;
  }(EventSubscription);

  module.exports = EmitterSubscription;
},196,[197],"node_modules/react-native/Libraries/vendor/emitter/EmitterSubscription.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  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;
},197,[],"node_modules/react-native/Libraries/vendor/emitter/EventSubscription.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  var invariant = _$$_REQUIRE(_dependencyMap[0], 'fbjs/lib/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;
},198,[166],"node_modules/react-native/Libraries/vendor/emitter/EventSubscriptionVendor.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _jsxFileName = "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Components/ActivityIndicator/ActivityIndicator.js";

  function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

  function _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; }

  function _objectWithoutProperties(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]; } 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; }

  var Platform = _$$_REQUIRE(_dependencyMap[0], 'Platform');

  var React = _$$_REQUIRE(_dependencyMap[1], 'React');

  var StyleSheet = _$$_REQUIRE(_dependencyMap[2], 'StyleSheet');

  var View = _$$_REQUIRE(_dependencyMap[3], 'View');

  var requireNativeComponent = _$$_REQUIRE(_dependencyMap[4], 'requireNativeComponent');

  var RCTActivityIndicator = Platform.OS === 'android' ? _$$_REQUIRE(_dependencyMap[5], 'ProgressBarAndroid') : requireNativeComponent('RCTActivityIndicatorView');
  var GRAY = '#999999';

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

    var sizeStyle;

    switch (props.size) {
      case 'small':
        sizeStyle = styles.sizeSmall;
        break;

      case 'large':
        sizeStyle = styles.sizeLarge;
        break;

      default:
        sizeStyle = {
          height: props.size,
          width: props.size
        };
        break;
    }

    var nativeProps = _objectSpread({}, restProps, {
      ref: forwardedRef,
      style: sizeStyle,
      styleAttr: 'Normal',
      indeterminate: true
    });

    return React.createElement(View, {
      onLayout: onLayout,
      style: [styles.container, style],
      __source: {
        fileName: _jsxFileName,
        lineNumber: 102
      }
    }, React.createElement(RCTActivityIndicator, _extends({}, nativeProps, {
      __source: {
        fileName: _jsxFileName,
        lineNumber: 103
      }
    })));
  };

  var ActivityIndicatorWithRef = React.forwardRef(function (props, ref) {
    return React.createElement(ActivityIndicator, _extends({}, props, {
      forwardedRef: ref,
      __source: {
        fileName: _jsxFileName,
        lineNumber: 110
      }
    }));
  });
  ActivityIndicatorWithRef.defaultProps = {
    animating: true,
    color: Platform.OS === 'ios' ? GRAY : null,
    hidesWhenStopped: true,
    size: 'small'
  };
  ActivityIndicatorWithRef.displayName = 'ActivityIndicator';
  var styles = StyleSheet.create({
    container: {
      alignItems: 'center',
      justifyContent: 'center'
    },
    sizeSmall: {
      width: 20,
      height: 20
    },
    sizeLarge: {
      width: 36,
      height: 36
    }
  });
  module.exports = ActivityIndicatorWithRef;
},199,[176,200,201,227,229,239],"node_modules/react-native/Libraries/Components/ActivityIndicator/ActivityIndicator.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  module.exports = _$$_REQUIRE(_dependencyMap[0], 'react');
},200,[1],"node_modules/react-native/Libraries/react-native/React.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  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 PixelRatio = _$$_REQUIRE(_dependencyMap[0], 'PixelRatio');

  var ReactNativeStyleAttributes = _$$_REQUIRE(_dependencyMap[1], 'ReactNativeStyleAttributes');

  var StyleSheetValidation = _$$_REQUIRE(_dependencyMap[2], 'StyleSheetValidation');

  var flatten = _$$_REQUIRE(_dependencyMap[3], '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 (typeof ReactNativeStyleAttributes[property] === 'string') {
        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;
    }
  };
},201,[202,205,225,226],"node_modules/react-native/Libraries/StyleSheet/StyleSheet.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  var Dimensions = _$$_REQUIRE(_dependencyMap[0], '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;
},202,[203],"node_modules/react-native/Libraries/Utilities/PixelRatio.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  var EventEmitter = _$$_REQUIRE(_dependencyMap[0], 'EventEmitter');

  var Platform = _$$_REQUIRE(_dependencyMap[1], 'Platform');

  var RCTDeviceEventEmitter = _$$_REQUIRE(_dependencyMap[2], 'RCTDeviceEventEmitter');

  var invariant = _$$_REQUIRE(_dependencyMap[3], 'fbjs/lib/invariant');

  var eventEmitter = new EventEmitter();
  var dimensionsInitialized = false;
  var dimensions = {};

  var Dimensions = function () {
    function Dimensions() {
      _classCallCheck(this, Dimensions);
    }

    _createClass(Dimensions, null, [{
      key: "set",
      value: function set(dims) {
        if (dims && dims.windowPhysicalPixels) {
          dims = JSON.parse(JSON.stringify(dims));
          var windowPhysicalPixels = dims.windowPhysicalPixels;
          dims.window = {
            width: windowPhysicalPixels.width / windowPhysicalPixels.scale,
            height: windowPhysicalPixels.height / windowPhysicalPixels.scale,
            scale: windowPhysicalPixels.scale,
            fontScale: windowPhysicalPixels.fontScale
          };

          if (Platform.OS === 'android') {
            var screenPhysicalPixels = dims.screenPhysicalPixels;
            dims.screen = {
              width: screenPhysicalPixels.width / screenPhysicalPixels.scale,
              height: screenPhysicalPixels.height / screenPhysicalPixels.scale,
              scale: screenPhysicalPixels.scale,
              fontScale: screenPhysicalPixels.fontScale
            };
            delete dims.screenPhysicalPixels;
          } else {
            dims.screen = dims.window;
          }

          delete dims.windowPhysicalPixels;
        }

        _extends(dimensions, dims);

        if (dimensionsInitialized) {
          eventEmitter.emit('change', {
            window: dimensions.window,
            screen: dimensions.screen
          });
        } else {
          dimensionsInitialized = true;
        }
      }
    }, {
      key: "get",
      value: function get(dim) {
        invariant(dimensions[dim], 'No dimension set for key ' + dim);
        return dimensions[dim];
      }
    }, {
      key: "addEventListener",
      value: function addEventListener(type, handler) {
        invariant(type === 'change', 'Trying to subscribe to unknown event: "%s"', type);
        eventEmitter.addListener(type, handler);
      }
    }, {
      key: "removeEventListener",
      value: function removeEventListener(type, handler) {
        invariant(type === 'change', 'Trying to remove listener for unknown event: "%s"', type);
        eventEmitter.removeListener(type, handler);
      }
    }]);

    return Dimensions;
  }();

  var dims = global.nativeExtensions && global.nativeExtensions.DeviceInfo && global.nativeExtensions.DeviceInfo.Dimensions;
  var nativeExtensionsEnabled = true;

  if (!dims) {
    var DeviceInfo = _$$_REQUIRE(_dependencyMap[4], 'DeviceInfo');

    dims = DeviceInfo.Dimensions;
    nativeExtensionsEnabled = false;
  }

  invariant(dims, 'Either DeviceInfo native extension or DeviceInfo Native Module must be registered');
  Dimensions.set(dims);

  if (!nativeExtensionsEnabled) {
    RCTDeviceEventEmitter.addListener('didUpdateDimensions', function (update) {
      Dimensions.set(update);
    });
  }

  module.exports = Dimensions;
},203,[195,176,194,166,204],"node_modules/react-native/Libraries/Utilities/Dimensions.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var DeviceInfo = _$$_REQUIRE(_dependencyMap[0], 'NativeModules').DeviceInfo;

  var invariant = _$$_REQUIRE(_dependencyMap[1], 'fbjs/lib/invariant');

  invariant(DeviceInfo, 'DeviceInfo native module is not installed correctly');
  module.exports = DeviceInfo;
},204,[168,166],"node_modules/react-native/Libraries/Utilities/DeviceInfo.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  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 ImageStylePropTypes = _$$_REQUIRE(_dependencyMap[0], 'ImageStylePropTypes');

  var TextStylePropTypes = _$$_REQUIRE(_dependencyMap[1], 'TextStylePropTypes');

  var ViewStylePropTypes = _$$_REQUIRE(_dependencyMap[2], 'ViewStylePropTypes');

  var keyMirror = _$$_REQUIRE(_dependencyMap[3], 'fbjs/lib/keyMirror');

  var processColor = _$$_REQUIRE(_dependencyMap[4], 'processColor');

  var processTransform = _$$_REQUIRE(_dependencyMap[5], 'processTransform');

  var sizesDiffer = _$$_REQUIRE(_dependencyMap[6], 'sizesDiffer');

  var ReactNativeStyleAttributes = _objectSpread({}, keyMirror(ViewStylePropTypes), keyMirror(TextStylePropTypes), keyMirror(ImageStylePropTypes));

  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;
},205,[206,219,220,210,221,222,224],"node_modules/react-native/Libraries/Components/View/ReactNativeStyleAttributes.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  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 ColorPropType = _$$_REQUIRE(_dependencyMap[0], 'ColorPropType');

  var ImageResizeMode = _$$_REQUIRE(_dependencyMap[1], 'ImageResizeMode');

  var LayoutPropTypes = _$$_REQUIRE(_dependencyMap[2], 'LayoutPropTypes');

  var ReactPropTypes = _$$_REQUIRE(_dependencyMap[3], 'prop-types');

  var ShadowPropTypesIOS = _$$_REQUIRE(_dependencyMap[4], 'ShadowPropTypesIOS');

  var TransformPropTypes = _$$_REQUIRE(_dependencyMap[5], 'TransformPropTypes');

  var ImageStylePropTypes = _objectSpread({}, LayoutPropTypes, ShadowPropTypesIOS, TransformPropTypes, {
    resizeMode: ReactPropTypes.oneOf(Object.keys(ImageResizeMode)),
    backfaceVisibility: ReactPropTypes.oneOf(['visible', 'hidden']),
    backgroundColor: ColorPropType,
    borderColor: ColorPropType,
    borderWidth: ReactPropTypes.number,
    borderRadius: ReactPropTypes.number,
    overflow: ReactPropTypes.oneOf(['visible', 'hidden']),
    tintColor: ColorPropType,
    opacity: ReactPropTypes.number,
    overlayColor: ReactPropTypes.string,
    borderTopLeftRadius: ReactPropTypes.number,
    borderTopRightRadius: ReactPropTypes.number,
    borderBottomLeftRadius: ReactPropTypes.number,
    borderBottomRightRadius: ReactPropTypes.number
  });

  module.exports = ImageStylePropTypes;
},206,[207,209,211,212,215,216],"node_modules/react-native/Libraries/Image/ImageStylePropTypes.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var normalizeColor = _$$_REQUIRE(_dependencyMap[0], '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;
},207,[208],"node_modules/react-native/Libraries/StyleSheet/ColorPropType.js");
__d(function (global, _$$_REQUIRE, 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;
},208,[],"node_modules/react-native/Libraries/Color/normalizeColor.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

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

  var ImageResizeMode = keyMirror({
    contain: null,
    cover: null,
    stretch: null,
    center: null,
    repeat: null
  });
  module.exports = ImageResizeMode;
},209,[210],"node_modules/react-native/Libraries/Image/ImageResizeMode.js");
__d(function (global, _$$_REQUIRE, 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;
},210,[166],"node_modules/react-native/node_modules/fbjs/lib/keyMirror.js");
__d(function (global, _$$_REQUIRE, 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;
},211,[212],"node_modules/react-native/Libraries/StyleSheet/LayoutPropTypes.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  if (process.env.NODE_ENV !== 'production') {
    var REACT_ELEMENT_TYPE = typeof Symbol === 'function' && (typeof Symbol === "function" ? Symbol.for : "@@for") && (typeof Symbol === "function" ? Symbol.for : "@@for")('react.element') || 0xeac7;

    var isValidElement = function isValidElement(object) {
      return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
    };

    var throwOnDirectAccess = true;
    module.exports = _$$_REQUIRE(_dependencyMap[0], './factoryWithTypeCheckers')(isValidElement, throwOnDirectAccess);
  } else {
    module.exports = _$$_REQUIRE(_dependencyMap[1], './factoryWithThrowingShims')();
  }
},212,[213,214],"node_modules/prop-types/index.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

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

  var ReactPropTypesSecret = _$$_REQUIRE(_dependencyMap[1], './lib/ReactPropTypesSecret');

  var checkPropTypes = _$$_REQUIRE(_dependencyMap[2], './checkPropTypes');

  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(),
      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 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)) {
        process.env.NODE_ENV !== 'production' ? printWarning('Invalid argument supplied to oneOf, expected an instance of array.') : void 0;
        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);
        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of value `' + 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 (propValue.hasOwnProperty(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['@@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.PropTypes = ReactPropTypes;
    return ReactPropTypes;
  };
},213,[3,10,9],"node_modules/prop-types/factoryWithTypeCheckers.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var ReactPropTypesSecret = _$$_REQUIRE(_dependencyMap[0], './lib/ReactPropTypesSecret');

  function 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,
      instanceOf: getShim,
      node: shim,
      objectOf: getShim,
      oneOf: getShim,
      oneOfType: getShim,
      shape: getShim,
      exact: getShim
    };
    ReactPropTypes.checkPropTypes = emptyFunction;
    ReactPropTypes.PropTypes = ReactPropTypes;
    return ReactPropTypes;
  };
},214,[10],"node_modules/prop-types/factoryWithThrowingShims.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var ColorPropType = _$$_REQUIRE(_dependencyMap[0], 'ColorPropType');

  var ReactPropTypes = _$$_REQUIRE(_dependencyMap[1], 'prop-types');

  var ShadowPropTypesIOS = {
    shadowColor: ColorPropType,
    shadowOffset: ReactPropTypes.shape({
      width: ReactPropTypes.number,
      height: ReactPropTypes.number
    }),
    shadowOpacity: ReactPropTypes.number,
    shadowRadius: ReactPropTypes.number
  };
  module.exports = ShadowPropTypesIOS;
},215,[207,212],"node_modules/react-native/Libraries/Components/View/ShadowPropTypesIOS.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var ReactPropTypes = _$$_REQUIRE(_dependencyMap[0], 'prop-types');

  var deprecatedPropType = _$$_REQUIRE(_dependencyMap[1], '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 TransformPropTypes = {
    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 = TransformPropTypes;
},216,[212,217],"node_modules/react-native/Libraries/StyleSheet/TransformPropTypes.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var UIManager = _$$_REQUIRE(_dependencyMap[0], 'UIManager');

  function deprecatedPropType(propType, explanation) {
    return function validate(props, propName, componentName) {
      if (!UIManager[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;
},217,[218],"node_modules/react-native/Libraries/Utilities/deprecatedPropType.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var NativeModules = _$$_REQUIRE(_dependencyMap[0], 'NativeModules');

  var Platform = _$$_REQUIRE(_dependencyMap[1], 'Platform');

  var defineLazyObjectProperty = _$$_REQUIRE(_dependencyMap[2], 'defineLazyObjectProperty');

  var invariant = _$$_REQUIRE(_dependencyMap[3], 'fbjs/lib/invariant');

  var UIManager = NativeModules.UIManager;
  invariant(UIManager, 'UIManager is undefined. The native module config is probably incorrect.');
  UIManager.__takeSnapshot = UIManager.takeSnapshot;

  UIManager.takeSnapshot = function () {
    invariant(false, 'UIManager.takeSnapshot should not be called directly. ' + 'Use ReactNative.takeSnapshot instead.');
  };

  if (Platform.OS === 'ios') {
    Object.keys(UIManager).forEach(function (viewName) {
      var viewConfig = UIManager[viewName];

      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;
          }
        });
      }
    });
  } else if (UIManager.ViewManagerNames) {
    var residual = global.__residual ? global.__residual : function (_, f) {
      for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
        args[_key - 2] = arguments[_key];
      }

      return f.apply(undefined, args);
    };
    residual('void', function (UIManager, defineLazyObjectProperty) {
      UIManager.ViewManagerNames.forEach(function (viewManagerName) {
        defineLazyObjectProperty(UIManager, viewManagerName, {
          get: function get() {
            return UIManager.getConstantsForViewManager(viewManagerName);
          }
        });
      });
    }, UIManager, defineLazyObjectProperty);
    if (global.__makePartial) global.__makePartial(UIManager);
  }

  module.exports = UIManager;
},218,[168,176,185,166],"node_modules/react-native/Libraries/ReactNative/UIManager.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  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 ColorPropType = _$$_REQUIRE(_dependencyMap[0], 'ColorPropType');

  var ReactPropTypes = _$$_REQUIRE(_dependencyMap[1], 'prop-types');

  var ViewStylePropTypes = _$$_REQUIRE(_dependencyMap[2], 'ViewStylePropTypes');

  var TextStylePropTypes = _objectSpread({}, ViewStylePropTypes, {
    color: ColorPropType,
    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: ColorPropType,
    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: ColorPropType,
    textTransform: ReactPropTypes.oneOf(['none', 'capitalize', 'uppercase', 'lowercase']),
    writingDirection: ReactPropTypes.oneOf(['auto', 'ltr', 'rtl'])
  });

  module.exports = TextStylePropTypes;
},219,[207,212,220],"node_modules/react-native/Libraries/Text/TextStylePropTypes.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  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 ColorPropType = _$$_REQUIRE(_dependencyMap[0], 'ColorPropType');

  var LayoutPropTypes = _$$_REQUIRE(_dependencyMap[1], 'LayoutPropTypes');

  var ReactPropTypes = _$$_REQUIRE(_dependencyMap[2], 'prop-types');

  var ShadowPropTypesIOS = _$$_REQUIRE(_dependencyMap[3], 'ShadowPropTypesIOS');

  var TransformPropTypes = _$$_REQUIRE(_dependencyMap[4], 'TransformPropTypes');

  var ViewStylePropTypes = _objectSpread({}, LayoutPropTypes, ShadowPropTypesIOS, TransformPropTypes, {
    backfaceVisibility: ReactPropTypes.oneOf(['visible', 'hidden']),
    backgroundColor: ColorPropType,
    borderColor: ColorPropType,
    borderTopColor: ColorPropType,
    borderRightColor: ColorPropType,
    borderBottomColor: ColorPropType,
    borderLeftColor: ColorPropType,
    borderStartColor: ColorPropType,
    borderEndColor: ColorPropType,
    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 = ViewStylePropTypes;
},220,[207,211,212,215,216],"node_modules/react-native/Libraries/Components/View/ViewStylePropTypes.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var Platform = _$$_REQUIRE(_dependencyMap[0], 'Platform');

  var normalizeColor = _$$_REQUIRE(_dependencyMap[1], '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 (Platform.OS === 'android') {
      int32Color = int32Color | 0x0;
    }

    return int32Color;
  }

  module.exports = processColor;
},221,[176,208],"node_modules/react-native/Libraries/StyleSheet/processColor.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var MatrixMath = _$$_REQUIRE(_dependencyMap[0], 'MatrixMath');

  var Platform = _$$_REQUIRE(_dependencyMap[1], 'Platform');

  var invariant = _$$_REQUIRE(_dependencyMap[2], 'fbjs/lib/invariant');

  var stringifySafe = _$$_REQUIRE(_dependencyMap[3], 'stringifySafe');

  function processTransform(transform) {
    if (__DEV__) {
      _validateTransforms(transform);
    }

    if (Platform.OS === 'android' || Platform.OS === '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;
},222,[223,176,166,174],"node_modules/react-native/Libraries/StyleSheet/processTransform.js");
__d(function (global, _$$_REQUIRE, 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 invariant = _$$_REQUIRE(_dependencyMap[0], 'fbjs/lib/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);
        var 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 (i = 0; i < 3; i++) {
        row[i] = [matrix[i][0], matrix[i][1], matrix[i][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 (i = 0; i < 3; i++) {
          scale[i] *= -1;
          row[i][0] *= -1;
          row[i][1] *= -1;
          row[i][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;
},223,[166],"node_modules/react-native/Libraries/Utilities/MatrixMath.js");
__d(function (global, _$$_REQUIRE, 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;
},224,[],"node_modules/react-native/Libraries/Utilities/differ/sizesDiffer.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  var ImageStylePropTypes = _$$_REQUIRE(_dependencyMap[0], 'ImageStylePropTypes');

  var TextStylePropTypes = _$$_REQUIRE(_dependencyMap[1], 'TextStylePropTypes');

  var ViewStylePropTypes = _$$_REQUIRE(_dependencyMap[2], 'ViewStylePropTypes');

  var invariant = _$$_REQUIRE(_dependencyMap[3], 'fbjs/lib/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__) {
          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__) {
          return;
        }

        for (var prop in styles[name]) {
          StyleSheetValidation.validateStyleProp(prop, styles[name], 'StyleSheet ' + name);
        }
      }
    }, {
      key: "addValidStylePropTypes",
      value: function addValidStylePropTypes(stylePropTypes) {
        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 = {};
  StyleSheetValidation.addValidStylePropTypes(ImageStylePropTypes);
  StyleSheetValidation.addValidStylePropTypes(TextStylePropTypes);
  StyleSheetValidation.addValidStylePropTypes(ViewStylePropTypes);
  module.exports = StyleSheetValidation;
},225,[206,219,220,166],"node_modules/react-native/Libraries/StyleSheet/StyleSheetValidation.js");
__d(function (global, _$$_REQUIRE, 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;
},226,[],"node_modules/react-native/Libraries/StyleSheet/flattenStyle.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _jsxFileName = "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Components/View/View.js";

  function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

  var React = _$$_REQUIRE(_dependencyMap[0], 'React');

  var TextAncestor = _$$_REQUIRE(_dependencyMap[1], 'TextAncestor');

  var invariant = _$$_REQUIRE(_dependencyMap[2], 'fbjs/lib/invariant');

  var requireNativeComponent = _$$_REQUIRE(_dependencyMap[3], 'requireNativeComponent');

  var RCTView = requireNativeComponent('RCTView');
  var ViewToExport = RCTView;

  if (__DEV__) {
    ViewToExport = React.forwardRef(function (props, ref) {
      return React.createElement(TextAncestor.Consumer, {
        __source: {
          fileName: _jsxFileName,
          lineNumber: 37
        }
      }, function (hasTextAncestor) {
        invariant(!hasTextAncestor, 'Nesting of <View> within <Text> is not currently supported.');
        return React.createElement(RCTView, _extends({}, props, {
          ref: ref,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 43
          }
        }));
      });
    });
    ViewToExport.displayName = 'View';
  }

  module.exports = ViewToExport;
},227,[200,228,166,229],"node_modules/react-native/Libraries/Components/View/View.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var React = _$$_REQUIRE(_dependencyMap[0], 'React');

  module.exports = React.createContext(false);
},228,[200],"node_modules/react-native/Libraries/Text/TextAncestor.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

  function _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 ReactNativeStyleAttributes = _$$_REQUIRE(_dependencyMap[0], 'ReactNativeStyleAttributes');

  var UIManager = _$$_REQUIRE(_dependencyMap[1], 'UIManager');

  var createReactNativeComponentClass = _$$_REQUIRE(_dependencyMap[2], 'createReactNativeComponentClass');

  var insetsDiffer = _$$_REQUIRE(_dependencyMap[3], 'insetsDiffer');

  var matricesDiffer = _$$_REQUIRE(_dependencyMap[4], 'matricesDiffer');

  var pointsDiffer = _$$_REQUIRE(_dependencyMap[5], 'pointsDiffer');

  var processColor = _$$_REQUIRE(_dependencyMap[6], 'processColor');

  var resolveAssetSource = _$$_REQUIRE(_dependencyMap[7], 'resolveAssetSource');

  var sizesDiffer = _$$_REQUIRE(_dependencyMap[8], 'sizesDiffer');

  var invariant = _$$_REQUIRE(_dependencyMap[9], 'fbjs/lib/invariant');

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

  var requireNativeComponent = function requireNativeComponent(uiViewClassName) {
    return createReactNativeComponentClass(uiViewClassName, function () {
      var viewConfig = UIManager[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[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) {
    if (UIManager.ViewManagerNames) {
      viewConfig = merge(viewConfig, UIManager.getDefaultEventTypes());
    } else {
      viewConfig.bubblingEventTypes = merge(viewConfig.bubblingEventTypes, UIManager.genericBubblingEventTypes);
      viewConfig.directEventTypes = merge(viewConfig.directEventTypes, UIManager.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;
  }

  function processColorArray(colors) {
    return colors == null ? null : colors.map(processColor);
  }

  module.exports = requireNativeComponent;
},229,[205,218,230,232,233,234,221,235,224,166,183],"node_modules/react-native/Libraries/ReactNative/requireNativeComponent.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _require = _$$_REQUIRE(_dependencyMap[0], 'ReactNativeViewConfigRegistry'),
      register = _require.register;

  var createReactNativeComponentClass = function createReactNativeComponentClass(name, callback) {
    return register(name, callback);
  };

  module.exports = createReactNativeComponentClass;
},230,[231],"node_modules/react-native/Libraries/Renderer/shims/createReactNativeComponentClass.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

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

  var customBubblingEventTypes = {};
  var customDirectEventTypes = {};
  var eventTypes = {};
  exports.customBubblingEventTypes = customBubblingEventTypes;
  exports.customDirectEventTypes = customDirectEventTypes;
  exports.eventTypes = eventTypes;
  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) {
          eventTypes[_topLevelType] = customBubblingEventTypes[_topLevelType] = bubblingEventTypes[_topLevelType];
        }
      }
    }

    if (directEventTypes != null) {
      for (var _topLevelType2 in directEventTypes) {
        if (customDirectEventTypes[_topLevelType2] == null) {
          eventTypes[_topLevelType2] = 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);
      invariant(typeof callback === 'function', 'View config not found for name %s', name);
      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;
  };
},231,[166],"node_modules/react-native/Libraries/Renderer/shims/ReactNativeViewConfigRegistry.js");
__d(function (global, _$$_REQUIRE, 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;
},232,[],"node_modules/react-native/Libraries/Utilities/differ/insetsDiffer.js");
__d(function (global, _$$_REQUIRE, 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;
},233,[],"node_modules/react-native/Libraries/Utilities/differ/matricesDiffer.js");
__d(function (global, _$$_REQUIRE, 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;
},234,[],"node_modules/react-native/Libraries/Utilities/differ/pointsDiffer.js");
__d(function (global, _$$_REQUIRE, 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) {
      var NativeModules = _$$_REQUIRE(_dependencyMap[2], 'NativeModules');

      sourceCode = NativeModules && NativeModules.SourceCode;
    }

    _sourceCodeScriptURL = sourceCode.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;
},235,[236,237,168],"node_modules/react-native/Libraries/Image/resolveAssetSource.js");
__d(function (global, _$$_REQUIRE, 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
  };
},236,[],"node_modules/react-native/Libraries/Image/AssetRegistry.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  var PixelRatio = _$$_REQUIRE(_dependencyMap[0], 'PixelRatio');

  var Platform = _$$_REQUIRE(_dependencyMap[1], 'Platform');

  var assetPathUtils = _$$_REQUIRE(_dependencyMap[2], '../../local-cli/bundle/assetPathUtils');

  var invariant = _$$_REQUIRE(_dependencyMap[3], 'fbjs/lib/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 (Platform.OS === '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=' + Platform.OS + '&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(Platform.OS === '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;
},237,[202,176,238,166],"node_modules/react-native/Libraries/Image/AssetSourceResolver.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function getAndroidAssetSuffix(scale) {
    switch (scale) {
      case 0.75:
        return 'ldpi';

      case 1:
        return 'mdpi';

      case 1.5:
        return 'hdpi';

      case 2:
        return 'xhdpi';

      case 3:
        return 'xxhdpi';

      case 4:
        return 'xxxhdpi';
    }

    throw new Error('no such scale');
  }

  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 asset: " + JSON.stringify(asset));
    }

    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
  };
},238,[],"node_modules/react-native/local-cli/bundle/assetPathUtils.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  module.exports = _$$_REQUIRE(_dependencyMap[0], 'UnimplementedView');
},239,[240],"node_modules/react-native/Libraries/Components/ProgressBarAndroid/ProgressBarAndroid.ios.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _default = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[0], "react")).default;

  var _reactTransformHmrLibIndexJs = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./../../../../react-transform-hmr/lib/index.js")).default;

  var _jsxFileName = "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Components/UnimplementedViews/UnimplementedView.js";

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var _components = {
    UnimplementedView: {
      displayName: "UnimplementedView"
    }
  };

  var _reactTransformHmrLibIndexJs2 = _reactTransformHmrLibIndexJs({
    filename: "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Components/UnimplementedViews/UnimplementedView.js",
    components: _components,
    locals: [module],
    imports: [_default]
  });

  function _wrapComponent(id) {
    return function (Component) {
      return _reactTransformHmrLibIndexJs2(Component, id);
    };
  }

  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

  var React = _$$_REQUIRE(_dependencyMap[2], 'React');

  var StyleSheet = _$$_REQUIRE(_dependencyMap[3], 'StyleSheet');

  var UnimplementedView = function (_React$Component) {
    function UnimplementedView() {
      _classCallCheck(this, UnimplementedView);

      return _possibleConstructorReturn(this, _getPrototypeOf(UnimplementedView).apply(this, arguments));
    }

    _createClass(UnimplementedView, [{
      key: "setNativeProps",
      value: function setNativeProps() {}
    }, {
      key: "render",
      value: function render() {
        var View = _$$_REQUIRE(_dependencyMap[4], 'View');

        return React.createElement(View, {
          style: [styles.unimplementedView, this.props.style],
          __source: {
            fileName: _jsxFileName,
            lineNumber: 30
          }
        }, this.props.children);
      }
    }]);

    _inherits(UnimplementedView, _React$Component);

    return UnimplementedView;
  }(React.Component);

  UnimplementedView = _wrapComponent("UnimplementedView")(UnimplementedView);
  var styles = StyleSheet.create({
    unimplementedView: __DEV__ ? {
      alignSelf: 'flex-start',
      borderColor: 'red',
      borderWidth: 1
    } : {}
  });
  module.exports = UnimplementedView;
},240,[1,11,200,201,227],"node_modules/react-native/Libraries/Components/UnimplementedViews/UnimplementedView.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _default = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[0], "react")).default;

  var _reactTransformHmrLibIndexJs = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./../../../react-transform-hmr/lib/index.js")).default;

  var _jsxFileName = "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/ART/ReactNativeART.js";

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var _components = {
    Surface: {
      displayName: "Surface"
    },
    Group: {
      displayName: "Group"
    },
    ClippingRectangle: {
      displayName: "ClippingRectangle"
    },
    Shape: {
      displayName: "Shape"
    },
    Text: {
      displayName: "Text"
    }
  };

  var _reactTransformHmrLibIndexJs2 = _reactTransformHmrLibIndexJs({
    filename: "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/ART/ReactNativeART.js",
    components: _components,
    locals: [module],
    imports: [_default]
  });

  function _wrapComponent(id) {
    return function (Component) {
      return _reactTransformHmrLibIndexJs2(Component, id);
    };
  }

  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

  var Color = _$$_REQUIRE(_dependencyMap[2], 'art/core/color');

  var Path = _$$_REQUIRE(_dependencyMap[3], 'ARTSerializablePath');

  var Transform = _$$_REQUIRE(_dependencyMap[4], 'art/core/transform');

  var React = _$$_REQUIRE(_dependencyMap[5], 'React');

  var PropTypes = _$$_REQUIRE(_dependencyMap[6], 'prop-types');

  var ReactNativeViewAttributes = _$$_REQUIRE(_dependencyMap[7], 'ReactNativeViewAttributes');

  var createReactNativeComponentClass = _$$_REQUIRE(_dependencyMap[8], 'createReactNativeComponentClass');

  var merge = _$$_REQUIRE(_dependencyMap[9], 'merge');

  var invariant = _$$_REQUIRE(_dependencyMap[10], 'fbjs/lib/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) {
    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 props = this.props;
        var w = extractNumber(props.width, 0);
        var h = extractNumber(props.height, 0);
        return React.createElement(NativeSurfaceView, {
          style: [props.style, {
            width: w,
            height: h
          }],
          __source: {
            fileName: _jsxFileName,
            lineNumber: 157
          }
        }, this.props.children);
      }
    }]);

    _inherits(Surface, _React$Component);

    return Surface;
  }(React.Component);

  Surface.childContextTypes = {
    isInSurface: PropTypes.bool
  };
  Surface = _wrapComponent("Surface")(Surface);

  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) {
    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);
      }
    }]);

    _inherits(Group, _React$Component2);

    return Group;
  }(React.Component);

  Group.contextTypes = {
    isInSurface: PropTypes.bool.isRequired
  };
  Group = _wrapComponent("Group")(Group);

  var ClippingRectangle = function (_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);
      }
    }]);

    _inherits(ClippingRectangle, _React$Component3);

    return ClippingRectangle;
  }(React.Component);

  ClippingRectangle = _wrapComponent("ClippingRectangle")(ClippingRectangle);
  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) {
    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: 408
          }
        });
      }
    }]);

    _inherits(Shape, _React$Component4);

    return Shape;
  }(React.Component);

  Shape = _wrapComponent("Shape")(Shape);
  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) {
    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: 510
          }
        });
      }
    }]);

    _inherits(Text, _React$Component5);

    return Text;
  }(React.Component);

  Text = _wrapComponent("Text")(Text);

  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;
},241,[1,11,242,243,246,200,212,247,230,248,166],"node_modules/react-native/Libraries/ART/ReactNativeART.js");
__d(function (global, _$$_REQUIRE, 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;
},242,[],"node_modules/art/core/color.js");
__d(function (global, _$$_REQUIRE, 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;
},243,[244,245],"node_modules/react-native/Libraries/ART/ARTSerializablePath.js");
__d(function (global, _$$_REQUIRE, 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;
  };
},244,[],"node_modules/art/core/class.js");
__d(function (global, _$$_REQUIRE, 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);
    }
  });
},245,[244],"node_modules/art/core/path.js");
__d(function (global, _$$_REQUIRE, 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
      };
    }
  });
},246,[244],"node_modules/art/core/transform.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  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 ReactNativeStyleAttributes = _$$_REQUIRE(_dependencyMap[0], 'ReactNativeStyleAttributes');

  var ReactNativeViewAttributes = {};
  ReactNativeViewAttributes.UIView = {
    pointerEvents: true,
    accessible: true,
    accessibilityActions: true,
    accessibilityLabel: true,
    accessibilityComponentType: true,
    accessibilityLiveRegion: true,
    accessibilityTraits: true,
    importantForAccessibility: true,
    nativeID: true,
    testID: true,
    renderToHardwareTextureAndroid: true,
    shouldRasterizeIOS: true,
    onLayout: true,
    onAccessibilityAction: true,
    onAccessibilityTap: true,
    onMagicTap: true,
    collapsable: true,
    needsOffscreenAlphaCompositing: true,
    style: ReactNativeStyleAttributes
  };
  ReactNativeViewAttributes.RCTView = _objectSpread({}, ReactNativeViewAttributes.UIView, {
    removeClippedSubviews: true
  });
  module.exports = ReactNativeViewAttributes;
},247,[205],"node_modules/react-native/Libraries/Components/View/ReactNativeViewAttributes.js");
__d(function (global, _$$_REQUIRE, 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;
},248,[249],"node_modules/react-native/Libraries/vendor/core/merge.js");
__d(function (global, _$$_REQUIRE, 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 (!two.hasOwnProperty(key)) {
          continue;
        }

        one[key] = two[key];
      }
    }
  }

  module.exports = mergeInto;
},249,[250],"node_modules/react-native/Libraries/vendor/core/mergeInto.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var invariant = _$$_REQUIRE(_dependencyMap[0], 'fbjs/lib/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;
},250,[166],"node_modules/react-native/Libraries/vendor/core/mergeHelpers.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _default = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[0], "react")).default;

  var _reactTransformHmrLibIndexJs = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./../../../react-transform-hmr/lib/index.js")).default;

  var _jsxFileName = "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Components/Button.js";

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var _components = {
    Button: {
      displayName: "Button"
    }
  };

  var _reactTransformHmrLibIndexJs2 = _reactTransformHmrLibIndexJs({
    filename: "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Components/Button.js",
    components: _components,
    locals: [module],
    imports: [_default]
  });

  function _wrapComponent(id) {
    return function (Component) {
      return _reactTransformHmrLibIndexJs2(Component, id);
    };
  }

  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

  var ColorPropType = _$$_REQUIRE(_dependencyMap[2], 'ColorPropType');

  var Platform = _$$_REQUIRE(_dependencyMap[3], 'Platform');

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

  var PropTypes = _$$_REQUIRE(_dependencyMap[5], 'prop-types');

  var StyleSheet = _$$_REQUIRE(_dependencyMap[6], 'StyleSheet');

  var Text = _$$_REQUIRE(_dependencyMap[7], 'Text');

  var TouchableNativeFeedback = _$$_REQUIRE(_dependencyMap[8], 'TouchableNativeFeedback');

  var TouchableOpacity = _$$_REQUIRE(_dependencyMap[9], 'TouchableOpacity');

  var View = _$$_REQUIRE(_dependencyMap[10], 'View');

  var invariant = _$$_REQUIRE(_dependencyMap[11], 'fbjs/lib/invariant');

  var Button = function (_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,
            title = _this$props.title,
            hasTVPreferredFocus = _this$props.hasTVPreferredFocus,
            disabled = _this$props.disabled,
            testID = _this$props.testID;
        var buttonStyles = [styles.button];
        var textStyles = [styles.text];

        if (color) {
          if (Platform.OS === 'ios') {
            textStyles.push({
              color: color
            });
          } else {
            buttonStyles.push({
              backgroundColor: color
            });
          }
        }

        var accessibilityTraits = ['button'];

        if (disabled) {
          buttonStyles.push(styles.buttonDisabled);
          textStyles.push(styles.textDisabled);
          accessibilityTraits.push('disabled');
        }

        invariant(typeof title === 'string', 'The title prop of a Button must be a string');
        var formattedTitle = Platform.OS === 'android' ? title.toUpperCase() : title;
        var Touchable = Platform.OS === 'android' ? TouchableNativeFeedback : TouchableOpacity;
        return React.createElement(Touchable, {
          accessibilityComponentType: "button",
          accessibilityLabel: accessibilityLabel,
          accessibilityTraits: accessibilityTraits,
          hasTVPreferredFocus: hasTVPreferredFocus,
          testID: testID,
          disabled: disabled,
          onPress: onPress,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 127
          }
        }, React.createElement(View, {
          style: buttonStyles,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 135
          }
        }, React.createElement(Text, {
          style: textStyles,
          disabled: disabled,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 136
          }
        }, formattedTitle)));
      }
    }]);

    _inherits(Button, _React$Component);

    return Button;
  }(React.Component);

  Button.propTypes = {
    title: PropTypes.string.isRequired,
    accessibilityLabel: PropTypes.string,
    color: ColorPropType,
    disabled: PropTypes.bool,
    hasTVPreferredFocus: PropTypes.bool,
    onPress: PropTypes.func.isRequired,
    testID: PropTypes.string
  };
  Button = _wrapComponent("Button")(Button);
  var styles = StyleSheet.create({
    button: Platform.select({
      ios: {},
      android: {
        elevation: 4,
        backgroundColor: '#2196F3',
        borderRadius: 2
      }
    }),
    text: Platform.select({
      ios: {
        color: '#007AFF',
        textAlign: 'center',
        padding: 8,
        fontSize: 18
      },
      android: {
        color: 'white',
        textAlign: 'center',
        padding: 8,
        fontWeight: '500'
      }
    }),
    buttonDisabled: Platform.select({
      ios: {},
      android: {
        elevation: 0,
        backgroundColor: '#dfdfdf'
      }
    }),
    textDisabled: Platform.select({
      ios: {
        color: '#cdcdcd'
      },
      android: {
        color: '#a1a1a1'
      }
    })
  });
  module.exports = Button;
},251,[1,11,207,176,200,212,201,252,330,331,227,166],"node_modules/react-native/Libraries/Components/Button.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _default = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[0], "react")).default;

  var _reactTransformHmrLibIndexJs = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./../../../react-transform-hmr/lib/index.js")).default;

  var _jsxFileName = "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Text/Text.js";

  function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

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

  function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }

  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 _components = {
    TouchableText: {
      displayName: "TouchableText"
    }
  };

  var _reactTransformHmrLibIndexJs2 = _reactTransformHmrLibIndexJs({
    filename: "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Text/Text.js",
    components: _components,
    locals: [module],
    imports: [_default]
  });

  function _wrapComponent(id) {
    return function (Component) {
      return _reactTransformHmrLibIndexJs2(Component, id);
    };
  }

  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

  var React = _$$_REQUIRE(_dependencyMap[2], 'React');

  var ReactNativeViewAttributes = _$$_REQUIRE(_dependencyMap[3], 'ReactNativeViewAttributes');

  var TextAncestor = _$$_REQUIRE(_dependencyMap[4], 'TextAncestor');

  var TextPropTypes = _$$_REQUIRE(_dependencyMap[5], 'TextPropTypes');

  var Touchable = _$$_REQUIRE(_dependencyMap[6], 'Touchable');

  var UIManager = _$$_REQUIRE(_dependencyMap[7], 'UIManager');

  var createReactNativeComponentClass = _$$_REQUIRE(_dependencyMap[8], 'createReactNativeComponentClass');

  var nullthrows = _$$_REQUIRE(_dependencyMap[9], 'fbjs/lib/nullthrows');

  var processColor = _$$_REQUIRE(_dependencyMap[10], '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,
      disabled: true,
      selectable: true,
      selectionColor: true,
      adjustsFontSizeToFit: true,
      minimumFontScale: true,
      textBreakStrategy: true
    }),
    uiViewClassName: 'RCTText'
  };

  var TouchableText = function (_React$Component) {
    function TouchableText() {
      var _getPrototypeOf2;

      var _temp, _this;

      _classCallCheck(this, TouchableText);

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

      return _possibleConstructorReturn(_this, (_temp = _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(_assertThisInitialized(_this))),
        responseHandlers: null
      }), _temp));
    }

    _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: 139
          }
        }, function (hasTextAncestor) {
          return hasTextAncestor ? React.createElement(RCTVirtualText, _extends({}, props, {
            ref: props.forwardedRef,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 142
            }
          })) : React.createElement(TextAncestor.Provider, {
            value: true,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 144
            }
          }, React.createElement(RCTText, _extends({}, props, {
            ref: props.forwardedRef,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 145
            }
          })));
        });
      }
    }, {
      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) ? _objectSpread({}, prevState, {
          responseHandlers: prevState.createResponderHandlers()
        }) : null;
      }
    }]);

    _inherits(TouchableText, _React$Component);

    return TouchableText;
  }(React.Component);

  TouchableText.defaultProps = {
    accessible: true,
    allowFontScaling: true,
    ellipsizeMode: 'tail'
  };
  TouchableText.viewConfig = viewConfig;
  TouchableText = _wrapComponent("TouchableText")(TouchableText);

  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.RCTVirtualText == null ? RCTText : createReactNativeComponentClass('RCTVirtualText', function () {
    return {
      validAttributes: _objectSpread({}, ReactNativeViewAttributes.UIView, {
        isHighlighted: true
      }),
      uiViewClassName: 'RCTVirtualText'
    };
  });
  var Text = React.forwardRef(function (props, ref) {
    return React.createElement(TouchableText, _extends({}, props, {
      forwardedRef: ref,
      __source: {
        fileName: _jsxFileName,
        lineNumber: 266
      }
    }));
  });
  Text.displayName = 'Text';
  Text.propTypes = TextPropTypes;
  module.exports = Text;
},252,[1,11,200,247,228,253,257,218,230,329,221],"node_modules/react-native/Libraries/Text/Text.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var ColorPropType = _$$_REQUIRE(_dependencyMap[0], 'ColorPropType');

  var EdgeInsetsPropType = _$$_REQUIRE(_dependencyMap[1], 'EdgeInsetsPropType');

  var PropTypes = _$$_REQUIRE(_dependencyMap[2], 'prop-types');

  var StyleSheetPropType = _$$_REQUIRE(_dependencyMap[3], 'StyleSheetPropType');

  var TextStylePropTypes = _$$_REQUIRE(_dependencyMap[4], 'TextStylePropTypes');

  var stylePropType = StyleSheetPropType(TextStylePropTypes);
  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: EdgeInsetsPropType,
    selectable: PropTypes.bool,
    selectionColor: ColorPropType,
    suppressHighlighting: PropTypes.bool,
    style: stylePropType,
    testID: PropTypes.string,
    nativeID: PropTypes.string,
    allowFontScaling: PropTypes.bool,
    accessible: PropTypes.bool,
    adjustsFontSizeToFit: PropTypes.bool,
    minimumFontScale: PropTypes.number,
    disabled: PropTypes.bool
  };
},253,[207,254,212,255,219],"node_modules/react-native/Libraries/Text/TextPropTypes.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var PropTypes = _$$_REQUIRE(_dependencyMap[0], 'prop-types');

  var EdgeInsetsPropType = PropTypes.shape({
    top: PropTypes.number,
    left: PropTypes.number,
    bottom: PropTypes.number,
    right: PropTypes.number
  });
  module.exports = EdgeInsetsPropType;
},254,[212],"node_modules/react-native/Libraries/StyleSheet/EdgeInsetsPropType.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var createStrictShapeTypeChecker = _$$_REQUIRE(_dependencyMap[0], 'createStrictShapeTypeChecker');

  var flattenStyle = _$$_REQUIRE(_dependencyMap[1], 'flattenStyle');

  function StyleSheetPropType(shape) {
    var shapePropType = createStrictShapeTypeChecker(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 = StyleSheetPropType;
},255,[256,226],"node_modules/react-native/Libraries/StyleSheet/StyleSheetPropType.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

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

  var merge = _$$_REQUIRE(_dependencyMap[1], 'merge');

  function createStrictShapeTypeChecker(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 = createStrictShapeTypeChecker;
},256,[166,248],"node_modules/react-native/Libraries/Utilities/createStrictShapeTypeChecker.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _jsxFileName = "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Components/Touchable/Touchable.js";

  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 BoundingDimensions = _$$_REQUIRE(_dependencyMap[0], 'BoundingDimensions');

  var Platform = _$$_REQUIRE(_dependencyMap[1], 'Platform');

  var Position = _$$_REQUIRE(_dependencyMap[2], 'Position');

  var React = _$$_REQUIRE(_dependencyMap[3], 'React');

  var ReactNative = _$$_REQUIRE(_dependencyMap[4], 'ReactNative');

  var TVEventHandler = _$$_REQUIRE(_dependencyMap[5], 'TVEventHandler');

  var TouchEventUtils = _$$_REQUIRE(_dependencyMap[6], 'fbjs/lib/TouchEventUtils');

  var UIManager = _$$_REQUIRE(_dependencyMap[7], 'UIManager');

  var View = _$$_REQUIRE(_dependencyMap[8], 'View');

  var keyMirror = _$$_REQUIRE(_dependencyMap[9], 'fbjs/lib/keyMirror');

  var normalizeColor = _$$_REQUIRE(_dependencyMap[10], 'normalizeColor');

  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 IsActive = {
    RESPONDER_ACTIVE_PRESS_OUT: true,
    RESPONDER_ACTIVE_PRESS_IN: true
  };
  var IsPressingIn = {
    RESPONDER_INACTIVE_PRESS_IN: true,
    RESPONDER_ACTIVE_PRESS_IN: true,
    RESPONDER_ACTIVE_LONG_PRESS_IN: true
  };
  var IsLongPressingIn = {
    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.touchableHandleActivePressIn && cmp.touchableHandleActivePressIn(evt);
          } else if (evt.eventType === 'blur') {
            cmp.touchableHandleActivePressOut && cmp.touchableHandleActivePressOut(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._receiveSignal(Signals.RESPONDER_RELEASE, e);
    },
    touchableHandleResponderTerminate: function touchableHandleResponderTerminate(e) {
      this._receiveSignal(Signals.RESPONDER_TERMINATED, e);
    },
    touchableHandleResponderMove: function touchableHandleResponderMove(e) {
      if (this.state.touchable.touchState === States.RESPONDER_INACTIVE_PRESS_IN) {
        return;
      }

      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;
        pressExpandTop += hitSlop.top;
        pressExpandRight += hitSlop.right;
        pressExpandBottom += hitSlop.bottom;
      }

      var touch = TouchEventUtils.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) {
        this._receiveSignal(Signals.ENTER_PRESS_RECT, e);

        var curState = this.state.touchable.touchState;

        if (curState === States.RESPONDER_INACTIVE_PRESS_IN) {
          this._cancelLongPressDelayTimeout();
        }
      } else {
        this._cancelLongPressDelayTimeout();

        this._receiveSignal(Signals.LEAVE_PRESS_RECT, 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 = TouchEventUtils.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();
      }

      if (!IsActive[curState] && IsActive[nextState]) {
        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 (Platform.OS === 'android') {
            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);
        }
      }
    }
  };
  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 hexColor = '#' + ('00000000' + normalizeColor(color).toString(16)).substr(-8);
      return React.createElement(View, {
        pointerEvents: "none",
        style: _objectSpread({
          position: 'absolute',
          borderColor: hexColor.slice(0, -2) + '55',
          borderWidth: 1,
          borderStyle: 'dashed',
          backgroundColor: hexColor.slice(0, -2) + '0F'
        }, debugHitSlopStyle),
        __source: {
          fileName: _jsxFileName,
          lineNumber: 840
        }
      });
    }
  };
  module.exports = Touchable;
},257,[258,176,260,200,261,327,328,218,227,210,208],"node_modules/react-native/Libraries/Components/Touchable/Touchable.js");
__d(function (global, _$$_REQUIRE, 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;
},258,[259],"node_modules/react-native/Libraries/Components/Touchable/BoundingDimensions.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var invariant = _$$_REQUIRE(_dependencyMap[0], 'fbjs/lib/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;
},259,[166],"node_modules/react-native/Libraries/Components/Touchable/PooledClass.js");
__d(function (global, _$$_REQUIRE, 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;
},260,[259],"node_modules/react-native/Libraries/Components/Touchable/Position.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var ReactNative;

  if (__DEV__) {
    ReactNative = _$$_REQUIRE(_dependencyMap[0], 'ReactNativeRenderer-dev');
  } else {
    ReactNative = _$$_REQUIRE(_dependencyMap[1], 'ReactNativeRenderer-prod');
  }

  module.exports = ReactNative;
},261,[262,326],"node_modules/react-native/Libraries/Renderer/shims/ReactNative.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

  if (__DEV__) {
    (function () {
      "use strict";

      _$$_REQUIRE(_dependencyMap[0], "InitializeCore");

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

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

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

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

      var RCTEventEmitter = _$$_REQUIRE(_dependencyMap[5], "RCTEventEmitter");

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

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

      var deepFreezeAndThrowOnMutationInDev = _$$_REQUIRE(_dependencyMap[8], "deepFreezeAndThrowOnMutationInDev");

      var deepDiffer = _$$_REQUIRE(_dependencyMap[9], "deepDiffer");

      var flattenStyle = _$$_REQUIRE(_dependencyMap[10], "flattenStyle");

      var TextInputState = _$$_REQUIRE(_dependencyMap[11], "TextInputState");

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

      var ExceptionsManager = _$$_REQUIRE(_dependencyMap[13], "ExceptionsManager");

      var invokeGuardedCallback = function invokeGuardedCallback(name, func, context, a, b, c, d, e, f) {
        this._hasCaughtError = false;
        this._caughtError = null;
        var funcArgs = Array.prototype.slice.call(arguments, 3);

        try {
          func.apply(context, funcArgs);
        } catch (error) {
          this._caughtError = error;
          this._hasCaughtError = true;
        }
      };

      {
        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) {
            invariant(typeof document !== "undefined", "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 funcArgs = Array.prototype.slice.call(arguments, 3);

            function callCallback() {
              fakeNode.removeEventListener(evtType, callCallback, false);
              func.apply(context, funcArgs);
              didError = false;
            }

            var error = void 0;
            var didSetError = false;
            var isCrossOriginError = false;

            function onError(event) {
              error = event.error;
              didSetError = true;

              if (error === null && event.colno === 0 && event.lineno === 0) {
                isCrossOriginError = true;
              }
            }

            var evtType = "react-" + (name ? name : "invokeguardedcallback");
            window.addEventListener("error", onError);
            fakeNode.addEventListener(evtType, callCallback, false);
            evt.initEvent(evtType, false, false);
            fakeNode.dispatchEvent(evt);

            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._hasCaughtError = true;
              this._caughtError = error;
            } else {
              this._hasCaughtError = false;
              this._caughtError = null;
            }

            window.removeEventListener("error", onError);
          };

          invokeGuardedCallback = invokeGuardedCallbackDev;
        }
      }
      var invokeGuardedCallback$1 = invokeGuardedCallback;
      var ReactErrorUtils = {
        _caughtError: null,
        _hasCaughtError: false,
        _rethrowError: null,
        _hasRethrowError: false,
        invokeGuardedCallback: function invokeGuardedCallback(name, func, context, a, b, c, d, e, f) {
          invokeGuardedCallback$1.apply(ReactErrorUtils, arguments);
        },
        invokeGuardedCallbackAndCatchFirstError: function invokeGuardedCallbackAndCatchFirstError(name, func, context, a, b, c, d, e, f) {
          ReactErrorUtils.invokeGuardedCallback.apply(this, arguments);

          if (ReactErrorUtils.hasCaughtError()) {
            var error = ReactErrorUtils.clearCaughtError();

            if (!ReactErrorUtils._hasRethrowError) {
              ReactErrorUtils._hasRethrowError = true;
              ReactErrorUtils._rethrowError = error;
            }
          }
        },
        rethrowCaughtError: function rethrowCaughtError() {
          return _rethrowCaughtError.apply(ReactErrorUtils, arguments);
        },
        hasCaughtError: function hasCaughtError() {
          return ReactErrorUtils._hasCaughtError;
        },
        clearCaughtError: function clearCaughtError() {
          if (ReactErrorUtils._hasCaughtError) {
            var error = ReactErrorUtils._caughtError;
            ReactErrorUtils._caughtError = null;
            ReactErrorUtils._hasCaughtError = false;
            return error;
          } else {
            invariant(false, "clearCaughtError was called but no error was captured. This error " + "is likely caused by a bug in React. Please file an issue.");
          }
        }
      };

      var _rethrowCaughtError = function _rethrowCaughtError() {
        if (ReactErrorUtils._hasRethrowError) {
          var error = ReactErrorUtils._rethrowError;
          ReactErrorUtils._rethrowError = null;
          ReactErrorUtils._hasRethrowError = false;
          throw 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);
          invariant(pluginIndex > -1, "EventPluginRegistry: Cannot inject event plugins that do not exist in " + "the plugin ordering, `%s`.", pluginName);

          if (plugins[pluginIndex]) {
            continue;
          }

          invariant(pluginModule.extractEvents, "EventPluginRegistry: Event plugins must implement an `extractEvents` " + "method, but `%s` does not.", pluginName);
          plugins[pluginIndex] = pluginModule;
          var publishedEvents = pluginModule.eventTypes;

          for (var eventName in publishedEvents) {
            invariant(publishEventForPlugin(publishedEvents[eventName], pluginModule, eventName), "EventPluginRegistry: Failed to publish event `%s` for plugin `%s`.", eventName, pluginName);
          }
        }
      }

      function publishEventForPlugin(dispatchConfig, pluginModule, eventName) {
        invariant(!eventNameDispatchConfigs.hasOwnProperty(eventName), "EventPluginHub: More than one plugin attempted to publish the same " + "event name, `%s`.", 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) {
        invariant(!registrationNameModules[registrationName], "EventPluginHub: More than one plugin attempted to publish the same " + "registration name, `%s`.", 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) {
        invariant(!eventPluginOrder, "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) {
            invariant(!namesToPlugins[pluginName], "EventPluginRegistry: Cannot inject two different event plugins " + "using the same name, `%s`.", pluginName);
            namesToPlugins[pluginName] = pluginModule;
            isOrderingDirty = true;
          }
        }

        if (isOrderingDirty) {
          recomputePluginOrdering();
        }
      }

      var getFiberCurrentPropsFromNode = null;
      var getInstanceFromNode = null;
      var getNodeFromInstance = null;
      var injection$1 = {
        injectComponentTree: function injectComponentTree(Injected) {
          getFiberCurrentPropsFromNode = Injected.getFiberCurrentPropsFromNode;
          getInstanceFromNode = Injected.getInstanceFromNode;
          getNodeFromInstance = Injected.getNodeFromInstance;
          {
            !(getNodeFromInstance && getInstanceFromNode) ? warning(false, "EventPluginUtils.injection.injectComponentTree(...): 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) ? warning(false, "EventPluginUtils: Invalid `event`.") : void 0;
        };
      }

      function executeDispatch(event, simulated, listener, inst) {
        var type = event.type || "unknown-event";
        event.currentTarget = getNodeFromInstance(inst);
        ReactErrorUtils.invokeGuardedCallbackAndCatchFirstError(type, listener, undefined, event);
        event.currentTarget = null;
      }

      function executeDispatchesInOrder(event, simulated) {
        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, simulated, dispatchListeners[i], dispatchInstances[i]);
          }
        } else if (dispatchListeners) {
          executeDispatch(event, simulated, 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;
        invariant(!Array.isArray(dispatchListener), "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) {
        invariant(next != null, "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, simulated) {
        if (event) {
          executeDispatchesInOrder(event, simulated);

          if (!event.isPersistent()) {
            event.constructor.release(event);
          }
        }
      };

      var executeDispatchesAndReleaseSimulated = function executeDispatchesAndReleaseSimulated(e) {
        return executeDispatchesAndRelease(e, true);
      };

      var executeDispatchesAndReleaseTopLevel = function executeDispatchesAndReleaseTopLevel(e) {
        return executeDispatchesAndRelease(e, false);
      };

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

        invariant(!listener || typeof listener === "function", "Expected `%s` listener to be a function, instead got a value of `%s` type.", registrationName, typeof listener);
        return listener;
      }

      function extractEvents(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 runEventsInBatch(events, simulated) {
        if (events !== null) {
          eventQueue = accumulateInto(eventQueue, events);
        }

        var processingEventQueue = eventQueue;
        eventQueue = null;

        if (!processingEventQueue) {
          return;
        }

        if (simulated) {
          forEachAccumulated(processingEventQueue, executeDispatchesAndReleaseSimulated);
        } else {
          forEachAccumulated(processingEventQueue, executeDispatchesAndReleaseTopLevel);
        }

        invariant(!eventQueue, "processEventQueue(): Additional events were enqueued while processing " + "an event queue. Support for this has not yet been implemented.");
        ReactErrorUtils.rethrowCaughtError();
      }

      function runExtractedEventsInBatch(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
        var events = extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget);
        runEventsInBatch(events, false);
      }

      var IndeterminateComponent = 0;
      var FunctionalComponent = 1;
      var ClassComponent = 2;
      var HostRoot = 3;
      var HostPortal = 4;
      var HostComponent = 5;
      var HostText = 6;
      var Fragment = 10;
      var Mode = 11;
      var ContextConsumer = 12;
      var ContextProvider = 13;
      var ForwardRef = 14;
      var Profiler = 15;
      var TimeoutComponent = 16;

      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 ? warning(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 didWarnForAddedNewProperty = false;
      var EVENT_POOL_SIZE = 10;
      var shouldBeReleasedProperties = ["dispatchConfig", "_targetInst", "nativeEvent", "isDefaultPrevented", "isPropagationStopped", "_dispatchListeners", "_dispatchInstances"];
      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;
        }
        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]));
            }
          }

          for (var i = 0; i < shouldBeReleasedProperties.length; i++) {
            this[shouldBeReleasedProperties[i]] = null;
          }

          {
            Object.defineProperty(this, "nativeEvent", getPooledWarningPropertyDefinition("nativeEvent", null));
            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;
      };

      {
        var isProxySupported = typeof Proxy === "function" && !Object.isSealed(new Proxy({}, {}));

        if (isProxySupported) {
          SyntheticEvent = new Proxy(SyntheticEvent, {
            construct: function construct(target, args) {
              return this.apply(target, Object.create(target.prototype), args);
            },
            apply: function apply(constructor, that, args) {
              return new Proxy(constructor.apply(that, args), {
                set: function set(target, prop, value) {
                  if (prop !== "isPersistent" && !target.constructor.Interface.hasOwnProperty(prop) && shouldBeReleasedProperties.indexOf(prop) === -1) {
                    !(didWarnForAddedNewProperty || target.isPersistent()) ? warning(false, "This synthetic event is reused for performance reasons. If you're " + "seeing this, you're adding a new property in the synthetic event object. " + "The property is never released. See " + "https://fb.me/react-event-pooling for more information.") : void 0;
                    didWarnForAddedNewProperty = true;
                  }

                  target[prop] = value;
                  return true;
                }
              });
            }
          });
        }
      }
      addEventPoolingTo(SyntheticEvent);

      function getPooledWarningPropertyDefinition(propName, getVal) {
        var isFunction = typeof getVal === "function";
        return {
          configurable: true,
          set: set,
          get: get$$1
        };

        function set(val) {
          var action = isFunction ? "setting the method" : "setting the property";
          warn(action, "This is effectively a no-op");
          return val;
        }

        function get$$1() {
          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 ? warning(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;
        invariant(event instanceof EventConstructor, "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 SyntheticEvent$1 = SyntheticEvent;
      var ResponderSyntheticEvent = SyntheticEvent$1.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;
        invariant(identifier != null, "Touch object is missing identifier.");
        {
          !(identifier <= MAX_TOUCH_BANK) ? warning(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.error("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.error("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) ? warning(false, "Cannot find single active touch.") : void 0;
              }
            }
          }
        },
        touchHistory: touchHistory
      };

      function accumulate(current, next) {
        invariant(next != null, "accumulate(...): Accumulated items must be 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$1 = {
        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$1.startShouldSetResponder : isMoveish(topLevelType) ? eventTypes$1.moveShouldSetResponder : topLevelType === TOP_SELECTION_CHANGE ? eventTypes$1.selectionChangeShouldSetResponder : eventTypes$1.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$1.responderGrant, wantsResponderInst, nativeEvent, nativeEventTarget);
        grantEvent.touchHistory = ResponderTouchHistoryStore.touchHistory;
        accumulateDirectDispatches(grantEvent);
        var blockHostResponder = executeDirectDispatch(grantEvent) === true;

        if (responderInst) {
          var terminationRequestEvent = ResponderSyntheticEvent.getPooled(eventTypes$1.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$1.responderTerminate, responderInst, nativeEvent, nativeEventTarget);
            terminateEvent.touchHistory = ResponderTouchHistoryStore.touchHistory;
            accumulateDirectDispatches(terminateEvent);
            extracted = accumulate(extracted, [grantEvent, terminateEvent]);
            changeResponder(wantsResponderInst, blockHostResponder);
          } else {
            var rejectEvent = ResponderSyntheticEvent.getPooled(eventTypes$1.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$1,
        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$1.responderStart : isResponderTouchMove ? eventTypes$1.responderMove : isResponderTouchEnd ? eventTypes$1.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$1.responderTerminate : isResponderRelease ? eventTypes$1.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$1 = ReactNativeViewConfigRegistry.customBubblingEventTypes;
      var customDirectEventTypes$1 = ReactNativeViewConfigRegistry.customDirectEventTypes;
      var eventTypes$2 = ReactNativeViewConfigRegistry.eventTypes;
      var ReactNativeBridgeEventPlugin = {
        eventTypes: eventTypes$2,
        extractEvents: function extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
          if (targetInst == null) {
            return null;
          }

          var bubbleDispatchConfig = customBubblingEventTypes$1[topLevelType];
          var directDispatchConfig = customDirectEventTypes$1[topLevelType];
          invariant(bubbleDispatchConfig || directDispatchConfig, 'Unsupported top level event type "%s" dispatched', topLevelType);
          var event = SyntheticEvent$1.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 = {};
      var instanceProps = {};

      function precacheFiberNode(hostInst, tag) {
        instanceCache[tag] = hostInst;
      }

      function uncacheFiberNode(tag) {
        delete instanceCache[tag];
        delete instanceProps[tag];
      }

      function getInstanceFromTag(tag) {
        return instanceCache[tag] || null;
      }

      function getTagFromInstance(inst) {
        var tag = inst.stateNode._nativeTag;

        if (tag === undefined) {
          tag = inst.stateNode.canonical._nativeTag;
        }

        invariant(tag, "All native instances should have a tag.");
        return tag;
      }

      function getFiberCurrentPropsFromNode$1(stateNode) {
        return instanceProps[stateNode._nativeTag] || null;
      }

      function updateFiberProps(tag, props) {
        instanceProps[tag] = props;
      }

      var ReactNativeComponentTree = Object.freeze({
        precacheFiberNode: precacheFiberNode,
        uncacheFiberNode: uncacheFiberNode,
        getClosestInstanceFromNode: getInstanceFromTag,
        getInstanceFromNode: getInstanceFromTag,
        getNodeFromInstance: getTagFromInstance,
        getFiberCurrentPropsFromNode: getFiberCurrentPropsFromNode$1,
        updateFiberProps: updateFiberProps
      });
      var fiberHostComponent = null;
      var restoreTarget = null;
      var restoreQueue = null;

      function restoreStateOfTarget(target) {
        var internalInstance = getInstanceFromNode(target);

        if (!internalInstance) {
          return;
        }

        invariant(fiberHostComponent && typeof fiberHostComponent.restoreControlledState === "function", "Fiber needs to be injected to handle a fiber target for controlled " + "events. This error is likely caused by a bug in React. Please file an issue.");
        var props = getFiberCurrentPropsFromNode(internalInstance.stateNode);
        fiberHostComponent.restoreControlledState(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 _batchedUpdates = function _batchedUpdates(fn, bookkeeping) {
        return fn(bookkeeping);
      };

      var _interactiveUpdates = function _interactiveUpdates(fn, a, b) {
        return fn(a, b);
      };

      var _flushInteractiveUpdates = function _flushInteractiveUpdates() {};

      var isBatching = false;

      function batchedUpdates(fn, bookkeeping) {
        if (isBatching) {
          return fn(bookkeeping);
        }

        isBatching = true;

        try {
          return _batchedUpdates(fn, bookkeeping);
        } finally {
          isBatching = false;
          var controlledComponentsHavePendingUpdates = needsStateRestore();

          if (controlledComponentsHavePendingUpdates) {
            _flushInteractiveUpdates();

            restoreStateIfNeeded();
          }
        }
      }

      var injection$2 = {
        injectRenderer: function injectRenderer(renderer) {
          _batchedUpdates = renderer.batchedUpdates;
          _interactiveUpdates = renderer.interactiveUpdates;
          _flushInteractiveUpdates = renderer.flushInteractiveUpdates;
        }
      };
      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 () {
          runExtractedEventsInBatch(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) {
              {
                warning(false, "A view is reporting that a touch occurred on tag zero.");
              }
            } else {
              rootNodeID = target;
            }
          }

          _receiveRootNodeIDEvent(rootNodeID, eventTopLevelType, nativeEvent);
        }
      }

      var ReactNativeEventEmitter = Object.freeze({
        getListener: getListener,
        registrationNames: registrationNameModules,
        _receiveRootNodeIDEvent: _receiveRootNodeIDEvent,
        receiveEvent: receiveEvent,
        receiveTouches: receiveTouches
      });
      var ReactNativeGlobalResponderHandler = {
        onChange: function onChange(from, to, blockNativeResponder) {
          if (to !== null) {
            var tag = to.stateNode._nativeTag;
            UIManager.setJSResponder(tag, blockNativeResponder);
          } else {
            UIManager.clearJSResponder();
          }
        }
      };
      RCTEventEmitter.register(ReactNativeEventEmitter);
      injection$1.injectComponentTree(ReactNativeComponentTree);
      ResponderEventPlugin.injection.injectGlobalResponderHandler(ReactNativeGlobalResponderHandler);

      function get$1(key) {
        return key._reactInternalFiber;
      }

      function set(key, value) {
        key._reactInternalFiber = value;
      }

      var ReactInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
      var ReactCurrentOwner = ReactInternals.ReactCurrentOwner;
      var ReactDebugCurrentFrame = ReactInternals.ReactDebugCurrentFrame;
      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_FORWARD_REF_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.forward_ref") : 0xead0;
      var REACT_TIMEOUT_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.timeout") : 0xead1;
      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 === "undefined") {
          return null;
        }

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

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

        return null;
      }

      function getComponentName(fiber) {
        var type = fiber.type;

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

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

        switch (type) {
          case REACT_ASYNC_MODE_TYPE:
            return "AsyncMode";

          case REACT_CONTEXT_TYPE:
            return "Context.Consumer";

          case REACT_FRAGMENT_TYPE:
            return "ReactFragment";

          case REACT_PORTAL_TYPE:
            return "ReactPortal";

          case REACT_PROFILER_TYPE:
            return "Profiler(" + fiber.pendingProps.id + ")";

          case REACT_PROVIDER_TYPE:
            return "Context.Provider";

          case REACT_STRICT_MODE_TYPE:
            return "StrictMode";

          case REACT_TIMEOUT_TYPE:
            return "Timeout";
        }

        if (typeof type === "object" && type !== null) {
          switch (type.$$typeof) {
            case REACT_FORWARD_REF_TYPE:
              var functionName = type.render.displayName || type.render.name || "";
              return functionName !== "" ? "ForwardRef(" + functionName + ")" : "ForwardRef";
          }
        }

        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 HostEffectMask = 511;
      var Incomplete = 512;
      var ShouldCapture = 1024;
      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.current;

          if (owner !== null && owner.tag === ClassComponent) {
            var ownerFiber = owner;
            var instance = ownerFiber.stateNode;
            !instance._warnedAboutRefsInRender ? warning(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) || "A component") : void 0;
            instance._warnedAboutRefsInRender = true;
          }
        }
        var fiber = get$1(component);

        if (!fiber) {
          return false;
        }

        return isFiberMountedImpl(fiber) === MOUNTED;
      }

      function assertIsMounted(fiber) {
        invariant(isFiberMountedImpl(fiber) === MOUNTED, "Unable to find node on an unmounted component.");
      }

      function findCurrentFiberUsingSlowPath(fiber) {
        var alternate = fiber.alternate;

        if (!alternate) {
          var state = isFiberMountedImpl(fiber);
          invariant(state !== UNMOUNTED, "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;
          var parentB = parentA ? parentA.alternate : null;

          if (!parentA || !parentB) {
            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;
            }

            invariant(false, "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;
              }

              invariant(didFindChild, "Child was not found in either parent set. This indicates a bug " + "in React related to the return pointer. Please file an issue.");
            }
          }

          invariant(a.alternate === b, "Return fibers should always be each others' alternates. " + "This error is likely caused by a bug in React. Please file an issue.");
        }

        invariant(a.tag === HostRoot, "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 findCurrentHostFiberWithNoPortals(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.tag !== HostPortal) {
            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$1 = {};
      var removedKeys = null;
      var removedKeyCount = 0;

      function defaultDiffer(prevProp, nextProp) {
        if (typeof nextProp !== "object" || nextProp === null) {
          return true;
        } else {
          return 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, flattenStyle(prevProp), nextProp, validAttributes);
        }

        return diffProperties(updatePayload, prevProp, 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$1, props, validAttributes);
      }

      function clearProperties(updatePayload, prevProps, validAttributes) {
        return diffProperties(updatePayload, prevProps, emptyObject$1, validAttributes);
      }

      function create(props, validAttributes) {
        return addProperties(null, props, validAttributes);
      }

      function diff(prevProps, nextProps, validAttributes) {
        return diffProperties(null, prevProps, nextProps, validAttributes);
      }

      function mountSafeCallback(context, callback) {
        return function () {
          if (!callback) {
            return undefined;
          }

          if (typeof context.__isMounted === "boolean") {
            if (!context.__isMounted) {
              return undefined;
            }
          } else if (typeof context.isMounted === "function") {
            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() {
          TextInputState.blurTextInput(this._nativeTag);
        };

        ReactNativeFiberHostComponent.prototype.focus = function focus() {
          TextInputState.focusTextInput(this._nativeTag);
        };

        ReactNativeFiberHostComponent.prototype.measure = function measure(callback) {
          UIManager.measure(this._nativeTag, mountSafeCallback(this, callback));
        };

        ReactNativeFiberHostComponent.prototype.measureInWindow = function measureInWindow(callback) {
          UIManager.measureInWindow(this._nativeTag, mountSafeCallback(this, callback));
        };

        ReactNativeFiberHostComponent.prototype.measureLayout = function measureLayout(relativeToNativeNode, onSuccess, onFail) {
          UIManager.measureLayout(this._nativeTag, relativeToNativeNode, mountSafeCallback(this, onFail), mountSafeCallback(this, onSuccess));
        };

        ReactNativeFiberHostComponent.prototype.setNativeProps = function setNativeProps(nativeProps) {
          {
            warnForStyleProps(nativeProps, this.viewConfig.validAttributes);
          }
          var updatePayload = create(nativeProps, this.viewConfig.validAttributes);

          if (updatePayload != null) {
            UIManager.updateView(this._nativeTag, this.viewConfig.uiViewClassName, updatePayload);
          }
        };

        return ReactNativeFiberHostComponent;
      }();

      var hasNativePerformanceNow = typeof performance === "object" && typeof performance.now === "function";
      var now$1 = hasNativePerformanceNow ? function () {
        return performance.now();
      } : function () {
        return Date.now();
      };
      var scheduledCallback = null;
      var frameDeadline = 0;
      var frameDeadlineObject = {
        timeRemaining: function timeRemaining() {
          return frameDeadline - now$1();
        },
        didTimeout: false
      };

      function setTimeoutCallback() {
        frameDeadline = now$1() + 5;
        var callback = scheduledCallback;
        scheduledCallback = null;

        if (callback !== null) {
          callback(frameDeadlineObject);
        }
      }

      function scheduleDeferredCallback$1(callback, options) {
        scheduledCallback = callback;
        var timeoutId = setTimeout(setTimeoutCallback, 1);
        return timeoutId;
      }

      function cancelDeferredCallback$1(callbackID) {
        scheduledCallback = null;
        clearTimeout(callbackID);
      }

      function shim() {
        invariant(false, "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 createContainerChildSet = shim;
      var appendChildToContainerChildSet = shim;
      var finalizeContainerChildren = shim;
      var replaceContainerChildren = shim;

      function shim$1() {
        invariant(false, "The current renderer does not support hyration. " + "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 getNextHydratableSibling = shim$1;
      var getFirstHydratableChild = shim$1;
      var hydrateInstance = shim$1;
      var hydrateTextInstance = 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 didNotFindHydratableInstance = shim$1;
      var didNotFindHydratableTextInstance = shim$1;
      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 = ReactNativeViewConfigRegistry.get(type);
        {
          for (var key in viewConfig.validAttributes) {
            if (props.hasOwnProperty(key)) {
              deepFreezeAndThrowOnMutationInDev(props[key]);
            }
          }
        }
        invariant(type !== "RCTView" || !hostContext.isInAParentText, "Nesting of <View> within <Text> is not currently supported.");
        var updatePayload = create(props, viewConfig.validAttributes);
        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) {
        invariant(hostContext.isInAParentText, "Text strings must be rendered within a <Text> component.");
        var tag = allocateTag();
        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;
        });

        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 emptyObject;
      }

      function resetAfterCommit(containerInfo) {}

      var now = now$1;
      var isPrimaryRenderer = true;
      var scheduleDeferredCallback = scheduleDeferredCallback$1;
      var cancelDeferredCallback = cancelDeferredCallback$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);
          UIManager.manageChildren(parentInstance._nativeTag, [index], [children.length - 1], [], [], []);
        } else {
          children.push(child);
          UIManager.manageChildren(parentInstance._nativeTag, [], [], [childTag], [children.length - 1], []);
        }
      }

      function appendChildToContainer(parentInstance, child) {
        var childTag = typeof child === "number" ? child : child._nativeTag;
        UIManager.setChildren(parentInstance, [childTag]);
      }

      function commitTextUpdate(textInstance, oldText, newText) {
        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) {
          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);
          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;
          UIManager.manageChildren(parentInstance._nativeTag, [], [], [childTag], [_beforeChildIndex], []);
        }
      }

      function insertInContainerBefore(parentInstance, child, beforeChild) {
        invariant(typeof parentInstance !== "number", "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);
        UIManager.manageChildren(parentInstance._nativeTag, [], [], [], [], [index]);
      }

      function removeChildFromContainer(parentInstance, child) {
        recursivelyUncacheFiberNode(child);
        UIManager.manageChildren(parentInstance, [], [], [], [], [0]);
      }

      function resetTextContent(instance) {}

      var describeComponentFrame = function describeComponentFrame(name, source, ownerName) {
        return "\n    in " + (name || "Unknown") + (source ? " (at " + source.fileName.replace(/^.*[\\\/]/, "") + ":" + source.lineNumber + ")" : ownerName ? " (created by " + ownerName + ")" : "");
      };

      function describeFiber(fiber) {
        switch (fiber.tag) {
          case IndeterminateComponent:
          case FunctionalComponent:
          case ClassComponent:
          case HostComponent:
            var owner = fiber._debugOwner;
            var source = fiber._debugSource;
            var name = getComponentName(fiber);
            var ownerName = null;

            if (owner) {
              ownerName = getComponentName(owner);
            }

            return describeComponentFrame(name, source, ownerName);

          default:
            return "";
        }
      }

      function getStackAddendumByWorkInProgressFiber(workInProgress) {
        var info = "";
        var node = workInProgress;

        do {
          info += describeFiber(node);
          node = node.return;
        } while (node);

        return info;
      }

      function getCurrentFiberOwnerName() {
        {
          var fiber = ReactDebugCurrentFiber.current;

          if (fiber === null) {
            return null;
          }

          var owner = fiber._debugOwner;

          if (owner !== null && typeof owner !== "undefined") {
            return getComponentName(owner);
          }
        }
        return null;
      }

      function getCurrentFiberStackAddendum() {
        {
          var fiber = ReactDebugCurrentFiber.current;

          if (fiber === null) {
            return null;
          }

          return getStackAddendumByWorkInProgressFiber(fiber);
        }
        return null;
      }

      function resetCurrentFiber() {
        ReactDebugCurrentFrame.getCurrentStack = null;
        ReactDebugCurrentFiber.current = null;
        ReactDebugCurrentFiber.phase = null;
      }

      function setCurrentFiber(fiber) {
        ReactDebugCurrentFrame.getCurrentStack = getCurrentFiberStackAddendum;
        ReactDebugCurrentFiber.current = fiber;
        ReactDebugCurrentFiber.phase = null;
      }

      function setCurrentPhase(phase) {
        ReactDebugCurrentFiber.phase = phase;
      }

      var ReactDebugCurrentFiber = {
        current: null,
        phase: null,
        resetCurrentFiber: resetCurrentFiber,
        setCurrentFiber: setCurrentFiber,
        setCurrentPhase: setCurrentPhase,
        getCurrentFiberOwnerName: getCurrentFiberOwnerName,
        getCurrentFiberStackAddendum: getCurrentFiberStackAddendum
      };
      var debugRenderPhaseSideEffects = false;
      var debugRenderPhaseSideEffectsForStrictMode = false;
      var enableGetDerivedStateFromCatch = false;
      var enableSuspense = false;
      var enableUserTimingAPI = true;
      var replayFailedUnitOfWorkWithInvokeGuardedCallback = true;
      var warnAboutDeprecatedLifecycles = false;
      var warnAboutLegacyContextAPI = false;
      var enableProfilerTimer = true;
      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$$1) {
        var prefix = warning$$1 ? warningEmoji + " " : reactEmoji + " ";
        var suffix = warning$$1 ? " Warning: " + warning$$1 : "";
        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$$1) {
        var formattedMarkName = formatMarkName(markName);
        var formattedLabel = formatLabel(label, warning$$1);

        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) || "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) || "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$$1) {
        var componentName = getComponentName(fiber) || "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$$1);
      };

      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, expirationTime) {
        if (enableUserTimingAPI) {
          if (supportsUserTiming) {
            isWaitingForCallback = false;
            var warning$$1 = didExpire ? "React was blocked by main thread" : null;
            endMark("(Waiting for async callback... will force flush in " + expirationTime + " ms)", "(Waiting for async callback...)", warning$$1);
          }
        }
      }

      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$$1 = "An error was thrown inside this error boundary";
          endFiberMark(fiber, null, warning$$1);
        }
      }

      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$$1 = hasScheduledUpdateInCurrentPhase ? "Scheduled a cascading update" : null;
            endFiberMark(currentPhaseFiber, currentPhase, warning$$1);
          }

          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$$1 = null;

          if (interruptedBy !== null) {
            if (interruptedBy.tag === HostRoot) {
              warning$$1 = "A top-level update interrupted the previous render";
            } else {
              var componentName = getComponentName(interruptedBy) || "Unknown";
              warning$$1 = "An update to " + componentName + " interrupted the previous render";
            }
          } else if (commitCountInCurrentWorkLoop > 1) {
            warning$$1 = "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$$1);
        }
      }

      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$$1 = null;

          if (hasScheduledUpdateInCurrentCommit) {
            warning$$1 = "Lifecycle hook scheduled a cascading update";
          } else if (commitCountInCurrentWorkLoop > 0) {
            warning$$1 = "Caused by a cascading update in earlier commit";
          }

          hasScheduledUpdateInCurrentCommit = false;
          commitCountInCurrentWorkLoop++;
          isCommitting = false;
          labelsInCurrentCommit.clear();
          endMark("(Committing Changes)", "(Committing Changes)", warning$$1);
        }
      }

      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) {
          {
            warning(false, "Unexpected pop.");
          }
          return;
        }

        {
          if (fiber !== fiberStack[index]) {
            warning(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;
      }

      function checkThatStackIsEmpty() {
        {
          if (index !== -1) {
            warning(false, "Expected an empty stack. Something was not reset properly.");
          }
        }
      }

      function resetStackAfterFatalErrorInDev() {
        {
          index = -1;
          valueStack.length = 0;
          fiberStack.length = 0;
        }
      }

      var warnedAboutMissingGetChildContext = void 0;
      {
        warnedAboutMissingGetChildContext = {};
      }
      var contextStackCursor = createCursor(emptyObject);
      var didPerformWorkStackCursor = createCursor(false);
      var previousContext = emptyObject;

      function getUnmaskedContext(workInProgress) {
        var hasOwnContext = isContextProvider(workInProgress);

        if (hasOwnContext) {
          return previousContext;
        }

        return contextStackCursor.current;
      }

      function cacheContext(workInProgress, unmaskedContext, maskedContext) {
        var instance = workInProgress.stateNode;
        instance.__reactInternalMemoizedUnmaskedChildContext = unmaskedContext;
        instance.__reactInternalMemoizedMaskedChildContext = maskedContext;
      }

      function getMaskedContext(workInProgress, unmaskedContext) {
        var type = workInProgress.type;
        var contextTypes = type.contextTypes;

        if (!contextTypes) {
          return emptyObject;
        }

        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(workInProgress) || "Unknown";
          checkPropTypes(contextTypes, context, "context", name, ReactDebugCurrentFiber.getCurrentFiberStackAddendum);
        }

        if (instance) {
          cacheContext(workInProgress, unmaskedContext, context);
        }

        return context;
      }

      function hasContextChanged() {
        return didPerformWorkStackCursor.current;
      }

      function isContextConsumer(fiber) {
        return fiber.tag === ClassComponent && fiber.type.contextTypes != null;
      }

      function isContextProvider(fiber) {
        return fiber.tag === ClassComponent && fiber.type.childContextTypes != null;
      }

      function popContextProvider(fiber) {
        if (!isContextProvider(fiber)) {
          return;
        }

        pop(didPerformWorkStackCursor, fiber);
        pop(contextStackCursor, fiber);
      }

      function popTopLevelContextObject(fiber) {
        pop(didPerformWorkStackCursor, fiber);
        pop(contextStackCursor, fiber);
      }

      function pushTopLevelContextObject(fiber, context, didChange) {
        invariant(contextStackCursor.current === emptyObject, "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, parentContext) {
        var instance = fiber.stateNode;
        var childContextTypes = fiber.type.childContextTypes;

        if (typeof instance.getChildContext !== "function") {
          {
            var componentName = getComponentName(fiber) || "Unknown";

            if (!warnedAboutMissingGetChildContext[componentName]) {
              warnedAboutMissingGetChildContext[componentName] = true;
              warning(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;
        {
          ReactDebugCurrentFiber.setCurrentPhase("getChildContext");
        }
        startPhaseTimer(fiber, "getChildContext");
        childContext = instance.getChildContext();
        stopPhaseTimer();
        {
          ReactDebugCurrentFiber.setCurrentPhase(null);
        }

        for (var contextKey in childContext) {
          invariant(contextKey in childContextTypes, '%s.getChildContext(): key "%s" is not defined in childContextTypes.', getComponentName(fiber) || "Unknown", contextKey);
        }

        {
          var name = getComponentName(fiber) || "Unknown";
          checkPropTypes(childContextTypes, childContext, "child context", name, ReactDebugCurrentFiber.getCurrentFiberStackAddendum);
        }
        return _extends({}, parentContext, childContext);
      }

      function pushContextProvider(workInProgress) {
        if (!isContextProvider(workInProgress)) {
          return false;
        }

        var instance = workInProgress.stateNode;
        var memoizedMergedChildContext = instance && instance.__reactInternalMemoizedMergedChildContext || emptyObject;
        previousContext = contextStackCursor.current;
        push(contextStackCursor, memoizedMergedChildContext, workInProgress);
        push(didPerformWorkStackCursor, didPerformWorkStackCursor.current, workInProgress);
        return true;
      }

      function invalidateContextProvider(workInProgress, didChange) {
        var instance = workInProgress.stateNode;
        invariant(instance, "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, 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) {
        invariant(isFiberMounted(fiber) && fiber.tag === ClassComponent, "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;

        while (node.tag !== HostRoot) {
          if (isContextProvider(node)) {
            return node.stateNode.__reactInternalMemoizedMergedChildContext;
          }

          var parent = node.return;
          invariant(parent, "Found unexpected detached subtree parent. " + "This error is likely caused by a bug in React. Please file an issue.");
          node = parent;
        }

        return node.stateNode.context;
      }

      var MAX_SIGNED_31_BIT_INT = 1073741823;
      var NoWork = 0;
      var Sync = 1;
      var Never = MAX_SIGNED_31_BIT_INT;
      var UNIT_SIZE = 10;
      var MAGIC_NUMBER_OFFSET = 2;

      function msToExpirationTime(ms) {
        return (ms / UNIT_SIZE | 0) + MAGIC_NUMBER_OFFSET;
      }

      function expirationTimeToMs(expirationTime) {
        return (expirationTime - MAGIC_NUMBER_OFFSET) * UNIT_SIZE;
      }

      function ceiling(num, precision) {
        return ((num / precision | 0) + 1) * precision;
      }

      function computeExpirationBucket(currentTime, expirationInMs, bucketSizeMs) {
        return MAGIC_NUMBER_OFFSET + ceiling(currentTime - MAGIC_NUMBER_OFFSET + expirationInMs / UNIT_SIZE, bucketSizeMs / UNIT_SIZE);
      }

      var NoContext = 0;
      var AsyncMode = 1;
      var StrictMode = 2;
      var ProfileMode = 4;
      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.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.mode = mode;
        this.effectTag = NoEffect;
        this.nextEffect = null;
        this.firstEffect = null;
        this.lastEffect = null;
        this.expirationTime = NoWork;
        this.alternate = null;

        if (enableProfilerTimer) {
          this.actualDuration = 0;
          this.actualStartTime = 0;
          this.selfBaseTime = 0;
          this.treeBaseTime = 0;
        }

        {
          this._debugID = debugCounter++;
          this._debugSource = null;
          this._debugOwner = null;
          this._debugIsCurrentlyTiming = false;

          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) {
        return !!(Component.prototype && Component.prototype.isReactComponent);
      }

      function createWorkInProgress(current, pendingProps, expirationTime) {
        var workInProgress = current.alternate;

        if (workInProgress === null) {
          workInProgress = createFiber(current.tag, pendingProps, current.key, current.mode);
          workInProgress.type = current.type;
          workInProgress.stateNode = current.stateNode;
          {
            workInProgress._debugID = current._debugID;
            workInProgress._debugSource = current._debugSource;
            workInProgress._debugOwner = current._debugOwner;
          }
          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 = 0;
          }
        }

        workInProgress.expirationTime = expirationTime;
        workInProgress.child = current.child;
        workInProgress.memoizedProps = current.memoizedProps;
        workInProgress.memoizedState = current.memoizedState;
        workInProgress.updateQueue = current.updateQueue;
        workInProgress.sibling = current.sibling;
        workInProgress.index = current.index;
        workInProgress.ref = current.ref;

        if (enableProfilerTimer) {
          workInProgress.selfBaseTime = current.selfBaseTime;
          workInProgress.treeBaseTime = current.treeBaseTime;
        }

        return workInProgress;
      }

      function createHostRootFiber(isAsync) {
        var mode = isAsync ? AsyncMode | StrictMode : NoContext;
        return createFiber(HostRoot, null, null, mode);
      }

      function createFiberFromElement(element, mode, expirationTime) {
        var owner = null;
        {
          owner = element._owner;
        }
        var fiber = void 0;
        var type = element.type;
        var key = element.key;
        var pendingProps = element.props;
        var fiberTag = void 0;

        if (typeof type === "function") {
          fiberTag = shouldConstruct(type) ? ClassComponent : IndeterminateComponent;
        } else if (typeof type === "string") {
          fiberTag = HostComponent;
        } else {
          switch (type) {
            case REACT_FRAGMENT_TYPE:
              return createFiberFromFragment(pendingProps.children, mode, expirationTime, key);

            case REACT_ASYNC_MODE_TYPE:
              fiberTag = Mode;
              mode |= AsyncMode | StrictMode;
              break;

            case REACT_STRICT_MODE_TYPE:
              fiberTag = Mode;
              mode |= StrictMode;
              break;

            case REACT_PROFILER_TYPE:
              return createFiberFromProfiler(pendingProps, mode, expirationTime, key);

            case REACT_TIMEOUT_TYPE:
              fiberTag = TimeoutComponent;
              mode |= StrictMode;
              break;

            default:
              fiberTag = getFiberTagFromObjectType(type, owner);
              break;
          }
        }

        fiber = createFiber(fiberTag, pendingProps, key, mode);
        fiber.type = type;
        fiber.expirationTime = expirationTime;
        {
          fiber._debugSource = element._source;
          fiber._debugOwner = element._owner;
        }
        return fiber;
      }

      function getFiberTagFromObjectType(type, owner) {
        var $$typeof = typeof type === "object" && type !== null ? type.$$typeof : null;

        switch ($$typeof) {
          case REACT_PROVIDER_TYPE:
            return ContextProvider;

          case REACT_CONTEXT_TYPE:
            return ContextConsumer;

          case REACT_FORWARD_REF_TYPE:
            return ForwardRef;

          default:
            {
              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) : null;

                if (ownerName) {
                  info += "\n\nCheck the render method of `" + ownerName + "`.";
                }
              }
              invariant(false, "Element type is invalid: expected a string (for built-in " + "components) or a class/function (for composite components) " + "but got: %s.%s", type == null ? type : typeof type, info);
            }
        }
      }

      function createFiberFromFragment(elements, mode, expirationTime, key) {
        var fiber = createFiber(Fragment, elements, key, mode);
        fiber.expirationTime = expirationTime;
        return fiber;
      }

      function createFiberFromProfiler(pendingProps, mode, expirationTime, key) {
        {
          if (typeof pendingProps.id !== "string" || typeof pendingProps.onRender !== "function") {
            invariant(false, 'Profiler must specify an "id" string and "onRender" function as props');
          }
        }
        var fiber = createFiber(Profiler, pendingProps, key, mode | ProfileMode);
        fiber.type = REACT_PROFILER_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, NoContext);
        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, NoContext);
        }

        target.tag = source.tag;
        target.key = source.key;
        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.mode = source.mode;
        target.effectTag = source.effectTag;
        target.nextEffect = source.nextEffect;
        target.firstEffect = source.firstEffect;
        target.lastEffect = source.lastEffect;
        target.expirationTime = source.expirationTime;
        target.alternate = source.alternate;

        if (enableProfilerTimer) {
          target.actualDuration = source.actualDuration;
          target.actualStartTime = source.actualStartTime;
          target.selfBaseTime = source.selfBaseTime;
          target.treeBaseTime = source.treeBaseTime;
        }

        target._debugID = source._debugID;
        target._debugSource = source._debugSource;
        target._debugOwner = source._debugOwner;
        target._debugIsCurrentlyTiming = source._debugIsCurrentlyTiming;
        return target;
      }

      function createFiberRoot(containerInfo, isAsync, hydrate) {
        var uninitializedFiber = createHostRootFiber(isAsync);
        var root = {
          current: uninitializedFiber,
          containerInfo: containerInfo,
          pendingChildren: null,
          earliestPendingTime: NoWork,
          latestPendingTime: NoWork,
          earliestSuspendedTime: NoWork,
          latestSuspendedTime: NoWork,
          latestPingedTime: NoWork,
          didError: false,
          pendingCommitExpirationTime: NoWork,
          finishedWork: null,
          context: null,
          pendingContext: null,
          hydrate: hydrate,
          nextExpirationTimeToWorkOn: NoWork,
          expirationTime: NoWork,
          firstBatch: null,
          nextScheduledRoot: null
        };
        uninitializedFiber.stateNode = root;
        return root;
      }

      var onCommitFiberRoot = null;
      var onCommitFiberUnmount = null;
      var hasLoggedError = false;

      function catchErrors(fn) {
        return function (arg) {
          try {
            return fn(arg);
          } catch (err) {
            if (true && !hasLoggedError) {
              hasLoggedError = true;
              warning(false, "React DevTools encountered an error: %s", err);
            }
          }
        };
      }

      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) {
          {
            warning(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 = catchErrors(function (root) {
            return hook.onCommitFiberRoot(rendererID, root);
          });
          onCommitFiberUnmount = catchErrors(function (fiber) {
            return hook.onCommitFiberUnmount(rendererID, fiber);
          });
        } catch (err) {
          {
            warning(false, "React DevTools encountered an error: %s.", err);
          }
        }

        return true;
      }

      function onCommitRoot(root) {
        if (typeof onCommitFiberRoot === "function") {
          onCommitFiberRoot(root);
        }
      }

      function onCommitUnmount(fiber) {
        if (typeof onCommitFiberUnmount === "function") {
          onCommitFiberUnmount(fiber);
        }
      }

      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("`warning(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 = {
        discardPendingWarnings: function discardPendingWarnings() {},
        flushPendingDeprecationWarnings: function flushPendingDeprecationWarnings() {},
        flushPendingUnsafeLifecycleWarnings: function flushPendingUnsafeLifecycleWarnings() {},
        recordDeprecationWarnings: function recordDeprecationWarnings(fiber, instance) {},
        recordUnsafeLifecycleWarnings: function recordUnsafeLifecycleWarnings(fiber, instance) {},
        recordLegacyContextWarning: function recordLegacyContextWarning(fiber, instance) {},
        flushLegacyContextWarning: function flushLegacyContextWarning() {}
      };
      {
        var LIFECYCLE_SUGGESTIONS = {
          UNSAFE_componentWillMount: "componentDidMount",
          UNSAFE_componentWillReceiveProps: "static getDerivedStateFromProps",
          UNSAFE_componentWillUpdate: "componentDidUpdate"
        };
        var pendingComponentWillMountWarnings = [];
        var pendingComponentWillReceivePropsWarnings = [];
        var pendingComponentWillUpdateWarnings = [];
        var pendingUnsafeLifecycleWarnings = new Map();
        var pendingLegacyContextWarning = new Map();
        var didWarnAboutDeprecatedLifecycles = new Set();
        var didWarnAboutUnsafeLifecycles = new Set();
        var didWarnAboutLegacyContext = new Set();

        var setToSortedString = function setToSortedString(set) {
          var array = [];
          set.forEach(function (value) {
            array.push(value);
          });
          return array.sort().join(", ");
        };

        ReactStrictModeWarnings.discardPendingWarnings = function () {
          pendingComponentWillMountWarnings = [];
          pendingComponentWillReceivePropsWarnings = [];
          pendingComponentWillUpdateWarnings = [];
          pendingUnsafeLifecycleWarnings = new Map();
          pendingLegacyContextWarning = new Map();
        };

        ReactStrictModeWarnings.flushPendingUnsafeLifecycleWarnings = function () {
          pendingUnsafeLifecycleWarnings.forEach(function (lifecycleWarningsMap, strictRoot) {
            var lifecyclesWarningMesages = [];
            Object.keys(lifecycleWarningsMap).forEach(function (lifecycle) {
              var lifecycleWarnings = lifecycleWarningsMap[lifecycle];

              if (lifecycleWarnings.length > 0) {
                var componentNames = new Set();
                lifecycleWarnings.forEach(function (fiber) {
                  componentNames.add(getComponentName(fiber) || "Component");
                  didWarnAboutUnsafeLifecycles.add(fiber.type);
                });
                var formatted = lifecycle.replace("UNSAFE_", "");
                var suggestion = LIFECYCLE_SUGGESTIONS[lifecycle];
                var sortedComponentNames = setToSortedString(componentNames);
                lifecyclesWarningMesages.push(formatted + ": Please update the following components to use " + (suggestion + " instead: " + sortedComponentNames));
              }
            });

            if (lifecyclesWarningMesages.length > 0) {
              var strictRootComponentStack = getStackAddendumByWorkInProgressFiber(strictRoot);
              warning(false, "Unsafe lifecycle methods were found within a strict-mode tree:%s" + "\n\n%s" + "\n\nLearn more about this warning here:" + "\nhttps://fb.me/react-strict-mode-warnings", strictRootComponentStack, lifecyclesWarningMesages.join("\n\n"));
            }
          });
          pendingUnsafeLifecycleWarnings = new Map();
        };

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

        ReactStrictModeWarnings.flushPendingDeprecationWarnings = function () {
          if (pendingComponentWillMountWarnings.length > 0) {
            var uniqueNames = new Set();
            pendingComponentWillMountWarnings.forEach(function (fiber) {
              uniqueNames.add(getComponentName(fiber) || "Component");
              didWarnAboutDeprecatedLifecycles.add(fiber.type);
            });
            var sortedNames = setToSortedString(uniqueNames);
            lowPriorityWarning$1(false, "componentWillMount is deprecated and will be removed in the next major version. " + "Use componentDidMount instead. As a temporary workaround, " + "you can rename to UNSAFE_componentWillMount." + "\n\nPlease update the following components: %s" + "\n\nLearn more about this warning here:" + "\nhttps://fb.me/react-async-component-lifecycle-hooks", sortedNames);
            pendingComponentWillMountWarnings = [];
          }

          if (pendingComponentWillReceivePropsWarnings.length > 0) {
            var _uniqueNames = new Set();

            pendingComponentWillReceivePropsWarnings.forEach(function (fiber) {
              _uniqueNames.add(getComponentName(fiber) || "Component");

              didWarnAboutDeprecatedLifecycles.add(fiber.type);
            });

            var _sortedNames = setToSortedString(_uniqueNames);

            lowPriorityWarning$1(false, "componentWillReceiveProps is deprecated and will be removed in the next major version. " + "Use static getDerivedStateFromProps instead." + "\n\nPlease update the following components: %s" + "\n\nLearn more about this warning here:" + "\nhttps://fb.me/react-async-component-lifecycle-hooks", _sortedNames);
            pendingComponentWillReceivePropsWarnings = [];
          }

          if (pendingComponentWillUpdateWarnings.length > 0) {
            var _uniqueNames2 = new Set();

            pendingComponentWillUpdateWarnings.forEach(function (fiber) {
              _uniqueNames2.add(getComponentName(fiber) || "Component");

              didWarnAboutDeprecatedLifecycles.add(fiber.type);
            });

            var _sortedNames2 = setToSortedString(_uniqueNames2);

            lowPriorityWarning$1(false, "componentWillUpdate is deprecated and will be removed in the next major version. " + "Use componentDidUpdate instead. As a temporary workaround, " + "you can rename to UNSAFE_componentWillUpdate." + "\n\nPlease update the following components: %s" + "\n\nLearn more about this warning here:" + "\nhttps://fb.me/react-async-component-lifecycle-hooks", _sortedNames2);
            pendingComponentWillUpdateWarnings = [];
          }
        };

        ReactStrictModeWarnings.recordDeprecationWarnings = function (fiber, instance) {
          if (didWarnAboutDeprecatedLifecycles.has(fiber.type)) {
            return;
          }

          if (typeof instance.componentWillMount === "function" && instance.componentWillMount.__suppressDeprecationWarning !== true) {
            pendingComponentWillMountWarnings.push(fiber);
          }

          if (typeof instance.componentWillReceiveProps === "function" && instance.componentWillReceiveProps.__suppressDeprecationWarning !== true) {
            pendingComponentWillReceivePropsWarnings.push(fiber);
          }

          if (typeof instance.componentWillUpdate === "function" && instance.componentWillUpdate.__suppressDeprecationWarning !== true) {
            pendingComponentWillUpdateWarnings.push(fiber);
          }
        };

        ReactStrictModeWarnings.recordUnsafeLifecycleWarnings = function (fiber, instance) {
          var strictRoot = findStrictRoot(fiber);

          if (strictRoot === null) {
            warning(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 (didWarnAboutUnsafeLifecycles.has(fiber.type)) {
            return;
          }

          var warningsForRoot = void 0;

          if (!pendingUnsafeLifecycleWarnings.has(strictRoot)) {
            warningsForRoot = {
              UNSAFE_componentWillMount: [],
              UNSAFE_componentWillReceiveProps: [],
              UNSAFE_componentWillUpdate: []
            };
            pendingUnsafeLifecycleWarnings.set(strictRoot, warningsForRoot);
          } else {
            warningsForRoot = pendingUnsafeLifecycleWarnings.get(strictRoot);
          }

          var unsafeLifecycles = [];

          if (typeof instance.componentWillMount === "function" && instance.componentWillMount.__suppressDeprecationWarning !== true || typeof instance.UNSAFE_componentWillMount === "function") {
            unsafeLifecycles.push("UNSAFE_componentWillMount");
          }

          if (typeof instance.componentWillReceiveProps === "function" && instance.componentWillReceiveProps.__suppressDeprecationWarning !== true || typeof instance.UNSAFE_componentWillReceiveProps === "function") {
            unsafeLifecycles.push("UNSAFE_componentWillReceiveProps");
          }

          if (typeof instance.componentWillUpdate === "function" && instance.componentWillUpdate.__suppressDeprecationWarning !== true || typeof instance.UNSAFE_componentWillUpdate === "function") {
            unsafeLifecycles.push("UNSAFE_componentWillUpdate");
          }

          if (unsafeLifecycles.length > 0) {
            unsafeLifecycles.forEach(function (lifecycle) {
              warningsForRoot[lifecycle].push(fiber);
            });
          }
        };

        ReactStrictModeWarnings.recordLegacyContextWarning = function (fiber, instance) {
          var strictRoot = findStrictRoot(fiber);

          if (strictRoot === null) {
            warning(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) || "Component");
              didWarnAboutLegacyContext.add(fiber.type);
            });
            var sortedNames = setToSortedString(uniqueNames);
            var strictRootComponentStack = getStackAddendumByWorkInProgressFiber(strictRoot);
            warning(false, "Legacy context API has been detected within a strict-mode tree: %s" + "\n\nPlease update the following components: %s" + "\n\nLearn more about this warning here:" + "\nhttps://fb.me/react-strict-mode-warnings", strictRootComponentStack, sortedNames);
          });
        };
      }
      var ReactFiberInstrumentation = {
        debugTool: null
      };
      var ReactFiberInstrumentation_1 = ReactFiberInstrumentation;

      function markPendingPriorityLevel(root, expirationTime) {
        root.didError = false;
        var earliestPendingTime = root.earliestPendingTime;

        if (earliestPendingTime === NoWork) {
          root.earliestPendingTime = root.latestPendingTime = expirationTime;
        } else {
          if (earliestPendingTime > expirationTime) {
            root.earliestPendingTime = expirationTime;
          } else {
            var latestPendingTime = root.latestPendingTime;

            if (latestPendingTime < expirationTime) {
              root.latestPendingTime = expirationTime;
            }
          }
        }

        findNextPendingPriorityLevel(root);
      }

      function markCommittedPriorityLevels(root, currentTime, earliestRemainingTime) {
        root.didError = false;

        if (earliestRemainingTime === NoWork) {
          root.earliestPendingTime = NoWork;
          root.latestPendingTime = NoWork;
          root.earliestSuspendedTime = NoWork;
          root.latestSuspendedTime = NoWork;
          root.latestPingedTime = NoWork;
          findNextPendingPriorityLevel(root);
          return;
        }

        var latestPendingTime = root.latestPendingTime;

        if (latestPendingTime !== NoWork) {
          if (latestPendingTime < earliestRemainingTime) {
            root.earliestPendingTime = root.latestPendingTime = NoWork;
          } else {
            var earliestPendingTime = root.earliestPendingTime;

            if (earliestPendingTime < earliestRemainingTime) {
              root.earliestPendingTime = root.latestPendingTime;
            }
          }
        }

        var earliestSuspendedTime = root.earliestSuspendedTime;

        if (earliestSuspendedTime === NoWork) {
          markPendingPriorityLevel(root, earliestRemainingTime);
          findNextPendingPriorityLevel(root);
          return;
        }

        var latestSuspendedTime = root.latestSuspendedTime;

        if (earliestRemainingTime > latestSuspendedTime) {
          root.earliestSuspendedTime = NoWork;
          root.latestSuspendedTime = NoWork;
          root.latestPingedTime = NoWork;
          markPendingPriorityLevel(root, earliestRemainingTime);
          findNextPendingPriorityLevel(root);
          return;
        }

        if (earliestRemainingTime < earliestSuspendedTime) {
          markPendingPriorityLevel(root, earliestRemainingTime);
          findNextPendingPriorityLevel(root);
          return;
        }

        findNextPendingPriorityLevel(root);
      }

      function hasLowerPriorityWork(root, renderExpirationTime) {
        return renderExpirationTime !== root.latestPendingTime && renderExpirationTime !== root.latestSuspendedTime;
      }

      function markSuspendedPriorityLevel(root, suspendedTime, didError) {
        if (didError && !hasLowerPriorityWork(root, suspendedTime)) {
          root.didError = true;
          findNextPendingPriorityLevel(root);
          return;
        }

        var earliestPendingTime = root.earliestPendingTime;
        var latestPendingTime = root.latestPendingTime;

        if (earliestPendingTime === suspendedTime) {
          if (latestPendingTime === suspendedTime) {
            root.earliestPendingTime = root.latestPendingTime = NoWork;
          } else {
            root.earliestPendingTime = latestPendingTime;
          }
        } else if (latestPendingTime === suspendedTime) {
          root.latestPendingTime = earliestPendingTime;
        }

        var latestSuspendedTime = root.latestSuspendedTime;

        if (latestSuspendedTime === suspendedTime) {
          root.latestPingedTime = NoWork;
        }

        var earliestSuspendedTime = root.earliestSuspendedTime;

        if (earliestSuspendedTime === NoWork) {
          root.earliestSuspendedTime = root.latestSuspendedTime = suspendedTime;
        } else {
          if (earliestSuspendedTime > suspendedTime) {
            root.earliestSuspendedTime = suspendedTime;
          } else if (latestSuspendedTime < suspendedTime) {
            root.latestSuspendedTime = suspendedTime;
          }
        }

        findNextPendingPriorityLevel(root);
      }

      function markPingedPriorityLevel(root, pingedTime) {
        var latestSuspendedTime = root.latestSuspendedTime;

        if (latestSuspendedTime !== NoWork && latestSuspendedTime <= pingedTime) {
          var latestPingedTime = root.latestPingedTime;

          if (latestPingedTime === NoWork || latestPingedTime < pingedTime) {
            root.latestPingedTime = pingedTime;
          }
        }

        findNextPendingPriorityLevel(root);
      }

      function findNextPendingPriorityLevel(root) {
        var earliestSuspendedTime = root.earliestSuspendedTime;
        var earliestPendingTime = root.earliestPendingTime;
        var nextExpirationTimeToWorkOn = void 0;
        var expirationTime = void 0;

        if (earliestSuspendedTime === NoWork) {
          nextExpirationTimeToWorkOn = expirationTime = earliestPendingTime;
        } else if (earliestPendingTime !== NoWork) {
          nextExpirationTimeToWorkOn = earliestPendingTime;
          expirationTime = earliestSuspendedTime < earliestPendingTime ? earliestSuspendedTime : earliestPendingTime;
        } else {
          nextExpirationTimeToWorkOn = expirationTime = root.latestPingedTime;
        }

        if (root.didError) {
          expirationTime = Sync;
        }

        root.nextExpirationTimeToWorkOn = nextExpirationTimeToWorkOn;
        root.expirationTime = expirationTime;
      }

      var UpdateState = 0;
      var ReplaceState = 1;
      var ForceUpdate = 2;
      var CaptureUpdate = 3;
      var hasForceUpdate = false;
      var didWarnUpdateInsideUpdate = void 0;
      var currentlyProcessingQueue = void 0;
      var resetCurrentlyProcessingQueue = void 0;
      {
        didWarnUpdateInsideUpdate = false;
        currentlyProcessingQueue = null;

        resetCurrentlyProcessingQueue = function resetCurrentlyProcessingQueue() {
          currentlyProcessingQueue = null;
        };
      }

      function createUpdateQueue(baseState) {
        var queue = {
          expirationTime: NoWork,
          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 = {
          expirationTime: currentQueue.expirationTime,
          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) {
        return {
          expirationTime: expirationTime,
          tag: UpdateState,
          payload: null,
          callback: null,
          next: null,
          nextEffect: null
        };
      }

      function appendUpdateToQueue(queue, update, expirationTime) {
        if (queue.lastUpdate === null) {
          queue.firstUpdate = queue.lastUpdate = update;
        } else {
          queue.lastUpdate.next = update;
          queue.lastUpdate = update;
        }

        if (queue.expirationTime === NoWork || queue.expirationTime > expirationTime) {
          queue.expirationTime = expirationTime;
        }
      }

      function enqueueUpdate(fiber, update, expirationTime) {
        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, expirationTime);
        } else {
          if (queue1.lastUpdate === null || queue2.lastUpdate === null) {
            appendUpdateToQueue(queue1, update, expirationTime);
            appendUpdateToQueue(queue2, update, expirationTime);
          } else {
            appendUpdateToQueue(queue1, update, expirationTime);
            queue2.lastUpdate = update;
          }
        }

        {
          if (fiber.tag === ClassComponent && (currentlyProcessingQueue === queue1 || queue2 !== null && currentlyProcessingQueue === queue2) && !didWarnUpdateInsideUpdate) {
            warning(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, renderExpirationTime) {
        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;
        }

        if (workInProgressQueue.expirationTime === NoWork || workInProgressQueue.expirationTime > renderExpirationTime) {
          workInProgressQueue.expirationTime = renderExpirationTime;
        }
      }

      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") {
                {
                  if (debugRenderPhaseSideEffects || debugRenderPhaseSideEffectsForStrictMode && workInProgress.mode & StrictMode) {
                    _payload.call(instance, prevState, nextProps);
                  }
                }
                return _payload.call(instance, prevState, nextProps);
              }

              return _payload;
            }

          case CaptureUpdate:
            {
              workInProgress.effectTag = workInProgress.effectTag & ~ShouldCapture | DidCapture;
            }

          case UpdateState:
            {
              var _payload2 = update.payload;
              var partialState = void 0;

              if (typeof _payload2 === "function") {
                {
                  if (debugRenderPhaseSideEffects || debugRenderPhaseSideEffectsForStrictMode && workInProgress.mode & StrictMode) {
                    _payload2.call(instance, prevState, nextProps);
                  }
                }
                partialState = _payload2.call(instance, prevState, nextProps);
              } 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;

        if (queue.expirationTime === NoWork || queue.expirationTime > renderExpirationTime) {
          return;
        }

        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 === NoWork || newExpirationTime > updateExpirationTime) {
              newExpirationTime = updateExpirationTime;
            }
          } else {
            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 === NoWork || 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;
        queue.expirationTime = newExpirationTime;
        workInProgress.memoizedState = resultState;
        {
          currentlyProcessingQueue = null;
        }
      }

      function callCallback(callback, context) {
        invariant(typeof callback === "function", "Invalid argument passed as callback. Expected a function. Instead " + "received: %s", 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;
        }

        var effect = finishedQueue.firstEffect;
        finishedQueue.firstEffect = finishedQueue.lastEffect = null;

        while (effect !== null) {
          var _callback3 = effect.callback;

          if (_callback3 !== null) {
            effect.callback = null;
            callCallback(_callback3, instance);
          }

          effect = effect.nextEffect;
        }

        effect = finishedQueue.firstCapturedEffect;
        finishedQueue.firstCapturedEffect = finishedQueue.lastCapturedEffect = null;

        while (effect !== null) {
          var _callback4 = effect.callback;

          if (_callback4 !== null) {
            effect.callback = null;
            callCallback(_callback4, instance);
          }

          effect = effect.nextEffect;
        }
      }

      function createCapturedValue(value, source) {
        return {
          value: value,
          source: source,
          stack: getStackAddendumByWorkInProgressFiber(source)
        };
      }

      var providerCursor = createCursor(null);
      var valueCursor = createCursor(null);
      var changedBitsCursor = createCursor(0);
      var rendererSigil = void 0;
      {
        rendererSigil = {};
      }

      function pushProvider(providerFiber) {
        var context = providerFiber.type._context;

        if (isPrimaryRenderer) {
          push(changedBitsCursor, context._changedBits, providerFiber);
          push(valueCursor, context._currentValue, providerFiber);
          push(providerCursor, providerFiber, providerFiber);
          context._currentValue = providerFiber.pendingProps.value;
          context._changedBits = providerFiber.stateNode;
          {
            !(context._currentRenderer === undefined || context._currentRenderer === null || context._currentRenderer === rendererSigil) ? warning(false, "Detected multiple renderers concurrently rendering the " + "same context provider. This is currently unsupported.") : void 0;
            context._currentRenderer = rendererSigil;
          }
        } else {
          push(changedBitsCursor, context._changedBits2, providerFiber);
          push(valueCursor, context._currentValue2, providerFiber);
          push(providerCursor, providerFiber, providerFiber);
          context._currentValue2 = providerFiber.pendingProps.value;
          context._changedBits2 = providerFiber.stateNode;
          {
            !(context._currentRenderer2 === undefined || context._currentRenderer2 === null || context._currentRenderer2 === rendererSigil) ? warning(false, "Detected multiple renderers concurrently rendering the " + "same context provider. This is currently unsupported.") : void 0;
            context._currentRenderer2 = rendererSigil;
          }
        }
      }

      function popProvider(providerFiber) {
        var changedBits = changedBitsCursor.current;
        var currentValue = valueCursor.current;
        pop(providerCursor, providerFiber);
        pop(valueCursor, providerFiber);
        pop(changedBitsCursor, providerFiber);
        var context = providerFiber.type._context;

        if (isPrimaryRenderer) {
          context._currentValue = currentValue;
          context._changedBits = changedBits;
        } else {
          context._currentValue2 = currentValue;
          context._changedBits2 = changedBits;
        }
      }

      function getContextCurrentValue(context) {
        return isPrimaryRenderer ? context._currentValue : context._currentValue2;
      }

      function getContextChangedBits(context) {
        return isPrimaryRenderer ? context._changedBits : context._changedBits2;
      }

      var NO_CONTEXT = {};
      var contextStackCursor$1 = createCursor(NO_CONTEXT);
      var contextFiberStackCursor = createCursor(NO_CONTEXT);
      var rootInstanceStackCursor = createCursor(NO_CONTEXT);

      function requiredContext(c) {
        invariant(c !== NO_CONTEXT, "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 commitTime = 0;

      function getCommitTime() {
        return commitTime;
      }

      function recordCommitTime() {
        if (!enableProfilerTimer) {
          return;
        }

        commitTime = now();
      }

      var fiberStack$1 = void 0;
      {
        fiberStack$1 = [];
      }
      var timerPausedAt = 0;
      var totalElapsedPauseTime = 0;

      function checkActualRenderTimeStackEmpty() {
        if (!enableProfilerTimer) {
          return;
        }

        {
          !(fiberStack$1.length === 0) ? warning(false, "Expected an empty stack. Something was not reset properly.") : void 0;
        }
      }

      function markActualRenderTimeStarted(fiber) {
        if (!enableProfilerTimer) {
          return;
        }

        {
          fiberStack$1.push(fiber);
        }
        fiber.actualDuration = now() - fiber.actualDuration - totalElapsedPauseTime;
        fiber.actualStartTime = now();
      }

      function pauseActualRenderTimerIfRunning() {
        if (!enableProfilerTimer) {
          return;
        }

        if (timerPausedAt === 0) {
          timerPausedAt = now();
        }
      }

      function recordElapsedActualRenderTime(fiber) {
        if (!enableProfilerTimer) {
          return;
        }

        {
          !(fiber === fiberStack$1.pop()) ? warning(false, "Unexpected Fiber (%s) popped.", getComponentName(fiber)) : void 0;
        }
        fiber.actualDuration = now() - totalElapsedPauseTime - fiber.actualDuration;
      }

      function resetActualRenderTimer() {
        if (!enableProfilerTimer) {
          return;
        }

        totalElapsedPauseTime = 0;
      }

      function resumeActualRenderTimerIfPaused() {
        if (!enableProfilerTimer) {
          return;
        }

        if (timerPausedAt > 0) {
          totalElapsedPauseTime += now() - timerPausedAt;
          timerPausedAt = 0;
        }
      }

      var baseStartTime = -1;

      function recordElapsedBaseRenderTimeIfRunning(fiber) {
        if (!enableProfilerTimer) {
          return;
        }

        if (baseStartTime !== -1) {
          fiber.selfBaseTime = now() - baseStartTime;
        }
      }

      function startBaseRenderTimer() {
        if (!enableProfilerTimer) {
          return;
        }

        {
          if (baseStartTime !== -1) {
            warning(false, "Cannot start base timer that is already running. " + "This error is likely caused by a bug in React. " + "Please file an issue.");
          }
        }
        baseStartTime = now();
      }

      function stopBaseRenderTimerIfRunning() {
        if (!enableProfilerTimer) {
          return;
        }

        baseStartTime = -1;
      }

      var hasOwnProperty = Object.prototype.hasOwnProperty;

      function is(x, y) {
        if (x === y) {
          return x !== 0 || y !== 0 || 1 / x === 1 / y;
        } else {
          return x !== x && y !== y;
        }
      }

      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 fakeInternalInstance = {};
      var isArray = Array.isArray;
      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;
      {
        didWarnAboutStateAssignmentForComponent = new Set();
        didWarnAboutUninitializedState = new Set();
        didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate = new Set();
        didWarnAboutLegacyLifecyclesAndDerivedState = new Set();
        didWarnAboutUndefinedDerivedState = 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);
            warning(false, "%s(...): Expected the last optional `callback` argument to be a " + "function. Instead received: %s.", callerName, callback);
          }
        };

        warnOnUndefinedDerivedState = function warnOnUndefinedDerivedState(workInProgress, partialState) {
          if (partialState === undefined) {
            var componentName = getComponentName(workInProgress) || "Component";

            if (!didWarnAboutUndefinedDerivedState.has(componentName)) {
              didWarnAboutUndefinedDerivedState.add(componentName);
              warning(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() {
            invariant(false, "_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, getDerivedStateFromProps, nextProps) {
        var prevState = workInProgress.memoizedState;
        {
          if (debugRenderPhaseSideEffects || debugRenderPhaseSideEffectsForStrictMode && workInProgress.mode & StrictMode) {
            getDerivedStateFromProps(nextProps, prevState);
          }
        }
        var partialState = getDerivedStateFromProps(nextProps, prevState);
        {
          warnOnUndefinedDerivedState(workInProgress, partialState);
        }
        var memoizedState = partialState === null || partialState === undefined ? prevState : _extends({}, prevState, partialState);
        workInProgress.memoizedState = memoizedState;
        var updateQueue = workInProgress.updateQueue;

        if (updateQueue !== null && updateQueue.expirationTime === NoWork) {
          updateQueue.baseState = memoizedState;
        }
      }

      var classComponentUpdater = {
        isMounted: isMounted,
        enqueueSetState: function enqueueSetState(inst, payload, callback) {
          var fiber = get$1(inst);
          var currentTime = recalculateCurrentTime();
          var expirationTime = computeExpirationForFiber(currentTime, fiber);
          var update = createUpdate(expirationTime);
          update.payload = payload;

          if (callback !== undefined && callback !== null) {
            {
              warnOnInvalidCallback(callback, "setState");
            }
            update.callback = callback;
          }

          enqueueUpdate(fiber, update, expirationTime);
          scheduleWork(fiber, expirationTime);
        },
        enqueueReplaceState: function enqueueReplaceState(inst, payload, callback) {
          var fiber = get$1(inst);
          var currentTime = recalculateCurrentTime();
          var expirationTime = computeExpirationForFiber(currentTime, fiber);
          var update = createUpdate(expirationTime);
          update.tag = ReplaceState;
          update.payload = payload;

          if (callback !== undefined && callback !== null) {
            {
              warnOnInvalidCallback(callback, "replaceState");
            }
            update.callback = callback;
          }

          enqueueUpdate(fiber, update, expirationTime);
          scheduleWork(fiber, expirationTime);
        },
        enqueueForceUpdate: function enqueueForceUpdate(inst, callback) {
          var fiber = get$1(inst);
          var currentTime = recalculateCurrentTime();
          var expirationTime = computeExpirationForFiber(currentTime, fiber);
          var update = createUpdate(expirationTime);
          update.tag = ForceUpdate;

          if (callback !== undefined && callback !== null) {
            {
              warnOnInvalidCallback(callback, "forceUpdate");
            }
            update.callback = callback;
          }

          enqueueUpdate(fiber, update, expirationTime);
          scheduleWork(fiber, expirationTime);
        }
      };

      function checkShouldComponentUpdate(workInProgress, oldProps, newProps, oldState, newState, newContext) {
        var instance = workInProgress.stateNode;
        var ctor = workInProgress.type;

        if (typeof instance.shouldComponentUpdate === "function") {
          startPhaseTimer(workInProgress, "shouldComponentUpdate");
          var shouldUpdate = instance.shouldComponentUpdate(newProps, newState, newContext);
          stopPhaseTimer();
          {
            !(shouldUpdate !== undefined) ? warning(false, "%s.shouldComponentUpdate(): Returned undefined instead of a " + "boolean value. Make sure to return true or false.", getComponentName(workInProgress) || "Component") : void 0;
          }
          return shouldUpdate;
        }

        if (ctor.prototype && ctor.prototype.isPureReactComponent) {
          return !shallowEqual(oldProps, newProps) || !shallowEqual(oldState, newState);
        }

        return true;
      }

      function checkClassInstance(workInProgress) {
        var instance = workInProgress.stateNode;
        var type = workInProgress.type;
        {
          var name = getComponentName(workInProgress) || "Component";
          var renderPresent = instance.render;

          if (!renderPresent) {
            if (type.prototype && typeof type.prototype.render === "function") {
              warning(false, "%s(...): No `render` method found on the returned component " + "instance: did you accidentally return an object from the constructor?", name);
            } else {
              warning(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 ? warning(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 ? warning(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 ? warning(false, "propTypes was defined as an instance property on %s. Use a static " + "property to define propTypes instead.", name) : void 0;
          var noInstanceContextTypes = !instance.contextTypes;
          !noInstanceContextTypes ? warning(false, "contextTypes was defined as an instance property on %s. Use a static " + "property to define contextTypes instead.", name) : void 0;
          var noComponentShouldUpdate = typeof instance.componentShouldUpdate !== "function";
          !noComponentShouldUpdate ? warning(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 (type.prototype && type.prototype.isPureReactComponent && typeof instance.shouldComponentUpdate !== "undefined") {
            warning(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(workInProgress) || "A pure component");
          }

          var noComponentDidUnmount = typeof instance.componentDidUnmount !== "function";
          !noComponentDidUnmount ? warning(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 ? warning(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 ? warning(false, "%s has a method called " + "componentWillRecieveProps(). Did you mean componentWillReceiveProps()?", name) : void 0;
          var noUnsafeComponentWillRecieveProps = typeof instance.UNSAFE_componentWillRecieveProps !== "function";
          !noUnsafeComponentWillRecieveProps ? warning(false, "%s has a method called " + "UNSAFE_componentWillRecieveProps(). Did you mean UNSAFE_componentWillReceiveProps()?", name) : void 0;
          var hasMutatedProps = instance.props !== workInProgress.pendingProps;
          !(instance.props === undefined || !hasMutatedProps) ? warning(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 ? warning(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(type)) {
            didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate.add(type);
            warning(false, "%s: getSnapshotBeforeUpdate() should be used with componentDidUpdate(). " + "This component defines getSnapshotBeforeUpdate() only.", getComponentName(workInProgress));
          }

          var noInstanceGetDerivedStateFromProps = typeof instance.getDerivedStateFromProps !== "function";
          !noInstanceGetDerivedStateFromProps ? warning(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.getDerivedStateFromCatch !== "function";
          !noInstanceGetDerivedStateFromCatch ? warning(false, "%s: getDerivedStateFromCatch() is defined as an instance method " + "and will be ignored. Instead, declare it as a static method.", name) : void 0;
          var noStaticGetSnapshotBeforeUpdate = typeof type.getSnapshotBeforeUpdate !== "function";
          !noStaticGetSnapshotBeforeUpdate ? warning(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(_state))) {
            warning(false, "%s.state: must be set to an object or null", name);
          }

          if (typeof instance.getChildContext === "function") {
            !(typeof type.childContextTypes === "object") ? warning(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, props, renderExpirationTime) {
        var ctor = workInProgress.type;
        var unmaskedContext = getUnmaskedContext(workInProgress);
        var needsContext = isContextConsumer(workInProgress);
        var context = needsContext ? getMaskedContext(workInProgress, unmaskedContext) : emptyObject;
        {
          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(workInProgress) || "Component";

            if (!didWarnAboutUninitializedState.has(componentName)) {
              didWarnAboutUninitializedState.add(componentName);
              warning(false, "%s: Did not properly initialize state during construction. " + "Expected state to be an object, but it was %s.", componentName, instance.state === null ? "null" : "undefined");
            }
          }

          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(workInProgress) || "Component";

              var newApiName = typeof ctor.getDerivedStateFromProps === "function" ? "getDerivedStateFromProps()" : "getSnapshotBeforeUpdate()";

              if (!didWarnAboutLegacyLifecyclesAndDerivedState.has(_componentName)) {
                didWarnAboutLegacyLifecyclesAndDerivedState.add(_componentName);
                warning(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 (needsContext) {
          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) {
          {
            warning(false, "%s.componentWillMount(): Assigning directly to this.state is " + "deprecated (except inside a component's " + "constructor). Use setState instead.", getComponentName(workInProgress) || "Component");
          }
          classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
        }
      }

      function callComponentWillReceiveProps(workInProgress, instance, newProps, newContext) {
        var oldState = instance.state;
        startPhaseTimer(workInProgress, "componentWillReceiveProps");

        if (typeof instance.componentWillReceiveProps === "function") {
          instance.componentWillReceiveProps(newProps, newContext);
        }

        if (typeof instance.UNSAFE_componentWillReceiveProps === "function") {
          instance.UNSAFE_componentWillReceiveProps(newProps, newContext);
        }

        stopPhaseTimer();

        if (instance.state !== oldState) {
          {
            var componentName = getComponentName(workInProgress) || "Component";

            if (!didWarnAboutStateAssignmentForComponent.has(componentName)) {
              didWarnAboutStateAssignmentForComponent.add(componentName);
              warning(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, renderExpirationTime) {
        var ctor = workInProgress.type;
        {
          checkClassInstance(workInProgress);
        }
        var instance = workInProgress.stateNode;
        var props = workInProgress.pendingProps;
        var unmaskedContext = getUnmaskedContext(workInProgress);
        instance.props = props;
        instance.state = workInProgress.memoizedState;
        instance.refs = emptyObject;
        instance.context = getMaskedContext(workInProgress, unmaskedContext);
        {
          if (workInProgress.mode & StrictMode) {
            ReactStrictModeWarnings.recordUnsafeLifecycleWarnings(workInProgress, instance);
            ReactStrictModeWarnings.recordLegacyContextWarning(workInProgress, instance);
          }

          if (warnAboutDeprecatedLifecycles) {
            ReactStrictModeWarnings.recordDeprecationWarnings(workInProgress, instance);
          }
        }
        var updateQueue = workInProgress.updateQueue;

        if (updateQueue !== null) {
          processUpdateQueue(workInProgress, updateQueue, props, instance, renderExpirationTime);
          instance.state = workInProgress.memoizedState;
        }

        var getDerivedStateFromProps = workInProgress.type.getDerivedStateFromProps;

        if (typeof getDerivedStateFromProps === "function") {
          applyDerivedStateFromProps(workInProgress, getDerivedStateFromProps, props);
          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, props, instance, renderExpirationTime);
            instance.state = workInProgress.memoizedState;
          }
        }

        if (typeof instance.componentDidMount === "function") {
          workInProgress.effectTag |= Update;
        }
      }

      function resumeMountClassInstance(workInProgress, renderExpirationTime) {
        var ctor = workInProgress.type;
        var instance = workInProgress.stateNode;
        var oldProps = workInProgress.memoizedProps;
        var newProps = workInProgress.pendingProps;
        instance.props = oldProps;
        var oldContext = instance.context;
        var newUnmaskedContext = getUnmaskedContext(workInProgress);
        var newContext = getMaskedContext(workInProgress, newUnmaskedContext);
        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 !== newContext) {
            callComponentWillReceiveProps(workInProgress, instance, newProps, newContext);
          }
        }

        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, getDerivedStateFromProps, newProps);
          newState = workInProgress.memoizedState;
        }

        var shouldUpdate = checkHasForceUpdateAfterProcessing() || checkShouldComponentUpdate(workInProgress, oldProps, newProps, oldState, newState, newContext);

        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 = newContext;
        return shouldUpdate;
      }

      function updateClassInstance(current, workInProgress, renderExpirationTime) {
        var ctor = workInProgress.type;
        var instance = workInProgress.stateNode;
        var oldProps = workInProgress.memoizedProps;
        var newProps = workInProgress.pendingProps;
        instance.props = oldProps;
        var oldContext = instance.context;
        var newUnmaskedContext = getUnmaskedContext(workInProgress);
        var newContext = getMaskedContext(workInProgress, newUnmaskedContext);
        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 !== newContext) {
            callComponentWillReceiveProps(workInProgress, instance, newProps, newContext);
          }
        }

        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, getDerivedStateFromProps, newProps);
          newState = workInProgress.memoizedState;
        }

        var shouldUpdate = checkHasForceUpdateAfterProcessing() || checkShouldComponentUpdate(workInProgress, oldProps, newProps, oldState, newState, newContext);

        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, newContext);
            }

            if (typeof instance.UNSAFE_componentWillUpdate === "function") {
              instance.UNSAFE_componentWillUpdate(newProps, newState, newContext);
            }

            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 = newContext;
        return shouldUpdate;
      }

      var getCurrentFiberStackAddendum$2 = ReactDebugCurrentFiber.getCurrentFiberStackAddendum;
      var didWarnAboutMaps = void 0;
      var didWarnAboutStringRefInStrictMode = void 0;
      var ownerHasKeyUseWarning = void 0;
      var ownerHasFunctionTypeWarning = void 0;

      var warnForMissingKey = function warnForMissingKey(child) {};

      {
        didWarnAboutMaps = false;
        didWarnAboutStringRefInStrictMode = {};
        ownerHasKeyUseWarning = {};
        ownerHasFunctionTypeWarning = {};

        warnForMissingKey = function warnForMissingKey(child) {
          if (child === null || typeof child !== "object") {
            return;
          }

          if (!child._store || child._store.validated || child.key != null) {
            return;
          }

          invariant(typeof child._store === "object", "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 an array or iterator should have a unique " + '"key" prop. See https://fb.me/react-warning-keys for ' + "more information." + (getCurrentFiberStackAddendum$2() || "");

          if (ownerHasKeyUseWarning[currentComponentErrorInfo]) {
            return;
          }

          ownerHasKeyUseWarning[currentComponentErrorInfo] = true;
          warning(false, "Each child in an array or iterator should have a unique " + '"key" prop. See https://fb.me/react-warning-keys for ' + "more information.%s", getCurrentFiberStackAddendum$2());
        };
      }
      var isArray$1 = Array.isArray;

      function coerceRef(returnFiber, current, element) {
        var mixedRef = element.ref;

        if (mixedRef !== null && typeof mixedRef !== "function" && typeof mixedRef !== "object") {
          {
            if (returnFiber.mode & StrictMode) {
              var componentName = getComponentName(returnFiber) || "Component";

              if (!didWarnAboutStringRefInStrictMode[componentName]) {
                warning(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 createRef() instead." + "\n%s" + "\n\nLearn more about using refs safely here:" + "\nhttps://fb.me/react-strict-mode-string-ref", mixedRef, getStackAddendumByWorkInProgressFiber(returnFiber));
                didWarnAboutStringRefInStrictMode[componentName] = true;
              }
            }
          }

          if (element._owner) {
            var owner = element._owner;
            var inst = void 0;

            if (owner) {
              var ownerFiber = owner;
              invariant(ownerFiber.tag === ClassComponent, "Stateless function components cannot have refs.");
              inst = ownerFiber.stateNode;
            }

            invariant(inst, "Missing owner for string ref %s. This error is likely caused by a " + "bug in React. Please file an issue.", mixedRef);
            var stringRef = "" + mixedRef;

            if (current !== null && current.ref !== null && typeof current.ref === "function" && current.ref._stringRef === stringRef) {
              return current.ref;
            }

            var ref = function ref(value) {
              var refs = inst.refs === emptyObject ? inst.refs = {} : inst.refs;

              if (value === null) {
                delete refs[stringRef];
              } else {
                refs[stringRef] = value;
              }
            };

            ref._stringRef = stringRef;
            return ref;
          } else {
            invariant(typeof mixedRef === "string", "Expected ref to be a function or a string.");
            invariant(element._owner, "Element ref was specified as a string (%s) but no owner was set. This could happen for one of" + " the following reasons:\n" + "1. You may be adding a ref to a functional component\n" + "2. You may be adding a ref to a component that was not created inside a component's render method\n" + "3. You have multiple copies of React loaded\n" + "See https://fb.me/react-refs-must-have-owner for more information.", mixedRef);
          }
        }

        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." + (getCurrentFiberStackAddendum$2() || "");
          }
          invariant(false, "Objects are not valid as a React child (found: %s).%s", 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." + (getCurrentFiberStackAddendum$2() || "");

        if (ownerHasFunctionTypeWarning[currentComponentErrorInfo]) {
          return;
        }

        ownerHasFunctionTypeWarning[currentComponentErrorInfo] = true;
        warning(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.%s", getCurrentFiberStackAddendum$2() || "");
      }

      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 = newFiber.alternate;

          if (current !== null) {
            var oldIndex = current.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, textContent, expirationTime) {
          if (current === null || current.tag !== HostText) {
            var created = createFiberFromText(textContent, returnFiber.mode, expirationTime);
            created.return = returnFiber;
            return created;
          } else {
            var existing = useFiber(current, textContent, expirationTime);
            existing.return = returnFiber;
            return existing;
          }
        }

        function updateElement(returnFiber, current, element, expirationTime) {
          if (current !== null && current.type === element.type) {
            var existing = useFiber(current, element.props, expirationTime);
            existing.ref = coerceRef(returnFiber, current, 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, element);
            created.return = returnFiber;
            return created;
          }
        }

        function updatePortal(returnFiber, current, portal, expirationTime) {
          if (current === null || current.tag !== HostPortal || current.stateNode.containerInfo !== portal.containerInfo || current.stateNode.implementation !== portal.implementation) {
            var created = createFiberFromPortal(portal, returnFiber.mode, expirationTime);
            created.return = returnFiber;
            return created;
          } else {
            var existing = useFiber(current, portal.children || [], expirationTime);
            existing.return = returnFiber;
            return existing;
          }
        }

        function updateFragment(returnFiber, current, fragment, expirationTime, key) {
          if (current === null || current.tag !== Fragment) {
            var created = createFiberFromFragment(fragment, returnFiber.mode, expirationTime, key);
            created.return = returnFiber;
            return created;
          } else {
            var existing = useFiber(current, 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$1(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$1(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$1(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(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.%s", key, getCurrentFiberStackAddendum$2());
                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) {
                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) {
              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);
          invariant(typeof iteratorFn === "function", "An object is not an iterable. This error is likely caused by a bug in " + "React. Please file an issue.");
          {
            if (newChildrenIterable.entries === iteratorFn) {
              !didWarnAboutMaps ? warning(false, "Using Maps as children is unsupported and will likely yield " + "unexpected results. Convert it to a sequence/iterable of keyed " + "ReactElements instead.%s", getCurrentFiberStackAddendum$2()) : 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);
          invariant(newChildren != null, "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) {
                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.type === element.type) {
                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$1(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 FunctionalComponent:
                {
                  var Component = returnFiber.type;
                  invariant(false, "%s(...): Nothing was returned from render. This usually means a " + "return statement is missing. Or, to render nothing, " + "return null.", Component.displayName || Component.name || "Component");
                }
            }
          }

          return deleteRemainingChildren(returnFiber, currentFirstChild);
        }

        return reconcileChildFibers;
      }

      var reconcileChildFibers = ChildReconciler(true);
      var mountChildFibers = ChildReconciler(false);

      function cloneChildFibers(current, workInProgress) {
        invariant(current === null || workInProgress.child === current.child, "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;
      }

      var hydrationParentFiber = null;
      var nextHydratableInstance = null;
      var isHydrating = false;

      function enterHydrationState(fiber) {
        if (!supportsHydration) {
          return false;
        }

        var parentInstance = fiber.stateNode.containerInfo;
        nextHydratableInstance = getFirstHydratableChild(parentInstance);
        hydrationParentFiber = 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;
                }

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

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

          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) {
          invariant(false, "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) {
          invariant(false, "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 popToNextHostParent(fiber) {
        var parent = fiber.return;

        while (parent !== null && parent.tag !== HostComponent && parent.tag !== HostRoot) {
          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 getCurrentFiberStackAddendum$1 = ReactDebugCurrentFiber.getCurrentFiberStackAddendum;
      var didWarnAboutBadClass = void 0;
      var didWarnAboutGetDerivedStateOnFunctionalComponent = void 0;
      var didWarnAboutStatelessRefs = void 0;
      {
        didWarnAboutBadClass = {};
        didWarnAboutGetDerivedStateOnFunctionalComponent = {};
        didWarnAboutStatelessRefs = {};
      }

      function reconcileChildren(current, workInProgress, nextChildren) {
        reconcileChildrenAtExpirationTime(current, workInProgress, nextChildren, workInProgress.expirationTime);
      }

      function reconcileChildrenAtExpirationTime(current, workInProgress, nextChildren, renderExpirationTime) {
        if (current === null) {
          workInProgress.child = mountChildFibers(workInProgress, null, nextChildren, renderExpirationTime);
        } else {
          workInProgress.child = reconcileChildFibers(workInProgress, current.child, nextChildren, renderExpirationTime);
        }
      }

      function updateForwardRef(current, workInProgress) {
        var render = workInProgress.type.render;
        var nextProps = workInProgress.pendingProps;
        var ref = workInProgress.ref;

        if (hasContextChanged()) {} else if (workInProgress.memoizedProps === nextProps) {
          var currentRef = current !== null ? current.ref : null;

          if (ref === currentRef) {
            return bailoutOnAlreadyFinishedWork(current, workInProgress);
          }
        }

        var nextChildren = void 0;
        {
          ReactCurrentOwner.current = workInProgress;
          ReactDebugCurrentFiber.setCurrentPhase("render");
          nextChildren = render(nextProps, ref);
          ReactDebugCurrentFiber.setCurrentPhase(null);
        }
        reconcileChildren(current, workInProgress, nextChildren);
        memoizeProps(workInProgress, nextProps);
        return workInProgress.child;
      }

      function updateFragment(current, workInProgress) {
        var nextChildren = workInProgress.pendingProps;

        if (hasContextChanged()) {} else if (workInProgress.memoizedProps === nextChildren) {
          return bailoutOnAlreadyFinishedWork(current, workInProgress);
        }

        reconcileChildren(current, workInProgress, nextChildren);
        memoizeProps(workInProgress, nextChildren);
        return workInProgress.child;
      }

      function updateMode(current, workInProgress) {
        var nextChildren = workInProgress.pendingProps.children;

        if (hasContextChanged()) {} else if (nextChildren === null || workInProgress.memoizedProps === nextChildren) {
          return bailoutOnAlreadyFinishedWork(current, workInProgress);
        }

        reconcileChildren(current, workInProgress, nextChildren);
        memoizeProps(workInProgress, nextChildren);
        return workInProgress.child;
      }

      function updateProfiler(current, workInProgress) {
        var nextProps = workInProgress.pendingProps;

        if (enableProfilerTimer) {
          workInProgress.effectTag |= Update;
        }

        if (workInProgress.memoizedProps === nextProps) {
          return bailoutOnAlreadyFinishedWork(current, workInProgress);
        }

        var nextChildren = nextProps.children;
        reconcileChildren(current, workInProgress, nextChildren);
        memoizeProps(workInProgress, nextProps);
        return workInProgress.child;
      }

      function markRef(current, workInProgress) {
        var ref = workInProgress.ref;

        if (current === null && ref !== null || current !== null && current.ref !== ref) {
          workInProgress.effectTag |= Ref;
        }
      }

      function updateFunctionalComponent(current, workInProgress) {
        var fn = workInProgress.type;
        var nextProps = workInProgress.pendingProps;

        if (hasContextChanged()) {} else {
          if (workInProgress.memoizedProps === nextProps) {
            return bailoutOnAlreadyFinishedWork(current, workInProgress);
          }
        }

        var unmaskedContext = getUnmaskedContext(workInProgress);
        var context = getMaskedContext(workInProgress, unmaskedContext);
        var nextChildren = void 0;
        {
          ReactCurrentOwner.current = workInProgress;
          ReactDebugCurrentFiber.setCurrentPhase("render");
          nextChildren = fn(nextProps, context);
          ReactDebugCurrentFiber.setCurrentPhase(null);
        }
        workInProgress.effectTag |= PerformedWork;
        reconcileChildren(current, workInProgress, nextChildren);
        memoizeProps(workInProgress, nextProps);
        return workInProgress.child;
      }

      function updateClassComponent(current, workInProgress, renderExpirationTime) {
        var hasContext = pushContextProvider(workInProgress);
        var shouldUpdate = void 0;

        if (current === null) {
          if (workInProgress.stateNode === null) {
            constructClassInstance(workInProgress, workInProgress.pendingProps, renderExpirationTime);
            mountClassInstance(workInProgress, renderExpirationTime);
            shouldUpdate = true;
          } else {
            shouldUpdate = resumeMountClassInstance(workInProgress, renderExpirationTime);
          }
        } else {
          shouldUpdate = updateClassInstance(current, workInProgress, renderExpirationTime);
        }

        return finishClassComponent(current, workInProgress, shouldUpdate, hasContext, renderExpirationTime);
      }

      function finishClassComponent(current, workInProgress, shouldUpdate, hasContext, renderExpirationTime) {
        markRef(current, workInProgress);
        var didCaptureError = (workInProgress.effectTag & DidCapture) !== NoEffect;

        if (!shouldUpdate && !didCaptureError) {
          if (hasContext) {
            invalidateContextProvider(workInProgress, false);
          }

          return bailoutOnAlreadyFinishedWork(current, workInProgress);
        }

        var ctor = workInProgress.type;
        var instance = workInProgress.stateNode;
        ReactCurrentOwner.current = workInProgress;
        var nextChildren = void 0;

        if (didCaptureError && (!enableGetDerivedStateFromCatch || typeof ctor.getDerivedStateFromCatch !== "function")) {
          nextChildren = null;

          if (enableProfilerTimer) {
            stopBaseRenderTimerIfRunning();
          }
        } else {
          {
            ReactDebugCurrentFiber.setCurrentPhase("render");
            nextChildren = instance.render();

            if (debugRenderPhaseSideEffects || debugRenderPhaseSideEffectsForStrictMode && workInProgress.mode & StrictMode) {
              instance.render();
            }

            ReactDebugCurrentFiber.setCurrentPhase(null);
          }
        }

        workInProgress.effectTag |= PerformedWork;

        if (didCaptureError) {
          reconcileChildrenAtExpirationTime(current, workInProgress, null, renderExpirationTime);
          workInProgress.child = null;
        }

        reconcileChildrenAtExpirationTime(current, workInProgress, nextChildren, renderExpirationTime);
        memoizeState(workInProgress, instance.state);
        memoizeProps(workInProgress, instance.props);

        if (hasContext) {
          invalidateContextProvider(workInProgress, 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, workInProgress, renderExpirationTime) {
        pushHostRootContext(workInProgress);
        var updateQueue = workInProgress.updateQueue;

        if (updateQueue !== null) {
          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, workInProgress);
          }

          var root = workInProgress.stateNode;

          if ((current === null || current.child === null) && root.hydrate && enterHydrationState(workInProgress)) {
            workInProgress.effectTag |= Placement;
            workInProgress.child = mountChildFibers(workInProgress, null, nextChildren, renderExpirationTime);
          } else {
            resetHydrationState();
            reconcileChildren(current, workInProgress, nextChildren);
          }

          return workInProgress.child;
        }

        resetHydrationState();
        return bailoutOnAlreadyFinishedWork(current, workInProgress);
      }

      function updateHostComponent(current, workInProgress, renderExpirationTime) {
        pushHostContext(workInProgress);

        if (current === null) {
          tryToClaimNextHydratableInstance(workInProgress);
        }

        var type = workInProgress.type;
        var memoizedProps = workInProgress.memoizedProps;
        var nextProps = workInProgress.pendingProps;
        var prevProps = current !== null ? current.memoizedProps : null;

        if (hasContextChanged()) {} else if (memoizedProps === nextProps) {
          var isHidden = workInProgress.mode & AsyncMode && shouldDeprioritizeSubtree(type, nextProps);

          if (isHidden) {
            workInProgress.expirationTime = Never;
          }

          if (!isHidden || renderExpirationTime !== Never) {
            return bailoutOnAlreadyFinishedWork(current, workInProgress);
          }
        }

        var nextChildren = nextProps.children;
        var isDirectTextChild = shouldSetTextContent(type, nextProps);

        if (isDirectTextChild) {
          nextChildren = null;
        } else if (prevProps && shouldSetTextContent(type, prevProps)) {
          workInProgress.effectTag |= ContentReset;
        }

        markRef(current, workInProgress);

        if (renderExpirationTime !== Never && workInProgress.mode & AsyncMode && shouldDeprioritizeSubtree(type, nextProps)) {
          workInProgress.expirationTime = Never;
          workInProgress.memoizedProps = nextProps;
          return null;
        }

        reconcileChildren(current, workInProgress, nextChildren);
        memoizeProps(workInProgress, nextProps);
        return workInProgress.child;
      }

      function updateHostText(current, workInProgress) {
        if (current === null) {
          tryToClaimNextHydratableInstance(workInProgress);
        }

        var nextProps = workInProgress.pendingProps;
        memoizeProps(workInProgress, nextProps);
        return null;
      }

      function mountIndeterminateComponent(current, workInProgress, renderExpirationTime) {
        invariant(current === null, "An indeterminate component should never have mounted. This error is " + "likely caused by a bug in React. Please file an issue.");
        var fn = workInProgress.type;
        var props = workInProgress.pendingProps;
        var unmaskedContext = getUnmaskedContext(workInProgress);
        var context = getMaskedContext(workInProgress, unmaskedContext);
        var value = void 0;
        {
          if (fn.prototype && typeof fn.prototype.render === "function") {
            var componentName = getComponentName(workInProgress) || "Unknown";

            if (!didWarnAboutBadClass[componentName]) {
              warning(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.current = workInProgress;
          value = fn(props, context);
        }
        workInProgress.effectTag |= PerformedWork;

        if (typeof value === "object" && value !== null && typeof value.render === "function" && value.$$typeof === undefined) {
          var Component = workInProgress.type;
          workInProgress.tag = ClassComponent;
          workInProgress.memoizedState = value.state !== null && value.state !== undefined ? value.state : null;
          var getDerivedStateFromProps = Component.getDerivedStateFromProps;

          if (typeof getDerivedStateFromProps === "function") {
            applyDerivedStateFromProps(workInProgress, getDerivedStateFromProps, props);
          }

          var hasContext = pushContextProvider(workInProgress);
          adoptClassInstance(workInProgress, value);
          mountClassInstance(workInProgress, renderExpirationTime);
          return finishClassComponent(current, workInProgress, true, hasContext, renderExpirationTime);
        } else {
          workInProgress.tag = FunctionalComponent;
          {
            var _Component = workInProgress.type;

            if (_Component) {
              !!_Component.childContextTypes ? warning(false, "%s(...): childContextTypes cannot be defined on a functional component.", _Component.displayName || _Component.name || "Component") : void 0;
            }

            if (workInProgress.ref !== null) {
              var info = "";
              var ownerName = ReactDebugCurrentFiber.getCurrentFiberOwnerName();

              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 (!didWarnAboutStatelessRefs[warningKey]) {
                didWarnAboutStatelessRefs[warningKey] = true;
                warning(false, "Stateless function components cannot be given refs. " + "Attempts to access this ref will fail.%s%s", info, ReactDebugCurrentFiber.getCurrentFiberStackAddendum());
              }
            }

            if (typeof fn.getDerivedStateFromProps === "function") {
              var _componentName = getComponentName(workInProgress) || "Unknown";

              if (!didWarnAboutGetDerivedStateOnFunctionalComponent[_componentName]) {
                warning(false, "%s: Stateless functional components do not support getDerivedStateFromProps.", _componentName);
                didWarnAboutGetDerivedStateOnFunctionalComponent[_componentName] = true;
              }
            }
          }
          reconcileChildren(current, workInProgress, value);
          memoizeProps(workInProgress, props);
          return workInProgress.child;
        }
      }

      function updateTimeoutComponent(current, workInProgress, renderExpirationTime) {
        if (enableSuspense) {
          var nextProps = workInProgress.pendingProps;
          var prevProps = workInProgress.memoizedProps;
          var prevDidTimeout = workInProgress.memoizedState;
          var alreadyCaptured = (workInProgress.effectTag & DidCapture) === NoEffect;
          var nextDidTimeout = !alreadyCaptured;

          if (hasContextChanged()) {} else if (nextProps === prevProps && nextDidTimeout === prevDidTimeout) {
            return bailoutOnAlreadyFinishedWork(current, workInProgress);
          }

          var render = nextProps.children;
          var nextChildren = render(nextDidTimeout);
          workInProgress.memoizedProps = nextProps;
          workInProgress.memoizedState = nextDidTimeout;
          reconcileChildren(current, workInProgress, nextChildren);
          return workInProgress.child;
        } else {
          return null;
        }
      }

      function updatePortalComponent(current, workInProgress, renderExpirationTime) {
        pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
        var nextChildren = workInProgress.pendingProps;

        if (hasContextChanged()) {} else if (workInProgress.memoizedProps === nextChildren) {
          return bailoutOnAlreadyFinishedWork(current, workInProgress);
        }

        if (current === null) {
          workInProgress.child = reconcileChildFibers(workInProgress, null, nextChildren, renderExpirationTime);
          memoizeProps(workInProgress, nextChildren);
        } else {
          reconcileChildren(current, workInProgress, nextChildren);
          memoizeProps(workInProgress, nextChildren);
        }

        return workInProgress.child;
      }

      function propagateContextChange(workInProgress, context, changedBits, renderExpirationTime) {
        var fiber = workInProgress.child;

        if (fiber !== null) {
          fiber.return = workInProgress;
        }

        while (fiber !== null) {
          var nextFiber = void 0;

          switch (fiber.tag) {
            case ContextConsumer:
              var observedBits = fiber.stateNode | 0;

              if (fiber.type === context && (observedBits & changedBits) !== 0) {
                var node = fiber;

                while (node !== null) {
                  var alternate = node.alternate;

                  if (node.expirationTime === NoWork || node.expirationTime > renderExpirationTime) {
                    node.expirationTime = renderExpirationTime;

                    if (alternate !== null && (alternate.expirationTime === NoWork || alternate.expirationTime > renderExpirationTime)) {
                      alternate.expirationTime = renderExpirationTime;
                    }
                  } else if (alternate !== null && (alternate.expirationTime === NoWork || alternate.expirationTime > renderExpirationTime)) {
                    alternate.expirationTime = renderExpirationTime;
                  } else {
                    break;
                  }

                  node = node.return;
                }

                nextFiber = null;
              } else {
                nextFiber = fiber.child;
              }

              break;

            case ContextProvider:
              nextFiber = fiber.type === workInProgress.type ? null : fiber.child;
              break;

            default:
              nextFiber = fiber.child;
              break;
          }

          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 updateContextProvider(current, workInProgress, renderExpirationTime) {
        var providerType = workInProgress.type;
        var context = providerType._context;
        var newProps = workInProgress.pendingProps;
        var oldProps = workInProgress.memoizedProps;
        var canBailOnProps = true;

        if (hasContextChanged()) {
          canBailOnProps = false;
        } else if (oldProps === newProps) {
          workInProgress.stateNode = 0;
          pushProvider(workInProgress);
          return bailoutOnAlreadyFinishedWork(current, workInProgress);
        }

        var newValue = newProps.value;
        workInProgress.memoizedProps = newProps;
        {
          var providerPropTypes = workInProgress.type.propTypes;

          if (providerPropTypes) {
            checkPropTypes(providerPropTypes, newProps, "prop", "Context.Provider", getCurrentFiberStackAddendum$1);
          }
        }
        var changedBits = void 0;

        if (oldProps === null) {
          changedBits = MAX_SIGNED_31_BIT_INT;
        } else {
          if (oldProps.value === newProps.value) {
            if (oldProps.children === newProps.children && canBailOnProps) {
              workInProgress.stateNode = 0;
              pushProvider(workInProgress);
              return bailoutOnAlreadyFinishedWork(current, workInProgress);
            }

            changedBits = 0;
          } else {
            var oldValue = oldProps.value;

            if (oldValue === newValue && (oldValue !== 0 || 1 / oldValue === 1 / newValue) || oldValue !== oldValue && newValue !== newValue) {
                if (oldProps.children === newProps.children && canBailOnProps) {
                  workInProgress.stateNode = 0;
                  pushProvider(workInProgress);
                  return bailoutOnAlreadyFinishedWork(current, workInProgress);
                }

                changedBits = 0;
              } else {
              changedBits = typeof context._calculateChangedBits === "function" ? context._calculateChangedBits(oldValue, newValue) : MAX_SIGNED_31_BIT_INT;
              {
                !((changedBits & MAX_SIGNED_31_BIT_INT) === changedBits) ? warning(false, "calculateChangedBits: Expected the return value to be a " + "31-bit integer. Instead received: %s", changedBits) : void 0;
              }
              changedBits |= 0;

              if (changedBits === 0) {
                if (oldProps.children === newProps.children && canBailOnProps) {
                  workInProgress.stateNode = 0;
                  pushProvider(workInProgress);
                  return bailoutOnAlreadyFinishedWork(current, workInProgress);
                }
              } else {
                propagateContextChange(workInProgress, context, changedBits, renderExpirationTime);
              }
            }
          }
        }

        workInProgress.stateNode = changedBits;
        pushProvider(workInProgress);
        var newChildren = newProps.children;
        reconcileChildren(current, workInProgress, newChildren);
        return workInProgress.child;
      }

      function updateContextConsumer(current, workInProgress, renderExpirationTime) {
        var context = workInProgress.type;
        var newProps = workInProgress.pendingProps;
        var oldProps = workInProgress.memoizedProps;
        var newValue = getContextCurrentValue(context);
        var changedBits = getContextChangedBits(context);

        if (hasContextChanged()) {} else if (changedBits === 0 && oldProps === newProps) {
          return bailoutOnAlreadyFinishedWork(current, workInProgress);
        }

        workInProgress.memoizedProps = newProps;
        var observedBits = newProps.unstable_observedBits;

        if (observedBits === undefined || observedBits === null) {
          observedBits = MAX_SIGNED_31_BIT_INT;
        }

        workInProgress.stateNode = observedBits;

        if ((changedBits & observedBits) !== 0) {
          propagateContextChange(workInProgress, context, changedBits, renderExpirationTime);
        } else if (oldProps === newProps) {
          return bailoutOnAlreadyFinishedWork(current, workInProgress);
        }

        var render = newProps.children;
        {
          !(typeof render === "function") ? warning(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;
        }
        var newChildren = void 0;
        {
          ReactCurrentOwner.current = workInProgress;
          ReactDebugCurrentFiber.setCurrentPhase("render");
          newChildren = render(newValue);
          ReactDebugCurrentFiber.setCurrentPhase(null);
        }
        workInProgress.effectTag |= PerformedWork;
        reconcileChildren(current, workInProgress, newChildren);
        return workInProgress.child;
      }

      function bailoutOnAlreadyFinishedWork(current, workInProgress) {
        cancelWorkTimer(workInProgress);

        if (enableProfilerTimer) {
          stopBaseRenderTimerIfRunning();
        }

        cloneChildFibers(current, workInProgress);
        return workInProgress.child;
      }

      function bailoutOnLowPriority(current, workInProgress) {
        cancelWorkTimer(workInProgress);

        if (enableProfilerTimer) {
          stopBaseRenderTimerIfRunning();
        }

        switch (workInProgress.tag) {
          case HostRoot:
            pushHostRootContext(workInProgress);
            break;

          case ClassComponent:
            pushContextProvider(workInProgress);
            break;

          case HostPortal:
            pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
            break;

          case ContextProvider:
            pushProvider(workInProgress);
            break;
        }

        return null;
      }

      function memoizeProps(workInProgress, nextProps) {
        workInProgress.memoizedProps = nextProps;
      }

      function memoizeState(workInProgress, nextState) {
        workInProgress.memoizedState = nextState;
      }

      function beginWork(current, workInProgress, renderExpirationTime) {
        if (enableProfilerTimer) {
          if (workInProgress.mode & ProfileMode) {
            markActualRenderTimeStarted(workInProgress);
          }
        }

        if (workInProgress.expirationTime === NoWork || workInProgress.expirationTime > renderExpirationTime) {
          return bailoutOnLowPriority(current, workInProgress);
        }

        switch (workInProgress.tag) {
          case IndeterminateComponent:
            return mountIndeterminateComponent(current, workInProgress, renderExpirationTime);

          case FunctionalComponent:
            return updateFunctionalComponent(current, workInProgress);

          case ClassComponent:
            return updateClassComponent(current, workInProgress, renderExpirationTime);

          case HostRoot:
            return updateHostRoot(current, workInProgress, renderExpirationTime);

          case HostComponent:
            return updateHostComponent(current, workInProgress, renderExpirationTime);

          case HostText:
            return updateHostText(current, workInProgress);

          case TimeoutComponent:
            return updateTimeoutComponent(current, workInProgress, renderExpirationTime);

          case HostPortal:
            return updatePortalComponent(current, workInProgress, renderExpirationTime);

          case ForwardRef:
            return updateForwardRef(current, workInProgress);

          case Fragment:
            return updateFragment(current, workInProgress);

          case Mode:
            return updateMode(current, workInProgress);

          case Profiler:
            return updateProfiler(current, workInProgress);

          case ContextProvider:
            return updateContextProvider(current, workInProgress, renderExpirationTime);

          case ContextConsumer:
            return updateContextConsumer(current, workInProgress, renderExpirationTime);

          default:
            invariant(false, "Unknown unit of work tag. This error is likely caused by a bug in " + "React. Please file an issue.");
        }
      }

      function markUpdate(workInProgress) {
        workInProgress.effectTag |= Update;
      }

      function markRef$1(workInProgress) {
        workInProgress.effectTag |= Ref;
      }

      function appendAllChildren(parent, workInProgress) {
        var node = workInProgress.child;

        while (node !== null) {
          if (node.tag === HostComponent || node.tag === HostText) {
            appendInitialChild(parent, node.stateNode);
          } 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;
        }
      }

      var updateHostContainer = void 0;
      var updateHostComponent$1 = void 0;
      var updateHostText$1 = void 0;

      if (supportsMutation) {
        updateHostContainer = function updateHostContainer(workInProgress) {};

        updateHostComponent$1 = function updateHostComponent$1(current, workInProgress, updatePayload, 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) {
        var appendAllChildrenToContainer = function appendAllChildrenToContainer(containerChildSet, workInProgress) {
          var node = workInProgress.child;

          while (node !== null) {
            if (node.tag === HostComponent || node.tag === HostText) {
              appendChildToContainerChildSet(containerChildSet, node.stateNode);
            } 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) {
          var portalOrRoot = workInProgress.stateNode;
          var childrenUnchanged = workInProgress.firstEffect === null;

          if (childrenUnchanged) {} else {
            var container = portalOrRoot.containerInfo;
            var newChildSet = createContainerChildSet(container);
            appendAllChildrenToContainer(newChildSet, workInProgress);
            portalOrRoot.pendingChildren = newChildSet;
            markUpdate(workInProgress);
            finalizeContainerChildren(container, newChildSet);
          }
        };

        updateHostComponent$1 = function updateHostComponent$1(current, workInProgress, updatePayload, type, oldProps, newProps, rootContainerInstance, currentHostContext) {
          var childrenUnchanged = workInProgress.firstEffect === null;
          var currentInstance = current.stateNode;

          if (childrenUnchanged && updatePayload === null) {
            workInProgress.stateNode = currentInstance;
          } else {
            var recyclableInstance = workInProgress.stateNode;
            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);
            }
          }
        };

        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, updatePayload, type, oldProps, newProps, rootContainerInstance, currentHostContext) {};

        updateHostText$1 = function updateHostText$1(current, workInProgress, oldText, newText) {};
      }

      function completeWork(current, workInProgress, renderExpirationTime) {
        var newProps = workInProgress.pendingProps;

        if (enableProfilerTimer) {
          if (workInProgress.mode & ProfileMode) {
            recordElapsedActualRenderTime(workInProgress);
          }
        }

        switch (workInProgress.tag) {
          case FunctionalComponent:
            return null;

          case ClassComponent:
            {
              popContextProvider(workInProgress);
              return null;
            }

          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);
              return null;
            }

          case HostComponent:
            {
              popHostContext(workInProgress);
              var rootContainerInstance = getRootHostContainer();
              var type = workInProgress.type;

              if (current !== null && workInProgress.stateNode != null) {
                var oldProps = current.memoizedProps;
                var instance = workInProgress.stateNode;
                var currentHostContext = getHostContext();
                var updatePayload = prepareUpdate(instance, type, oldProps, newProps, rootContainerInstance, currentHostContext);
                updateHostComponent$1(current, workInProgress, updatePayload, type, oldProps, newProps, rootContainerInstance, currentHostContext);

                if (current.ref !== workInProgress.ref) {
                  markRef$1(workInProgress);
                }
              } else {
                if (!newProps) {
                  invariant(workInProgress.stateNode !== null, "We must have new props for new mounts. This error is likely " + "caused by a bug in React. Please file an issue.");
                  return null;
                }

                var _currentHostContext = getHostContext();

                var wasHydrated = popHydrationState(workInProgress);

                if (wasHydrated) {
                  if (prepareToHydrateHostInstance(workInProgress, rootContainerInstance, _currentHostContext)) {
                    markUpdate(workInProgress);
                  }
                } else {
                  var _instance = createInstance(type, newProps, rootContainerInstance, _currentHostContext, workInProgress);

                  appendAllChildren(_instance, workInProgress);

                  if (finalizeInitialChildren(_instance, type, newProps, rootContainerInstance, _currentHostContext)) {
                    markUpdate(workInProgress);
                  }

                  workInProgress.stateNode = _instance;
                }

                if (workInProgress.ref !== null) {
                  markRef$1(workInProgress);
                }
              }

              return null;
            }

          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") {
                  invariant(workInProgress.stateNode !== null, "We must have new props for new mounts. This error is likely " + "caused by a bug in React. Please file an issue.");
                  return null;
                }

                var _rootContainerInstance = getRootHostContainer();

                var _currentHostContext2 = getHostContext();

                var _wasHydrated = popHydrationState(workInProgress);

                if (_wasHydrated) {
                  if (prepareToHydrateHostTextInstance(workInProgress)) {
                    markUpdate(workInProgress);
                  }
                } else {
                  workInProgress.stateNode = createTextInstance(newText, _rootContainerInstance, _currentHostContext2, workInProgress);
                }
              }

              return null;
            }

          case ForwardRef:
            return null;

          case TimeoutComponent:
            return null;

          case Fragment:
            return null;

          case Mode:
            return null;

          case Profiler:
            return null;

          case HostPortal:
            popHostContainer(workInProgress);
            updateHostContainer(workInProgress);
            return null;

          case ContextProvider:
            popProvider(workInProgress);
            return null;

          case ContextConsumer:
            return null;

          case IndeterminateComponent:
            invariant(false, "An indeterminate component should have become determinate before " + "completing. This error is likely caused by a bug in React. Please " + "file an issue.");

          default:
            invariant(false, "Unknown unit of work tag. This error is likely caused by a bug in " + "React. Please file an issue.");
        }
      }

      function showErrorDialog(capturedError) {
        var componentStack = capturedError.componentStack,
            error = capturedError.error;
        var errorToHandle = void 0;

        if (error instanceof Error) {
          var message = error.message,
              name = error.name;
          var summary = message ? name + ": " + message : name;
          errorToHandle = error;

          try {
            errorToHandle.message = summary + "\n\nThis error is located at:" + componentStack;
          } catch (e) {}
        } else if (typeof error === "string") {
          errorToHandle = new Error(error + "\n\nThis error is located at:" + componentStack);
        } else {
          errorToHandle = new Error("Unspecified error at:" + componentStack);
        }

        ExceptionsManager.handleException(errorToHandle, false);
        return false;
      }

      function logCapturedError(capturedError) {
        var logError = showErrorDialog(capturedError);

        if (logError === false) {
          return;
        }

        var error = capturedError.error;
        var suppressLogging = error && error.suppressReactErrorLogging;

        if (suppressLogging) {
          return;
        }

        {
          var componentName = capturedError.componentName,
              componentStack = capturedError.componentStack,
              errorBoundaryName = capturedError.errorBoundaryName,
              errorBoundaryFound = capturedError.errorBoundaryFound,
              willRetry = capturedError.willRetry;
          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 invokeGuardedCallback$3 = ReactErrorUtils.invokeGuardedCallback;
      var hasCaughtError$1 = ReactErrorUtils.hasCaughtError;
      var clearCaughtError$1 = ReactErrorUtils.clearCaughtError;
      var didWarnAboutUndefinedSnapshotBeforeUpdate = null;
      {
        didWarnAboutUndefinedSnapshotBeforeUpdate = new Set();
      }

      function logError(boundary, errorInfo) {
        var source = errorInfo.source;
        var stack = errorInfo.stack;

        if (stack === null && source !== null) {
          stack = getStackAddendumByWorkInProgressFiber(source);
        }

        var capturedError = {
          componentName: source !== null ? getComponentName(source) : 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);
          capturedError.errorBoundaryFound = true;
          capturedError.willRetry = true;
        }

        try {
          logCapturedError(capturedError);
        } catch (e) {
          var suppressLogging = e && e.suppressReactErrorLogging;

          if (!suppressLogging) {
            console.error(e);
          }
        }
      }

      var callComponentWillUnmountWithTimer = function callComponentWillUnmountWithTimer(current, instance) {
        startPhaseTimer(current, "componentWillUnmount");
        instance.props = current.memoizedProps;
        instance.state = current.memoizedState;
        instance.componentWillUnmount();
        stopPhaseTimer();
      };

      function safelyCallComponentWillUnmount(current, instance) {
        {
          invokeGuardedCallback$3(null, callComponentWillUnmountWithTimer, null, current, instance);

          if (hasCaughtError$1()) {
            var unmountError = clearCaughtError$1();
            captureCommitPhaseError(current, unmountError);
          }
        }
      }

      function safelyDetachRef(current) {
        var ref = current.ref;

        if (ref !== null) {
          if (typeof ref === "function") {
            {
              invokeGuardedCallback$3(null, ref, null, null);

              if (hasCaughtError$1()) {
                var refError = clearCaughtError$1();
                captureCommitPhaseError(current, refError);
              }
            }
          } else {
            ref.current = null;
          }
        }
      }

      function commitBeforeMutationLifeCycles(current, finishedWork) {
        switch (finishedWork.tag) {
          case ClassComponent:
            {
              if (finishedWork.effectTag & Snapshot) {
                if (current !== null) {
                  var prevProps = current.memoizedProps;
                  var prevState = current.memoizedState;
                  startPhaseTimer(finishedWork, "getSnapshotBeforeUpdate");
                  var instance = finishedWork.stateNode;
                  instance.props = finishedWork.memoizedProps;
                  instance.state = finishedWork.memoizedState;
                  var snapshot = instance.getSnapshotBeforeUpdate(prevProps, prevState);
                  {
                    var didWarnSet = didWarnAboutUndefinedSnapshotBeforeUpdate;

                    if (snapshot === undefined && !didWarnSet.has(finishedWork.type)) {
                      didWarnSet.add(finishedWork.type);
                      warning(false, "%s.getSnapshotBeforeUpdate(): A snapshot value (or null) " + "must be returned. You have returned undefined.", getComponentName(finishedWork));
                    }
                  }
                  instance.__reactInternalSnapshotBeforeUpdate = snapshot;
                  stopPhaseTimer();
                }
              }

              return;
            }

          case HostRoot:
          case HostComponent:
          case HostText:
          case HostPortal:
            return;

          default:
            {
              invariant(false, "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 commitLifeCycles(finishedRoot, current, finishedWork, currentTime, committedExpirationTime) {
        switch (finishedWork.tag) {
          case ClassComponent:
            {
              var instance = finishedWork.stateNode;

              if (finishedWork.effectTag & Update) {
                if (current === null) {
                  startPhaseTimer(finishedWork, "componentDidMount");
                  instance.props = finishedWork.memoizedProps;
                  instance.state = finishedWork.memoizedState;
                  instance.componentDidMount();
                  stopPhaseTimer();
                } else {
                  var prevProps = current.memoizedProps;
                  var prevState = current.memoizedState;
                  startPhaseTimer(finishedWork, "componentDidUpdate");
                  instance.props = finishedWork.memoizedProps;
                  instance.state = finishedWork.memoizedState;
                  instance.componentDidUpdate(prevProps, prevState, instance.__reactInternalSnapshotBeforeUpdate);
                  stopPhaseTimer();
                }
              }

              var updateQueue = finishedWork.updateQueue;

              if (updateQueue !== null) {
                instance.props = finishedWork.memoizedProps;
                instance.state = finishedWork.memoizedState;
                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 === null && finishedWork.effectTag & Update) {
                var type = finishedWork.type;
                var props = finishedWork.memoizedProps;
              }

              return;
            }

          case HostText:
            {
              return;
            }

          case HostPortal:
            {
              return;
            }

          case Profiler:
            {
              return;
            }

          case TimeoutComponent:
            {
              return;
            }

          default:
            {
              invariant(false, "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 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")) {
                warning(false, "Unexpected ref object provided for %s. " + "Use either a ref-setter function or React.createRef().%s", getComponentName(finishedWork), getStackAddendumByWorkInProgressFiber(finishedWork));
              }
            }
            ref.current = instanceToUse;
          }
        }
      }

      function commitDetachRef(current) {
        var currentRef = current.ref;

        if (currentRef !== null) {
          if (typeof currentRef === "function") {
            currentRef(null);
          } else {
            currentRef.current = null;
          }
        }
      }

      function commitUnmount(current) {
        if (typeof onCommitUnmount === "function") {
          onCommitUnmount(current);
        }

        switch (current.tag) {
          case ClassComponent:
            {
              safelyDetachRef(current);
              var instance = current.stateNode;

              if (typeof instance.componentWillUnmount === "function") {
                safelyCallComponentWillUnmount(current, instance);
              }

              return;
            }

          case HostComponent:
            {
              safelyDetachRef(current);
              return;
            }

          case HostPortal:
            {
              if (supportsMutation) {
                unmountHostComponents(current);
              } else if (supportsPersistence) {
                emptyPortalContainer(current);
              }

              return;
            }
        }
      }

      function commitNestedUnmounts(root) {
        var node = root;

        while (true) {
          commitUnmount(node);

          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) {
        current.return = null;
        current.child = null;

        if (current.alternate) {
          current.alternate.child = null;
          current.alternate.return = null;
        }
      }

      function emptyPortalContainer(current) {
        if (!supportsPersistence) {
          return;
        }

        var portal = current.stateNode;
        var containerInfo = portal.containerInfo;
        var emptyChildSet = createContainerChildSet(containerInfo);
        replaceContainerChildren(containerInfo, emptyChildSet);
      }

      function commitContainer(finishedWork) {
        if (!supportsPersistence) {
          return;
        }

        switch (finishedWork.tag) {
          case ClassComponent:
            {
              return;
            }

          case HostComponent:
            {
              return;
            }

          case HostText:
            {
              return;
            }

          case HostRoot:
          case HostPortal:
            {
              var portalOrRoot = finishedWork.stateNode;
              var containerInfo = portalOrRoot.containerInfo,
                  _pendingChildren = portalOrRoot.pendingChildren;
              replaceContainerChildren(containerInfo, _pendingChildren);
              return;
            }

          default:
            {
              invariant(false, "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;
        }

        invariant(false, "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) {
            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;

        switch (parentFiber.tag) {
          case HostComponent:
            parent = parentFiber.stateNode;
            isContainer = false;
            break;

          case HostRoot:
            parent = parentFiber.stateNode.containerInfo;
            isContainer = true;
            break;

          case HostPortal:
            parent = parentFiber.stateNode.containerInfo;
            isContainer = true;
            break;

          default:
            invariant(false, "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) {
          if (node.tag === HostComponent || node.tag === HostText) {
            if (before) {
              if (isContainer) {
                insertInContainerBefore(parent, node.stateNode, before);
              } else {
                insertBefore(parent, node.stateNode, before);
              }
            } else {
              if (isContainer) {
                appendChildToContainer(parent, node.stateNode);
              } else {
                appendChild(parent, node.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) {
        var node = current;
        var currentParentIsValid = false;
        var currentParent = void 0;
        var currentParentIsContainer = void 0;

        while (true) {
          if (!currentParentIsValid) {
            var parent = node.return;

            findParent: while (true) {
              invariant(parent !== null, "Expected to find a host parent. This error is likely caused by " + "a bug in React. Please file an issue.");

              switch (parent.tag) {
                case HostComponent:
                  currentParent = parent.stateNode;
                  currentParentIsContainer = false;
                  break findParent;

                case HostRoot:
                  currentParent = parent.stateNode.containerInfo;
                  currentParentIsContainer = true;
                  break findParent;

                case HostPortal:
                  currentParent = parent.stateNode.containerInfo;
                  currentParentIsContainer = true;
                  break findParent;
              }

              parent = parent.return;
            }

            currentParentIsValid = true;
          }

          if (node.tag === HostComponent || node.tag === HostText) {
            commitNestedUnmounts(node);

            if (currentParentIsContainer) {
              removeChildFromContainer(currentParent, node.stateNode);
            } else {
              removeChild(currentParent, node.stateNode);
            }
          } else if (node.tag === HostPortal) {
            currentParent = node.stateNode.containerInfo;

            if (node.child !== null) {
              node.child.return = node;
              node = node.child;
              continue;
            }
          } else {
            commitUnmount(node);

            if (node.child !== null) {
              node.child.return = node;
              node = node.child;
              continue;
            }
          }

          if (node === current) {
            return;
          }

          while (node.sibling === null) {
            if (node.return === null || node.return === current) {
              return;
            }

            node = node.return;

            if (node.tag === HostPortal) {
              currentParentIsValid = false;
            }
          }

          node.sibling.return = node.return;
          node = node.sibling;
        }
      }

      function commitDeletion(current) {
        if (supportsMutation) {
          unmountHostComponents(current);
        } else {
          commitNestedUnmounts(current);
        }

        detachFiber(current);
      }

      function commitWork(current, finishedWork) {
        if (!supportsMutation) {
          commitContainer(finishedWork);
          return;
        }

        switch (finishedWork.tag) {
          case ClassComponent:
            {
              return;
            }

          case HostComponent:
            {
              var instance = finishedWork.stateNode;

              if (instance != null) {
                var newProps = finishedWork.memoizedProps;
                var oldProps = current !== null ? current.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:
            {
              invariant(finishedWork.stateNode !== null, "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 !== null ? current.memoizedProps : newText;
              commitTextUpdate(textInstance, oldText, newText);
              return;
            }

          case HostRoot:
            {
              return;
            }

          case Profiler:
            {
              if (enableProfilerTimer) {
                var onRender = finishedWork.memoizedProps.onRender;
                onRender(finishedWork.memoizedProps.id, current === null ? "mount" : "update", finishedWork.actualDuration, finishedWork.treeBaseTime, finishedWork.actualStartTime, getCommitTime());
              }

              return;
            }

          case TimeoutComponent:
            {
              return;
            }

          default:
            {
              invariant(false, "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 commitResetTextContent(current) {
        if (!supportsMutation) {
          return;
        }

        resetTextContent(current.stateNode);
      }

      function createRootErrorUpdate(fiber, errorInfo, expirationTime) {
        var update = createUpdate(expirationTime);
        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);
        update.tag = CaptureUpdate;
        var getDerivedStateFromCatch = fiber.type.getDerivedStateFromCatch;

        if (enableGetDerivedStateFromCatch && typeof getDerivedStateFromCatch === "function") {
          var error = errorInfo.value;

          update.payload = function () {
            return getDerivedStateFromCatch(error);
          };
        }

        var inst = fiber.stateNode;

        if (inst !== null && typeof inst.componentDidCatch === "function") {
          update.callback = function callback() {
            if (!enableGetDerivedStateFromCatch || getDerivedStateFromCatch !== "function") {
              markLegacyErrorBoundaryAsFailed(this);
            }

            var error = errorInfo.value;
            var stack = errorInfo.stack;
            logError(fiber, errorInfo);
            this.componentDidCatch(error, {
              componentStack: stack !== null ? stack : ""
            });
          };
        }

        return update;
      }

      function schedulePing(finishedWork) {
        var currentTime = recalculateCurrentTime();
        var expirationTime = computeExpirationForFiber(currentTime, finishedWork);
        var recoveryUpdate = createUpdate(expirationTime);
        enqueueUpdate(finishedWork, recoveryUpdate, expirationTime);
        scheduleWork(finishedWork, expirationTime);
      }

      function throwException(root, returnFiber, sourceFiber, value, renderExpirationTime, currentTimeMs) {
        sourceFiber.effectTag |= Incomplete;
        sourceFiber.firstEffect = sourceFiber.lastEffect = null;

        if (enableSuspense && value !== null && typeof value === "object" && typeof value.then === "function") {
          var thenable = value;
          var expirationTimeMs = expirationTimeToMs(renderExpirationTime);
          var startTimeMs = expirationTimeMs - 5000;
          var elapsedMs = currentTimeMs - startTimeMs;

          if (elapsedMs < 0) {
            elapsedMs = 0;
          }

          var remainingTimeMs = expirationTimeMs - currentTimeMs;
          var _workInProgress = returnFiber;
          var earliestTimeoutMs = -1;

          searchForEarliestTimeout: do {
            if (_workInProgress.tag === TimeoutComponent) {
              var current = _workInProgress.alternate;

              if (current !== null && current.memoizedState === true) {
                earliestTimeoutMs = 0;
                break searchForEarliestTimeout;
              }

              var timeoutPropMs = _workInProgress.pendingProps.ms;

              if (typeof timeoutPropMs === "number") {
                if (timeoutPropMs <= 0) {
                  earliestTimeoutMs = 0;
                  break searchForEarliestTimeout;
                } else if (earliestTimeoutMs === -1 || timeoutPropMs < earliestTimeoutMs) {
                  earliestTimeoutMs = timeoutPropMs;
                }
              } else if (earliestTimeoutMs === -1) {
                earliestTimeoutMs = remainingTimeMs;
              }
            }

            _workInProgress = _workInProgress.return;
          } while (_workInProgress !== null);

          var msUntilTimeout = earliestTimeoutMs - elapsedMs;

          if (renderExpirationTime === Never || msUntilTimeout > 0) {
            markTimeout(root, thenable, msUntilTimeout, renderExpirationTime);

            var onResolveOrReject = function onResolveOrReject() {
              retrySuspendedRoot(root, renderExpirationTime);
            };

            thenable.then(onResolveOrReject, onResolveOrReject);
            return;
          } else {
            _workInProgress = returnFiber;

            do {
              switch (_workInProgress.tag) {
                case HostRoot:
                  {
                    var message = renderExpirationTime === Sync ? "A synchronous update was suspended, but no fallback UI " + "was provided." : "An update was suspended for longer than the timeout, " + "but no fallback UI was provided.";
                    value = new Error(message);
                    break;
                  }

                case TimeoutComponent:
                  {
                    if ((_workInProgress.effectTag & DidCapture) === NoEffect) {
                      _workInProgress.effectTag |= ShouldCapture;

                      var _onResolveOrReject = schedulePing.bind(null, _workInProgress);

                      thenable.then(_onResolveOrReject, _onResolveOrReject);
                      return;
                    }

                    break;
                  }
              }

              _workInProgress = _workInProgress.return;
            } while (_workInProgress !== null);
          }
        } else {
          markError(root);

          if (!root.didError && renderExpirationTime !== Sync || hasLowerPriorityWork(root, renderExpirationTime)) {
            return;
          }
        }

        value = createCapturedValue(value, sourceFiber);
        var workInProgress = returnFiber;

        do {
          switch (workInProgress.tag) {
            case HostRoot:
              {
                var _errorInfo = value;
                workInProgress.effectTag |= ShouldCapture;
                var update = createRootErrorUpdate(workInProgress, _errorInfo, renderExpirationTime);
                enqueueCapturedUpdate(workInProgress, update, renderExpirationTime);
                return;
              }

            case ClassComponent:
              var errorInfo = value;
              var ctor = workInProgress.type;
              var instance = workInProgress.stateNode;

              if ((workInProgress.effectTag & DidCapture) === NoEffect && (typeof ctor.getDerivedStateFromCatch === "function" && enableGetDerivedStateFromCatch || instance !== null && typeof instance.componentDidCatch === "function" && !isAlreadyFailedLegacyErrorBoundary(instance))) {
                workInProgress.effectTag |= ShouldCapture;

                var _update = createClassErrorUpdate(workInProgress, errorInfo, renderExpirationTime);

                enqueueCapturedUpdate(workInProgress, _update, renderExpirationTime);
                return;
              }

              break;

            default:
              break;
          }

          workInProgress = workInProgress.return;
        } while (workInProgress !== null);
      }

      function unwindWork(workInProgress, renderExpirationTime) {
        if (enableProfilerTimer) {
          if (workInProgress.mode & ProfileMode) {
            recordElapsedActualRenderTime(workInProgress);
          }
        }

        switch (workInProgress.tag) {
          case ClassComponent:
            {
              popContextProvider(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;

              if (_effectTag & ShouldCapture) {
                workInProgress.effectTag = _effectTag & ~ShouldCapture | DidCapture;
                return workInProgress;
              }

              return null;
            }

          case HostComponent:
            {
              popHostContext(workInProgress);
              return null;
            }

          case TimeoutComponent:
            {
              var _effectTag2 = workInProgress.effectTag;

              if (_effectTag2 & ShouldCapture) {
                workInProgress.effectTag = _effectTag2 & ~ShouldCapture | DidCapture;
                return workInProgress;
              }

              return null;
            }

          case HostPortal:
            popHostContainer(workInProgress);
            return null;

          case ContextProvider:
            popProvider(workInProgress);
            return null;

          default:
            return null;
        }
      }

      function unwindInterruptedWork(interruptedWork) {
        if (enableProfilerTimer) {
          if (interruptedWork.mode & ProfileMode) {
            resumeActualRenderTimerIfPaused();
            recordElapsedActualRenderTime(interruptedWork);
          }
        }

        switch (interruptedWork.tag) {
          case ClassComponent:
            {
              popContextProvider(interruptedWork);
              break;
            }

          case HostRoot:
            {
              popHostContainer(interruptedWork);
              popTopLevelContextObject(interruptedWork);
              break;
            }

          case HostComponent:
            {
              popHostContext(interruptedWork);
              break;
            }

          case HostPortal:
            popHostContainer(interruptedWork);
            break;

          case ContextProvider:
            popProvider(interruptedWork);
            break;

          default:
            break;
        }
      }

      var invokeGuardedCallback$2 = ReactErrorUtils.invokeGuardedCallback;
      var hasCaughtError = ReactErrorUtils.hasCaughtError;
      var clearCaughtError = ReactErrorUtils.clearCaughtError;
      var didWarnAboutStateTransition = void 0;
      var didWarnSetStateChildContext = void 0;
      var warnAboutUpdateOnUnmounted = void 0;
      var warnAboutInvalidUpdates = void 0;
      {
        didWarnAboutStateTransition = false;
        didWarnSetStateChildContext = false;
        var didWarnStateUpdateForUnmountedComponent = {};

        warnAboutUpdateOnUnmounted = function warnAboutUpdateOnUnmounted(fiber) {
          var componentName = getComponentName(fiber) || "ReactClass";

          if (didWarnStateUpdateForUnmountedComponent[componentName]) {
            return;
          }

          warning(false, "Can't call setState (or forceUpdate) 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 the " + "componentWillUnmount method.%s", getStackAddendumByWorkInProgressFiber(fiber));
          didWarnStateUpdateForUnmountedComponent[componentName] = true;
        };

        warnAboutInvalidUpdates = function warnAboutInvalidUpdates(instance) {
          switch (ReactDebugCurrentFiber.phase) {
            case "getChildContext":
              if (didWarnSetStateChildContext) {
                return;
              }

              warning(false, "setState(...): Cannot call setState() inside getChildContext()");
              didWarnSetStateChildContext = true;
              break;

            case "render":
              if (didWarnAboutStateTransition) {
                return;
              }

              warning(false, "Cannot update during an existing state transition (such as within " + "`render` or another component's constructor). Render methods should " + "be a pure function of props and state; constructor side-effects are " + "an anti-pattern, but can be moved to `componentWillMount`.");
              didWarnAboutStateTransition = true;
              break;
          }
        };
      }
      var originalStartTimeMs = now();
      var mostRecentCurrentTime = msToExpirationTime(0);
      var mostRecentCurrentTimeMs = originalStartTimeMs;
      var lastUniqueAsyncExpiration = 0;
      var expirationContext = NoWork;
      var isWorking = false;
      var nextUnitOfWork = null;
      var nextRoot = null;
      var nextRenderExpirationTime = NoWork;
      var nextLatestTimeoutMs = -1;
      var nextRenderDidError = false;
      var nextEffect = null;
      var isCommitting$1 = false;
      var legacyErrorBoundariesThatAlreadyFailed = null;
      var interruptedBy = null;
      var stashedWorkInProgressProperties = void 0;
      var replayUnitOfWork = void 0;
      var isReplayingFailedUnitOfWork = void 0;
      var originalReplayError = void 0;
      var rethrowOriginalError = void 0;

      if (true && replayFailedUnitOfWorkWithInvokeGuardedCallback) {
        stashedWorkInProgressProperties = null;
        isReplayingFailedUnitOfWork = false;
        originalReplayError = null;

        replayUnitOfWork = function replayUnitOfWork(failedUnitOfWork, thrownValue, isYieldy) {
          if (thrownValue !== null && typeof thrownValue === "object" && typeof thrownValue.then === "function") {
            return;
          }

          if (stashedWorkInProgressProperties === null) {
            warning(false, "Could not replay rendering after an error. This is likely a bug in React. " + "Please file an issue.");
            return;
          }

          assignFiberPropertiesInDEV(failedUnitOfWork, stashedWorkInProgressProperties);

          switch (failedUnitOfWork.tag) {
            case HostRoot:
              popHostContainer(failedUnitOfWork);
              popTopLevelContextObject(failedUnitOfWork);
              break;

            case HostComponent:
              popHostContext(failedUnitOfWork);
              break;

            case ClassComponent:
              popContextProvider(failedUnitOfWork);
              break;

            case HostPortal:
              popHostContainer(failedUnitOfWork);
              break;

            case ContextProvider:
              popProvider(failedUnitOfWork);
              break;
          }

          isReplayingFailedUnitOfWork = true;
          originalReplayError = thrownValue;
          invokeGuardedCallback$2(null, workLoop, null, isYieldy);
          isReplayingFailedUnitOfWork = false;
          originalReplayError = null;

          if (hasCaughtError()) {
            clearCaughtError();

            if (enableProfilerTimer) {
              if (failedUnitOfWork.mode & ProfileMode) {
                recordElapsedActualRenderTime(failedUnitOfWork);
              }

              stopBaseRenderTimerIfRunning();
            }
          } else {
            nextUnitOfWork = failedUnitOfWork;
          }
        };

        rethrowOriginalError = function rethrowOriginalError() {
          throw originalReplayError;
        };
      }

      function resetStack() {
        if (nextUnitOfWork !== null) {
          var interruptedWork = nextUnitOfWork.return;

          while (interruptedWork !== null) {
            unwindInterruptedWork(interruptedWork);
            interruptedWork = interruptedWork.return;
          }
        }

        {
          ReactStrictModeWarnings.discardPendingWarnings();
          checkThatStackIsEmpty();
        }
        nextRoot = null;
        nextRenderExpirationTime = NoWork;
        nextLatestTimeoutMs = -1;
        nextRenderDidError = false;
        nextUnitOfWork = null;
      }

      function commitAllHostEffects() {
        while (nextEffect !== null) {
          {
            ReactDebugCurrentFiber.setCurrentFiber(nextEffect);
          }
          recordEffect();
          var effectTag = nextEffect.effectTag;

          if (effectTag & ContentReset) {
            commitResetTextContent(nextEffect);
          }

          if (effectTag & Ref) {
            var current = nextEffect.alternate;

            if (current !== null) {
              commitDetachRef(current);
            }
          }

          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);
                break;
              }
          }

          nextEffect = nextEffect.nextEffect;
        }

        {
          ReactDebugCurrentFiber.resetCurrentFiber();
        }
      }

      function commitBeforeMutationLifecycles() {
        while (nextEffect !== null) {
          var effectTag = nextEffect.effectTag;

          if (effectTag & Snapshot) {
            recordEffect();
            var current = nextEffect.alternate;
            commitBeforeMutationLifeCycles(current, nextEffect);
          }

          nextEffect = nextEffect.nextEffect;
        }
      }

      function commitAllLifeCycles(finishedRoot, currentTime, committedExpirationTime) {
        {
          ReactStrictModeWarnings.flushPendingUnsafeLifecycleWarnings();

          if (warnAboutDeprecatedLifecycles) {
            ReactStrictModeWarnings.flushPendingDeprecationWarnings();
          }

          if (warnAboutLegacyContextAPI) {
            ReactStrictModeWarnings.flushLegacyContextWarning();
          }
        }

        while (nextEffect !== null) {
          var effectTag = nextEffect.effectTag;

          if (effectTag & (Update | Callback)) {
            recordEffect();
            var current = nextEffect.alternate;
            commitLifeCycles(finishedRoot, current, nextEffect, currentTime, committedExpirationTime);
          }

          if (effectTag & Ref) {
            recordEffect();
            commitAttachRef(nextEffect);
          }

          var next = nextEffect.nextEffect;
          nextEffect.nextEffect = null;
          nextEffect = next;
        }
      }

      function isAlreadyFailedLegacyErrorBoundary(instance) {
        return legacyErrorBoundariesThatAlreadyFailed !== null && legacyErrorBoundariesThatAlreadyFailed.has(instance);
      }

      function markLegacyErrorBoundaryAsFailed(instance) {
        if (legacyErrorBoundariesThatAlreadyFailed === null) {
          legacyErrorBoundariesThatAlreadyFailed = new Set([instance]);
        } else {
          legacyErrorBoundariesThatAlreadyFailed.add(instance);
        }
      }

      function commitRoot(root, finishedWork) {
        isWorking = true;
        isCommitting$1 = true;
        startCommitTimer();
        invariant(root.current !== finishedWork, "Cannot commit the same tree as before. This is probably a bug " + "related to the return field. This error is likely caused by a bug " + "in React. Please file an issue.");
        var committedExpirationTime = root.pendingCommitExpirationTime;
        invariant(committedExpirationTime !== NoWork, "Cannot commit an incomplete root. This error is likely caused by a " + "bug in React. Please file an issue.");
        root.pendingCommitExpirationTime = NoWork;
        var earliestRemainingTime = finishedWork.expirationTime;
        var currentTime = recalculateCurrentTime();
        markCommittedPriorityLevels(root, currentTime, earliestRemainingTime);
        ReactCurrentOwner.current = null;
        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;
        }

        prepareForCommit(root.containerInfo);
        nextEffect = firstEffect;
        startCommitSnapshotEffectsTimer();

        while (nextEffect !== null) {
          var didError = false;
          var error = void 0;
          {
            invokeGuardedCallback$2(null, commitBeforeMutationLifecycles, null);

            if (hasCaughtError()) {
              didError = true;
              error = clearCaughtError();
            }
          }

          if (didError) {
            invariant(nextEffect !== null, "Should have next effect. This error is likely caused by a bug " + "in React. Please file an issue.");
            captureCommitPhaseError(nextEffect, error);

            if (nextEffect !== null) {
              nextEffect = nextEffect.nextEffect;
            }
          }
        }

        stopCommitSnapshotEffectsTimer();

        if (enableProfilerTimer) {
          recordCommitTime();
        }

        nextEffect = firstEffect;
        startCommitHostEffectsTimer();

        while (nextEffect !== null) {
          var _didError = false;

          var _error = void 0;

          {
            invokeGuardedCallback$2(null, commitAllHostEffects, null);

            if (hasCaughtError()) {
              _didError = true;
              _error = clearCaughtError();
            }
          }

          if (_didError) {
            invariant(nextEffect !== null, "Should have next effect. This error is likely caused by a bug " + "in React. Please file an issue.");
            captureCommitPhaseError(nextEffect, _error);

            if (nextEffect !== null) {
              nextEffect = nextEffect.nextEffect;
            }
          }
        }

        stopCommitHostEffectsTimer();
        resetAfterCommit(root.containerInfo);
        root.current = finishedWork;
        nextEffect = firstEffect;
        startCommitLifeCyclesTimer();

        while (nextEffect !== null) {
          var _didError2 = false;

          var _error2 = void 0;

          {
            invokeGuardedCallback$2(null, commitAllLifeCycles, null, root, currentTime, committedExpirationTime);

            if (hasCaughtError()) {
              _didError2 = true;
              _error2 = clearCaughtError();
            }
          }

          if (_didError2) {
            invariant(nextEffect !== null, "Should have next effect. This error is likely caused by a bug " + "in React. Please file an issue.");
            captureCommitPhaseError(nextEffect, _error2);

            if (nextEffect !== null) {
              nextEffect = nextEffect.nextEffect;
            }
          }
        }

        if (enableProfilerTimer) {
          {
            checkActualRenderTimeStackEmpty();
          }
          resetActualRenderTimer();
        }

        isCommitting$1 = false;
        isWorking = false;
        stopCommitLifeCyclesTimer();
        stopCommitTimer();

        if (typeof onCommitRoot === "function") {
          onCommitRoot(finishedWork.stateNode);
        }

        if (true && ReactFiberInstrumentation_1.debugTool) {
          ReactFiberInstrumentation_1.debugTool.onCommitWork(finishedWork);
        }

        var expirationTime = root.expirationTime;

        if (expirationTime === NoWork) {
          legacyErrorBoundariesThatAlreadyFailed = null;
        }

        onCommit(root, expirationTime);
      }

      function resetExpirationTime(workInProgress, renderTime) {
        if (renderTime !== Never && workInProgress.expirationTime === Never) {
          return;
        }

        var newExpirationTime = NoWork;

        switch (workInProgress.tag) {
          case HostRoot:
          case ClassComponent:
            {
              var updateQueue = workInProgress.updateQueue;

              if (updateQueue !== null) {
                newExpirationTime = updateQueue.expirationTime;
              }
            }
        }

        if (enableProfilerTimer && workInProgress.mode & ProfileMode) {
          var treeBaseTime = workInProgress.selfBaseTime;
          var child = workInProgress.child;

          while (child !== null) {
            treeBaseTime += child.treeBaseTime;

            if (child.expirationTime !== NoWork && (newExpirationTime === NoWork || newExpirationTime > child.expirationTime)) {
              newExpirationTime = child.expirationTime;
            }

            child = child.sibling;
          }

          workInProgress.treeBaseTime = treeBaseTime;
        } else {
          var _child = workInProgress.child;

          while (_child !== null) {
            if (_child.expirationTime !== NoWork && (newExpirationTime === NoWork || newExpirationTime > _child.expirationTime)) {
              newExpirationTime = _child.expirationTime;
            }

            _child = _child.sibling;
          }
        }

        workInProgress.expirationTime = newExpirationTime;
      }

      function completeUnitOfWork(workInProgress) {
        while (true) {
          var current = workInProgress.alternate;
          {
            ReactDebugCurrentFiber.setCurrentFiber(workInProgress);
          }
          var returnFiber = workInProgress.return;
          var siblingFiber = workInProgress.sibling;

          if ((workInProgress.effectTag & Incomplete) === NoEffect) {
            var next = completeWork(current, workInProgress, nextRenderExpirationTime);
            stopWorkTimer(workInProgress);
            resetExpirationTime(workInProgress, nextRenderExpirationTime);
            {
              ReactDebugCurrentFiber.resetCurrentFiber();
            }

            if (next !== null) {
              stopWorkTimer(workInProgress);

              if (true && ReactFiberInstrumentation_1.debugTool) {
                ReactFiberInstrumentation_1.debugTool.onCompleteWork(workInProgress);
              }

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

            if (true && ReactFiberInstrumentation_1.debugTool) {
              ReactFiberInstrumentation_1.debugTool.onCompleteWork(workInProgress);
            }

            if (siblingFiber !== null) {
              return siblingFiber;
            } else if (returnFiber !== null) {
              workInProgress = returnFiber;
              continue;
            } else {
              return null;
            }
          } else {
            var _next = unwindWork(workInProgress, nextRenderExpirationTime);

            if (workInProgress.effectTag & DidCapture) {
              stopFailedWorkTimer(workInProgress);
            } else {
              stopWorkTimer(workInProgress);
            }

            {
              ReactDebugCurrentFiber.resetCurrentFiber();
            }

            if (_next !== null) {
              stopWorkTimer(workInProgress);

              if (true && ReactFiberInstrumentation_1.debugTool) {
                ReactFiberInstrumentation_1.debugTool.onCompleteWork(workInProgress);
              }

              _next.effectTag &= HostEffectMask;
              return _next;
            }

            if (returnFiber !== null) {
              returnFiber.firstEffect = returnFiber.lastEffect = null;
              returnFiber.effectTag |= Incomplete;
            }

            if (true && ReactFiberInstrumentation_1.debugTool) {
              ReactFiberInstrumentation_1.debugTool.onCompleteWork(workInProgress);
            }

            if (siblingFiber !== null) {
              return siblingFiber;
            } else if (returnFiber !== null) {
              workInProgress = returnFiber;
              continue;
            } else {
              return null;
            }
          }
        }

        return null;
      }

      function performUnitOfWork(workInProgress) {
        var current = workInProgress.alternate;
        startWorkTimer(workInProgress);
        {
          ReactDebugCurrentFiber.setCurrentFiber(workInProgress);
        }

        if (true && replayFailedUnitOfWorkWithInvokeGuardedCallback) {
          stashedWorkInProgressProperties = assignFiberPropertiesInDEV(stashedWorkInProgressProperties, workInProgress);
        }

        var next = void 0;

        if (enableProfilerTimer) {
          if (workInProgress.mode & ProfileMode) {
            startBaseRenderTimer();
          }

          next = beginWork(current, workInProgress, nextRenderExpirationTime);

          if (workInProgress.mode & ProfileMode) {
            recordElapsedBaseRenderTimeIfRunning(workInProgress);
            stopBaseRenderTimerIfRunning();
          }
        } else {
          next = beginWork(current, workInProgress, nextRenderExpirationTime);
        }

        {
          ReactDebugCurrentFiber.resetCurrentFiber();

          if (isReplayingFailedUnitOfWork) {
            rethrowOriginalError();
          }
        }

        if (true && ReactFiberInstrumentation_1.debugTool) {
          ReactFiberInstrumentation_1.debugTool.onBeginWork(workInProgress);
        }

        if (next === null) {
          next = completeUnitOfWork(workInProgress);
        }

        ReactCurrentOwner.current = null;
        return next;
      }

      function workLoop(isYieldy) {
        if (!isYieldy) {
          while (nextUnitOfWork !== null) {
            nextUnitOfWork = performUnitOfWork(nextUnitOfWork);
          }
        } else {
          while (nextUnitOfWork !== null && !shouldYield()) {
            nextUnitOfWork = performUnitOfWork(nextUnitOfWork);
          }

          if (enableProfilerTimer) {
            pauseActualRenderTimerIfRunning();
          }
        }
      }

      function renderRoot(root, isYieldy) {
        invariant(!isWorking, "renderRoot was called recursively. This error is likely caused " + "by a bug in React. Please file an issue.");
        isWorking = true;
        var expirationTime = root.nextExpirationTimeToWorkOn;

        if (expirationTime !== nextRenderExpirationTime || root !== nextRoot || nextUnitOfWork === null) {
          resetStack();
          nextRoot = root;
          nextRenderExpirationTime = expirationTime;
          nextLatestTimeoutMs = -1;
          nextRenderDidError = false;
          nextUnitOfWork = createWorkInProgress(nextRoot.current, null, nextRenderExpirationTime);
          root.pendingCommitExpirationTime = NoWork;
        }

        var didFatal = false;
        startWorkLoopTimer(nextUnitOfWork);

        do {
          try {
            workLoop(isYieldy);
          } catch (thrownValue) {
            if (enableProfilerTimer) {
              stopBaseRenderTimerIfRunning();
            }

            if (nextUnitOfWork === null) {
              didFatal = true;
              onUncaughtError(thrownValue);
            } else {
              {
                resetCurrentlyProcessingQueue();
              }
              var failedUnitOfWork = nextUnitOfWork;

              if (true && replayFailedUnitOfWorkWithInvokeGuardedCallback) {
                replayUnitOfWork(failedUnitOfWork, thrownValue, isYieldy);
              }

              invariant(nextUnitOfWork !== null, "Failed to replay rendering after an error. This " + "is likely caused by a bug in React. Please file an issue " + "with a reproducing case to help us find it.");
              var sourceFiber = nextUnitOfWork;
              var returnFiber = sourceFiber.return;

              if (returnFiber === null) {
                didFatal = true;
                onUncaughtError(thrownValue);
                break;
              }

              throwException(root, returnFiber, sourceFiber, thrownValue, nextRenderExpirationTime, mostRecentCurrentTimeMs);
              nextUnitOfWork = completeUnitOfWork(sourceFiber);
            }
          }

          break;
        } while (true);

        isWorking = false;

        if (didFatal) {
          var didCompleteRoot = false;
          stopWorkLoopTimer(interruptedBy, didCompleteRoot);
          interruptedBy = null;
          {
            resetStackAfterFatalErrorInDev();
          }
          onFatal(root);
        } else if (nextUnitOfWork === null) {
          var rootWorkInProgress = root.current.alternate;
          invariant(rootWorkInProgress !== null, "Finished root should have a work-in-progress. This error is likely " + "caused by a bug in React. Please file an issue.");

          if ((rootWorkInProgress.effectTag & Incomplete) === NoEffect) {
            var _didCompleteRoot = true;
            stopWorkLoopTimer(interruptedBy, _didCompleteRoot);
            interruptedBy = null;
            onComplete(root, rootWorkInProgress, expirationTime);
          } else {
            var _didCompleteRoot2 = false;
            stopWorkLoopTimer(interruptedBy, _didCompleteRoot2);
            interruptedBy = null;
            markSuspendedPriorityLevel(root, expirationTime, nextRenderDidError);
            var suspendedExpirationTime = expirationTime;
            var newExpirationTime = root.expirationTime;
            onSuspend(root, suspendedExpirationTime, newExpirationTime, nextLatestTimeoutMs);
          }
        } else {
          var _didCompleteRoot3 = false;
          stopWorkLoopTimer(interruptedBy, _didCompleteRoot3);
          interruptedBy = null;
          onYield(root);
        }
      }

      function dispatch(sourceFiber, value, expirationTime) {
        invariant(!isWorking || isCommitting$1, "dispatch: Cannot dispatch during the render phase.");
        var fiber = sourceFiber.return;

        while (fiber !== null) {
          switch (fiber.tag) {
            case ClassComponent:
              var ctor = fiber.type;
              var instance = fiber.stateNode;

              if (typeof ctor.getDerivedStateFromCatch === "function" || typeof instance.componentDidCatch === "function" && !isAlreadyFailedLegacyErrorBoundary(instance)) {
                var errorInfo = createCapturedValue(value, sourceFiber);
                var update = createClassErrorUpdate(fiber, errorInfo, expirationTime);
                enqueueUpdate(fiber, update, expirationTime);
                scheduleWork(fiber, expirationTime);
                return;
              }

              break;

            case HostRoot:
              {
                var _errorInfo = createCapturedValue(value, sourceFiber);

                var _update = createRootErrorUpdate(fiber, _errorInfo, expirationTime);

                enqueueUpdate(fiber, _update, expirationTime);
                scheduleWork(fiber, expirationTime);
                return;
              }
          }

          fiber = fiber.return;
        }

        if (sourceFiber.tag === HostRoot) {
          var rootFiber = sourceFiber;

          var _errorInfo2 = createCapturedValue(value, rootFiber);

          var _update2 = createRootErrorUpdate(rootFiber, _errorInfo2, expirationTime);

          enqueueUpdate(rootFiber, _update2, expirationTime);
          scheduleWork(rootFiber, expirationTime);
        }
      }

      function captureCommitPhaseError(fiber, error) {
        return dispatch(fiber, error, Sync);
      }

      function computeAsyncExpiration(currentTime) {
        var expirationMs = 5000;
        var bucketSizeMs = 250;
        return computeExpirationBucket(currentTime, expirationMs, bucketSizeMs);
      }

      function computeInteractiveExpiration(currentTime) {
        var expirationMs = void 0;
        {
          expirationMs = 500;
        }
        var bucketSizeMs = 100;
        return computeExpirationBucket(currentTime, expirationMs, bucketSizeMs);
      }

      function computeUniqueAsyncExpiration() {
        var currentTime = recalculateCurrentTime();
        var result = computeAsyncExpiration(currentTime);

        if (result <= lastUniqueAsyncExpiration) {
          result = lastUniqueAsyncExpiration + 1;
        }

        lastUniqueAsyncExpiration = result;
        return lastUniqueAsyncExpiration;
      }

      function computeExpirationForFiber(currentTime, fiber) {
        var expirationTime = void 0;

        if (expirationContext !== NoWork) {
          expirationTime = expirationContext;
        } else if (isWorking) {
          if (isCommitting$1) {
            expirationTime = Sync;
          } else {
            expirationTime = nextRenderExpirationTime;
          }
        } else {
          if (fiber.mode & AsyncMode) {
            if (isBatchingInteractiveUpdates) {
              expirationTime = computeInteractiveExpiration(currentTime);
            } else {
              expirationTime = computeAsyncExpiration(currentTime);
            }
          } else {
            expirationTime = Sync;
          }
        }

        if (isBatchingInteractiveUpdates) {
          if (lowestPendingInteractiveExpirationTime === NoWork || expirationTime > lowestPendingInteractiveExpirationTime) {
            lowestPendingInteractiveExpirationTime = expirationTime;
          }
        }

        return expirationTime;
      }

      function markTimeout(root, thenable, timeoutMs, suspendedTime) {
        if (timeoutMs >= 0 && nextLatestTimeoutMs < timeoutMs) {
          nextLatestTimeoutMs = timeoutMs;
        }
      }

      function markError(root) {
        nextRenderDidError = true;
      }

      function retrySuspendedRoot(root, suspendedTime) {
        markPingedPriorityLevel(root, suspendedTime);
        var retryTime = root.expirationTime;

        if (retryTime !== NoWork) {
          requestWork(root, retryTime);
        }
      }

      function scheduleWork(fiber, expirationTime) {
        recordScheduleUpdate();
        {
          if (fiber.tag === ClassComponent) {
            var instance = fiber.stateNode;
            warnAboutInvalidUpdates(instance);
          }
        }
        var node = fiber;

        while (node !== null) {
          if (node.expirationTime === NoWork || node.expirationTime > expirationTime) {
            node.expirationTime = expirationTime;
          }

          if (node.alternate !== null) {
            if (node.alternate.expirationTime === NoWork || node.alternate.expirationTime > expirationTime) {
              node.alternate.expirationTime = expirationTime;
            }
          }

          if (node.return === null) {
            if (node.tag === HostRoot) {
              var root = node.stateNode;

              if (!isWorking && nextRenderExpirationTime !== NoWork && expirationTime < nextRenderExpirationTime) {
                interruptedBy = fiber;
                resetStack();
              }

              markPendingPriorityLevel(root, expirationTime);

              if (!isWorking || isCommitting$1 || nextRoot !== root) {
                var rootExpirationTime = root.expirationTime;
                requestWork(root, rootExpirationTime);
              }

              if (nestedUpdateCount > NESTED_UPDATE_LIMIT) {
                invariant(false, "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.");
              }
            } else {
              {
                if (fiber.tag === ClassComponent) {
                  warnAboutUpdateOnUnmounted(fiber);
                }
              }
              return;
            }
          }

          node = node.return;
        }
      }

      function recalculateCurrentTime() {
        mostRecentCurrentTimeMs = now() - originalStartTimeMs;
        mostRecentCurrentTime = msToExpirationTime(mostRecentCurrentTimeMs);
        return mostRecentCurrentTime;
      }

      function deferredUpdates(fn) {
        var previousExpirationContext = expirationContext;
        var currentTime = recalculateCurrentTime();
        expirationContext = computeAsyncExpiration(currentTime);

        try {
          return fn();
        } finally {
          expirationContext = previousExpirationContext;
        }
      }

      function syncUpdates(fn, a, b, c, d) {
        var previousExpirationContext = expirationContext;
        expirationContext = Sync;

        try {
          return fn(a, b, c, d);
        } finally {
          expirationContext = previousExpirationContext;
        }
      }

      var firstScheduledRoot = null;
      var lastScheduledRoot = null;
      var callbackExpirationTime = NoWork;
      var callbackID = void 0;
      var isRendering = false;
      var nextFlushedRoot = null;
      var nextFlushedExpirationTime = NoWork;
      var lowestPendingInteractiveExpirationTime = NoWork;
      var deadlineDidExpire = false;
      var hasUnhandledError = false;
      var unhandledError = null;
      var deadline = null;
      var isBatchingUpdates = false;
      var isUnbatchingUpdates = false;
      var isBatchingInteractiveUpdates = false;
      var completedBatches = null;
      var NESTED_UPDATE_LIMIT = 1000;
      var nestedUpdateCount = 0;
      var timeHeuristicForUnitOfWork = 1;

      function scheduleCallbackWithExpirationTime(expirationTime) {
        if (callbackExpirationTime !== NoWork) {
          if (expirationTime > callbackExpirationTime) {
            return;
          } else {
            if (callbackID !== null) {
              cancelDeferredCallback(callbackID);
            }
          }
        } else {
          startRequestCallbackTimer();
        }

        callbackExpirationTime = expirationTime;
        var currentMs = now() - originalStartTimeMs;
        var expirationTimeMs = expirationTimeToMs(expirationTime);
        var timeout = expirationTimeMs - currentMs;
        callbackID = scheduleDeferredCallback(performAsyncWork, {
          timeout: timeout
        });
      }

      function onFatal(root) {
        root.finishedWork = null;
      }

      function onComplete(root, finishedWork, expirationTime) {
        root.pendingCommitExpirationTime = expirationTime;
        root.finishedWork = finishedWork;
      }

      function onSuspend(root, suspendedExpirationTime, expirationTime, timeoutMs) {
        if (timeoutMs >= 0) {
          var suspendedRoot = root;
          setTimeout(function () {
            retrySuspendedRoot(suspendedRoot, suspendedExpirationTime);
          }, timeoutMs);
        }

        root.expirationTime = expirationTime;
      }

      function onYield(root) {
        root.finishedWork = null;
      }

      function onCommit(root, expirationTime) {
        root.expirationTime = expirationTime;
        root.finishedWork = null;
      }

      function requestWork(root, expirationTime) {
        addRootToSchedule(root, expirationTime);

        if (isRendering) {
          return;
        }

        if (isBatchingUpdates) {
          if (isUnbatchingUpdates) {
            nextFlushedRoot = root;
            nextFlushedExpirationTime = Sync;
            performWorkOnRoot(root, Sync, false);
          }

          return;
        }

        if (expirationTime === Sync) {
          performSyncWork();
        } else {
          scheduleCallbackWithExpirationTime(expirationTime);
        }
      }

      function addRootToSchedule(root, expirationTime) {
        if (root.nextScheduledRoot === null) {
          root.expirationTime = expirationTime;

          if (lastScheduledRoot === null) {
            firstScheduledRoot = lastScheduledRoot = root;
            root.nextScheduledRoot = root;
          } else {
            lastScheduledRoot.nextScheduledRoot = root;
            lastScheduledRoot = root;
            lastScheduledRoot.nextScheduledRoot = firstScheduledRoot;
          }
        } else {
          var remainingExpirationTime = root.expirationTime;

          if (remainingExpirationTime === NoWork || expirationTime < remainingExpirationTime) {
            root.expirationTime = expirationTime;
          }
        }
      }

      function findHighestPriorityRoot() {
        var highestPriorityWork = NoWork;
        var highestPriorityRoot = null;

        if (lastScheduledRoot !== null) {
          var previousScheduledRoot = lastScheduledRoot;
          var root = firstScheduledRoot;

          while (root !== null) {
            var remainingExpirationTime = root.expirationTime;

            if (remainingExpirationTime === NoWork) {
              invariant(previousScheduledRoot !== null && lastScheduledRoot !== null, "Should have a previous and last root. This error is likely " + "caused by a bug in React. Please file an issue.");

              if (root === root.nextScheduledRoot) {
                root.nextScheduledRoot = null;
                firstScheduledRoot = lastScheduledRoot = null;
                break;
              } else if (root === firstScheduledRoot) {
                var next = root.nextScheduledRoot;
                firstScheduledRoot = next;
                lastScheduledRoot.nextScheduledRoot = next;
                root.nextScheduledRoot = null;
              } else if (root === lastScheduledRoot) {
                lastScheduledRoot = previousScheduledRoot;
                lastScheduledRoot.nextScheduledRoot = firstScheduledRoot;
                root.nextScheduledRoot = null;
                break;
              } else {
                previousScheduledRoot.nextScheduledRoot = root.nextScheduledRoot;
                root.nextScheduledRoot = null;
              }

              root = previousScheduledRoot.nextScheduledRoot;
            } else {
              if (highestPriorityWork === NoWork || remainingExpirationTime < highestPriorityWork) {
                highestPriorityWork = remainingExpirationTime;
                highestPriorityRoot = root;
              }

              if (root === lastScheduledRoot) {
                break;
              }

              previousScheduledRoot = root;
              root = root.nextScheduledRoot;
            }
          }
        }

        var previousFlushedRoot = nextFlushedRoot;

        if (previousFlushedRoot !== null && previousFlushedRoot === highestPriorityRoot && highestPriorityWork === Sync) {
          nestedUpdateCount++;
        } else {
          nestedUpdateCount = 0;
        }

        nextFlushedRoot = highestPriorityRoot;
        nextFlushedExpirationTime = highestPriorityWork;
      }

      function performAsyncWork(dl) {
        performWork(NoWork, dl);
      }

      function performSyncWork() {
        performWork(Sync, null);
      }

      function performWork(minExpirationTime, dl) {
        deadline = dl;
        findHighestPriorityRoot();

        if (enableProfilerTimer) {
          resumeActualRenderTimerIfPaused();
        }

        if (enableUserTimingAPI && deadline !== null) {
          var didExpire = nextFlushedExpirationTime < recalculateCurrentTime();
          var timeout = expirationTimeToMs(nextFlushedExpirationTime);
          stopRequestCallbackTimer(didExpire, timeout);
        }

        if (deadline !== null) {
          while (nextFlushedRoot !== null && nextFlushedExpirationTime !== NoWork && (minExpirationTime === NoWork || minExpirationTime >= nextFlushedExpirationTime) && (!deadlineDidExpire || recalculateCurrentTime() >= nextFlushedExpirationTime)) {
            recalculateCurrentTime();
            performWorkOnRoot(nextFlushedRoot, nextFlushedExpirationTime, true);
            findHighestPriorityRoot();
          }
        } else {
          while (nextFlushedRoot !== null && nextFlushedExpirationTime !== NoWork && (minExpirationTime === NoWork || minExpirationTime >= nextFlushedExpirationTime)) {
            performWorkOnRoot(nextFlushedRoot, nextFlushedExpirationTime, false);
            findHighestPriorityRoot();
          }
        }

        if (deadline !== null) {
          callbackExpirationTime = NoWork;
          callbackID = null;
        }

        if (nextFlushedExpirationTime !== NoWork) {
          scheduleCallbackWithExpirationTime(nextFlushedExpirationTime);
        }

        deadline = null;
        deadlineDidExpire = false;
        finishRendering();
      }

      function flushRoot(root, expirationTime) {
        invariant(!isRendering, "work.commit(): Cannot commit while already rendering. This likely " + "means you attempted to commit from inside a lifecycle method.");
        nextFlushedRoot = root;
        nextFlushedExpirationTime = expirationTime;
        performWorkOnRoot(root, expirationTime, false);
        performSyncWork();
        finishRendering();
      }

      function finishRendering() {
        nestedUpdateCount = 0;

        if (completedBatches !== null) {
          var batches = completedBatches;
          completedBatches = null;

          for (var i = 0; i < batches.length; i++) {
            var batch = batches[i];

            try {
              batch._onComplete();
            } catch (error) {
              if (!hasUnhandledError) {
                hasUnhandledError = true;
                unhandledError = error;
              }
            }
          }
        }

        if (hasUnhandledError) {
          var error = unhandledError;
          unhandledError = null;
          hasUnhandledError = false;
          throw error;
        }
      }

      function performWorkOnRoot(root, expirationTime, isYieldy) {
        invariant(!isRendering, "performWorkOnRoot was called recursively. This error is likely caused " + "by a bug in React. Please file an issue.");
        isRendering = true;

        if (!isYieldy) {
          var finishedWork = root.finishedWork;

          if (finishedWork !== null) {
            completeRoot(root, finishedWork, expirationTime);
          } else {
            root.finishedWork = null;
            renderRoot(root, false);
            finishedWork = root.finishedWork;

            if (finishedWork !== null) {
              completeRoot(root, finishedWork, expirationTime);
            }
          }
        } else {
          var _finishedWork = root.finishedWork;

          if (_finishedWork !== null) {
            completeRoot(root, _finishedWork, expirationTime);
          } else {
            root.finishedWork = null;
            renderRoot(root, true);
            _finishedWork = root.finishedWork;

            if (_finishedWork !== null) {
              if (!shouldYield()) {
                completeRoot(root, _finishedWork, expirationTime);
              } else {
                root.finishedWork = _finishedWork;

                if (enableProfilerTimer) {
                  pauseActualRenderTimerIfRunning();
                }
              }
            }
          }
        }

        isRendering = false;
      }

      function completeRoot(root, finishedWork, expirationTime) {
        var firstBatch = root.firstBatch;

        if (firstBatch !== null && firstBatch._expirationTime <= expirationTime) {
          if (completedBatches === null) {
            completedBatches = [firstBatch];
          } else {
            completedBatches.push(firstBatch);
          }

          if (firstBatch._defer) {
            root.finishedWork = finishedWork;
            root.expirationTime = NoWork;
            return;
          }
        }

        root.finishedWork = null;
        commitRoot(root, finishedWork);
      }

      function shouldYield() {
        if (deadline === null || deadlineDidExpire) {
          return false;
        }

        if (deadline.timeRemaining() > timeHeuristicForUnitOfWork) {
          return false;
        }

        deadlineDidExpire = true;
        return true;
      }

      function onUncaughtError(error) {
        invariant(nextFlushedRoot !== null, "Should be working on a root. This error is likely caused by a bug in " + "React. Please file an issue.");
        nextFlushedRoot.expirationTime = NoWork;

        if (!hasUnhandledError) {
          hasUnhandledError = true;
          unhandledError = error;
        }
      }

      function batchedUpdates$1(fn, a) {
        var previousIsBatchingUpdates = isBatchingUpdates;
        isBatchingUpdates = true;

        try {
          return fn(a);
        } finally {
          isBatchingUpdates = previousIsBatchingUpdates;

          if (!isBatchingUpdates && !isRendering) {
            performSyncWork();
          }
        }
      }

      function unbatchedUpdates(fn, a) {
        if (isBatchingUpdates && !isUnbatchingUpdates) {
          isUnbatchingUpdates = true;

          try {
            return fn(a);
          } finally {
            isUnbatchingUpdates = false;
          }
        }

        return fn(a);
      }

      function flushSync(fn, a) {
        invariant(!isRendering, "flushSync was called from inside a lifecycle method. It cannot be " + "called when React is already rendering.");
        var previousIsBatchingUpdates = isBatchingUpdates;
        isBatchingUpdates = true;

        try {
          return syncUpdates(fn, a);
        } finally {
          isBatchingUpdates = previousIsBatchingUpdates;
          performSyncWork();
        }
      }

      function interactiveUpdates$1(fn, a, b) {
        if (isBatchingInteractiveUpdates) {
          return fn(a, b);
        }

        if (!isBatchingUpdates && !isRendering && lowestPendingInteractiveExpirationTime !== NoWork) {
          performWork(lowestPendingInteractiveExpirationTime, null);
          lowestPendingInteractiveExpirationTime = NoWork;
        }

        var previousIsBatchingInteractiveUpdates = isBatchingInteractiveUpdates;
        var previousIsBatchingUpdates = isBatchingUpdates;
        isBatchingInteractiveUpdates = true;
        isBatchingUpdates = true;

        try {
          return fn(a, b);
        } finally {
          isBatchingInteractiveUpdates = previousIsBatchingInteractiveUpdates;
          isBatchingUpdates = previousIsBatchingUpdates;

          if (!isBatchingUpdates && !isRendering) {
            performSyncWork();
          }
        }
      }

      function flushInteractiveUpdates$1() {
        if (!isRendering && lowestPendingInteractiveExpirationTime !== NoWork) {
          performWork(lowestPendingInteractiveExpirationTime, null);
          lowestPendingInteractiveExpirationTime = NoWork;
        }
      }

      function flushControlled(fn) {
        var previousIsBatchingUpdates = isBatchingUpdates;
        isBatchingUpdates = true;

        try {
          syncUpdates(fn);
        } finally {
          isBatchingUpdates = previousIsBatchingUpdates;

          if (!isBatchingUpdates && !isRendering) {
            performWork(Sync, null);
          }
        }
      }

      var didWarnAboutNestedUpdates = void 0;
      {
        didWarnAboutNestedUpdates = false;
      }

      function getContextForSubtree(parentComponent) {
        if (!parentComponent) {
          return emptyObject;
        }

        var fiber = get$1(parentComponent);
        var parentContext = findCurrentUnmaskedContext(fiber);
        return isContextProvider(fiber) ? processChildContext(fiber, parentContext) : parentContext;
      }

      function scheduleRootUpdate(current, element, expirationTime, callback) {
        {
          if (ReactDebugCurrentFiber.phase === "render" && ReactDebugCurrentFiber.current !== null && !didWarnAboutNestedUpdates) {
            didWarnAboutNestedUpdates = true;
            warning(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(ReactDebugCurrentFiber.current) || "Unknown");
          }
        }
        var update = createUpdate(expirationTime);
        update.payload = {
          element: element
        };
        callback = callback === undefined ? null : callback;

        if (callback !== null) {
          !(typeof callback === "function") ? warning(false, "render(...): Expected the last optional `callback` argument to be a " + "function. Instead received: %s.", callback) : void 0;
          update.callback = callback;
        }

        enqueueUpdate(current, update, expirationTime);
        scheduleWork(current, expirationTime);
        return expirationTime;
      }

      function updateContainerAtExpirationTime(element, container, parentComponent, expirationTime, callback) {
        var current = container.current;
        {
          if (ReactFiberInstrumentation_1.debugTool) {
            if (current.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, element, expirationTime, callback);
      }

      function findHostInstance$1(component) {
        var fiber = get$1(component);

        if (fiber === undefined) {
          if (typeof component.render === "function") {
            invariant(false, "Unable to find node on an unmounted component.");
          } else {
            invariant(false, "Argument appears to not be a ReactComponent. Keys: %s", Object.keys(component));
          }
        }

        var hostFiber = findCurrentHostFiber(fiber);

        if (hostFiber === null) {
          return null;
        }

        return hostFiber.stateNode;
      }

      function createContainer(containerInfo, isAsync, hydrate) {
        return createFiberRoot(containerInfo, isAsync, hydrate);
      }

      function updateContainer(element, container, parentComponent, callback) {
        var current = container.current;
        var currentTime = recalculateCurrentTime();
        var expirationTime = computeExpirationForFiber(currentTime, current);
        return updateContainerAtExpirationTime(element, container, parentComponent, expirationTime, 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;
        }
      }

      function findHostInstanceWithNoPortals(fiber) {
        var hostFiber = findCurrentHostFiberWithNoPortals(fiber);

        if (hostFiber === null) {
          return null;
        }

        return hostFiber.stateNode;
      }

      function injectIntoDevTools(devToolsConfig) {
        var _findFiberByHostInstance = devToolsConfig.findFiberByHostInstance;
        return injectInternals(_extends({}, devToolsConfig, {
          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);
          }
        }));
      }

      var ReactNativeFiberRenderer = Object.freeze({
        updateContainerAtExpirationTime: updateContainerAtExpirationTime,
        createContainer: createContainer,
        updateContainer: updateContainer,
        flushRoot: flushRoot,
        requestWork: requestWork,
        computeUniqueAsyncExpiration: computeUniqueAsyncExpiration,
        batchedUpdates: batchedUpdates$1,
        unbatchedUpdates: unbatchedUpdates,
        deferredUpdates: deferredUpdates,
        syncUpdates: syncUpdates,
        interactiveUpdates: interactiveUpdates$1,
        flushInteractiveUpdates: flushInteractiveUpdates$1,
        flushControlled: flushControlled,
        flushSync: flushSync,
        getPublicRootInstance: getPublicRootInstance,
        findHostInstance: findHostInstance$1,
        findHostInstanceWithNoPortals: findHostInstanceWithNoPortals,
        injectIntoDevTools: injectIntoDevTools
      });

      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.4.1";

      var NativeMethodsMixin = function NativeMethodsMixin(findNodeHandle, findHostInstance) {
        var NativeMethodsMixin = {
          measure: function measure(callback) {
            UIManager.measure(findNodeHandle(this), mountSafeCallback(this, callback));
          },
          measureInWindow: function measureInWindow(callback) {
            UIManager.measureInWindow(findNodeHandle(this), mountSafeCallback(this, callback));
          },
          measureLayout: function measureLayout(relativeToNativeNode, onSuccess, onFail) {
            UIManager.measureLayout(findNodeHandle(this), relativeToNativeNode, mountSafeCallback(this, onFail), mountSafeCallback(this, onSuccess));
          },
          setNativeProps: function setNativeProps(nativeProps) {
            var maybeInstance = void 0;

            try {
              maybeInstance = findHostInstance(this);
            } catch (error) {}

            if (maybeInstance == null) {
              return;
            }

            var viewConfig = maybeInstance.viewConfig;
            {
              warnForStyleProps(nativeProps, viewConfig.validAttributes);
            }
            var updatePayload = create(nativeProps, viewConfig.validAttributes);

            if (updatePayload != null) {
              UIManager.updateView(maybeInstance._nativeTag, viewConfig.uiViewClassName, updatePayload);
            }
          },
          focus: function focus() {
            TextInputState.focusTextInput(findNodeHandle(this));
          },
          blur: function blur() {
            TextInputState.blurTextInput(findNodeHandle(this));
          }
        };
        {
          var NativeMethodsMixin_DEV = NativeMethodsMixin;
          invariant(!NativeMethodsMixin_DEV.componentWillMount && !NativeMethodsMixin_DEV.componentWillReceiveProps && !NativeMethodsMixin_DEV.UNSAFE_componentWillMount && !NativeMethodsMixin_DEV.UNSAFE_componentWillReceiveProps, "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() {
            TextInputState.blurTextInput(findNodeHandle(this));
          };

          ReactNativeComponent.prototype.focus = function focus() {
            TextInputState.focusTextInput(findNodeHandle(this));
          };

          ReactNativeComponent.prototype.measure = function measure(callback) {
            UIManager.measure(findNodeHandle(this), mountSafeCallback(this, callback));
          };

          ReactNativeComponent.prototype.measureInWindow = function measureInWindow(callback) {
            UIManager.measureInWindow(findNodeHandle(this), mountSafeCallback(this, callback));
          };

          ReactNativeComponent.prototype.measureLayout = function measureLayout(relativeToNativeNode, onSuccess, onFail) {
            UIManager.measureLayout(findNodeHandle(this), relativeToNativeNode, mountSafeCallback(this, onFail), mountSafeCallback(this, onSuccess));
          };

          ReactNativeComponent.prototype.setNativeProps = function setNativeProps(nativeProps) {
            var maybeInstance = void 0;

            try {
              maybeInstance = findHostInstance(this);
            } catch (error) {}

            if (maybeInstance == null) {
              return;
            }

            var viewConfig = maybeInstance.viewConfig || maybeInstance.canonical.viewConfig;
            var updatePayload = create(nativeProps, viewConfig.validAttributes);

            if (updatePayload != null) {
              UIManager.updateView(maybeInstance._nativeTag, viewConfig.uiViewClassName, updatePayload);
            }
          };

          return ReactNativeComponent;
        }(React.Component);

        return ReactNativeComponent;
      };

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

          return emptyObject;
        };

        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),
              getInspectorData: function getInspectorData(findNodeHandle) {
                return {
                  measure: function measure(callback) {
                    return 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,
              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 findHostInstance = findHostInstance$1;

      function findNodeHandle(componentOrHandle) {
        {
          var owner = ReactCurrentOwner.current;

          if (owner !== null && owner.stateNode !== null) {
            !owner.stateNode._warnedAboutRefsInRender ? warning(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) || "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 = findHostInstance(componentOrHandle);

        if (hostInstance == null) {
          return hostInstance;
        }

        if (hostInstance.canonical) {
          return hostInstance.canonical._nativeTag;
        }

        return hostInstance._nativeTag;
      }

      injection$2.injectRenderer(ReactNativeFiberRenderer);

      function computeComponentStackForErrorReporting(reactTag) {
        var fiber = getInstanceFromTag(reactTag);

        if (!fiber) {
          return "";
        }

        return getStackAddendumByWorkInProgressFiber(fiber);
      }

      var roots = new Map();
      var ReactNativeRenderer = {
        NativeComponent: ReactNativeComponent(findNodeHandle, findHostInstance),
        findNodeHandle: findNodeHandle,
        render: function render(element, containerTag, callback) {
          var root = roots.get(containerTag);

          if (!root) {
            root = createContainer(containerTag, false, 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);
          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.default : ReactNativeRenderer$3;
      module.exports = reactNativeRenderer;
    })();
  }
},262,[263,166,183,231,218,322,1,323,173,324,226,325,9,271],"node_modules/react-native/Libraries/Renderer/oss/ReactNativeRenderer-dev.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _require = _$$_REQUIRE(_dependencyMap[0], 'PolyfillFunctions'),
      polyfillObjectProperty = _require.polyfillObjectProperty,
      polyfillGlobal = _require.polyfillGlobal;

  if (global.GLOBAL === undefined) {
    global.GLOBAL = global;
  }

  if (global.window === undefined) {
    global.window = global;
  }

  var _shouldPolyfillCollection = _$$_REQUIRE(_dependencyMap[1], '_shouldPolyfillES6Collection');

  if (_shouldPolyfillCollection('Map')) {
    polyfillGlobal('Map', function () {
      return _$$_REQUIRE(_dependencyMap[2], 'Map');
    });
  }

  if (_shouldPolyfillCollection('Set')) {
    polyfillGlobal('Set', function () {
      return _$$_REQUIRE(_dependencyMap[3], 'Set');
    });
  }

  global.process = global.process || {};
  global.process.env = global.process.env || {};

  if (!global.process.env.NODE_ENV) {
    global.process.env.NODE_ENV = __DEV__ ? 'development' : 'production';
  }

  if (global.__RCTProfileIsProfiling) {
    var Systrace = _$$_REQUIRE(_dependencyMap[4], 'Systrace');

    Systrace.installReactHook();
    Systrace.setEnabled(true);
  }

  var ExceptionsManager = _$$_REQUIRE(_dependencyMap[5], '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[6], 'ErrorUtils');

    ErrorUtils.setGlobalHandler(handleError);
  }

  var ReactNativeVersionCheck = _$$_REQUIRE(_dependencyMap[7], 'ReactNativeVersionCheck');

  ReactNativeVersionCheck.checkVersions();
  polyfillGlobal('Promise', function () {
    return _$$_REQUIRE(_dependencyMap[8], 'Promise');
  });
  polyfillGlobal('regeneratorRuntime', function () {
    delete global.regeneratorRuntime;

    _$$_REQUIRE(_dependencyMap[9], 'regenerator-runtime/runtime');

    return global.regeneratorRuntime;
  });

  var defineLazyTimer = function defineLazyTimer(name) {
    polyfillGlobal(name, function () {
      return _$$_REQUIRE(_dependencyMap[10], 'JSTimers')[name];
    });
  };

  defineLazyTimer('setTimeout');
  defineLazyTimer('setInterval');
  defineLazyTimer('setImmediate');
  defineLazyTimer('clearTimeout');
  defineLazyTimer('clearInterval');
  defineLazyTimer('clearImmediate');
  defineLazyTimer('requestAnimationFrame');
  defineLazyTimer('cancelAnimationFrame');
  defineLazyTimer('requestIdleCallback');
  defineLazyTimer('cancelIdleCallback');
  polyfillGlobal('XMLHttpRequest', function () {
    return _$$_REQUIRE(_dependencyMap[11], 'XMLHttpRequest');
  });
  polyfillGlobal('FormData', function () {
    return _$$_REQUIRE(_dependencyMap[12], 'FormData');
  });
  polyfillGlobal('fetch', function () {
    return _$$_REQUIRE(_dependencyMap[13], 'fetch').fetch;
  });
  polyfillGlobal('Headers', function () {
    return _$$_REQUIRE(_dependencyMap[13], 'fetch').Headers;
  });
  polyfillGlobal('Request', function () {
    return _$$_REQUIRE(_dependencyMap[13], 'fetch').Request;
  });
  polyfillGlobal('Response', function () {
    return _$$_REQUIRE(_dependencyMap[13], 'fetch').Response;
  });
  polyfillGlobal('WebSocket', function () {
    return _$$_REQUIRE(_dependencyMap[14], 'WebSocket');
  });
  polyfillGlobal('Blob', function () {
    return _$$_REQUIRE(_dependencyMap[15], 'Blob');
  });
  polyfillGlobal('File', function () {
    return _$$_REQUIRE(_dependencyMap[16], 'File');
  });
  polyfillGlobal('FileReader', function () {
    return _$$_REQUIRE(_dependencyMap[17], 'FileReader');
  });
  polyfillGlobal('URL', function () {
    return _$$_REQUIRE(_dependencyMap[18], 'URL');
  });

  if (!global.alert) {
    global.alert = function (text) {
      _$$_REQUIRE(_dependencyMap[19], 'Alert').alert('Alert', '' + text);
    };
  }

  var navigator = global.navigator;

  if (navigator === undefined) {
    global.navigator = navigator = {};
  }

  polyfillObjectProperty(navigator, 'product', function () {
    return 'ReactNative';
  });
  polyfillObjectProperty(navigator, 'geolocation', function () {
    return _$$_REQUIRE(_dependencyMap[20], 'Geolocation');
  });

  var BatchedBridge = _$$_REQUIRE(_dependencyMap[21], 'BatchedBridge');

  BatchedBridge.registerLazyCallableModule('Systrace', function () {
    return _$$_REQUIRE(_dependencyMap[4], 'Systrace');
  });
  BatchedBridge.registerLazyCallableModule('JSTimers', function () {
    return _$$_REQUIRE(_dependencyMap[10], 'JSTimers');
  });
  BatchedBridge.registerLazyCallableModule('HeapCapture', function () {
    return _$$_REQUIRE(_dependencyMap[22], 'HeapCapture');
  });
  BatchedBridge.registerLazyCallableModule('SamplingProfiler', function () {
    return _$$_REQUIRE(_dependencyMap[23], 'SamplingProfiler');
  });
  BatchedBridge.registerLazyCallableModule('RCTLog', function () {
    return _$$_REQUIRE(_dependencyMap[24], 'RCTLog');
  });
  BatchedBridge.registerLazyCallableModule('RCTDeviceEventEmitter', function () {
    return _$$_REQUIRE(_dependencyMap[25], 'RCTDeviceEventEmitter');
  });
  BatchedBridge.registerLazyCallableModule('RCTNativeAppEventEmitter', function () {
    return _$$_REQUIRE(_dependencyMap[26], 'RCTNativeAppEventEmitter');
  });
  BatchedBridge.registerLazyCallableModule('PerformanceLogger', function () {
    return _$$_REQUIRE(_dependencyMap[27], 'PerformanceLogger');
  });
  BatchedBridge.registerLazyCallableModule('JSDevSupportModule', function () {
    return _$$_REQUIRE(_dependencyMap[28], 'JSDevSupportModule');
  });

  global.__fetchSegment = function (segmentId, options, callback) {
    var _require2 = _$$_REQUIRE(_dependencyMap[29], 'NativeModules'),
        SegmentFetcher = _require2.SegmentFetcher;

    if (!SegmentFetcher) {
      throw new Error('SegmentFetcher is missing. Please ensure that it is ' + 'included as a NativeModule.');
    }

    SegmentFetcher.fetchSegment(segmentId, options, function (errorObject) {
      if (errorObject) {
        var error = new Error(errorObject.message);
        error.code = errorObject.code;
        callback(error);
      }

      callback(null);
    });
  };

  if (__DEV__) {
    if (!global.__RCTProfileIsProfiling) {
      BatchedBridge.registerCallableModule('HMRClient', _$$_REQUIRE(_dependencyMap[30], 'HMRClient'));

      if (!window.document) {
        _$$_REQUIRE(_dependencyMap[31], 'setupDevtools');
      }

      var JSInspector = _$$_REQUIRE(_dependencyMap[32], 'JSInspector');

      JSInspector.registerAgent(_$$_REQUIRE(_dependencyMap[33], 'NetworkAgent'));
    }
  }
},263,[264,265,266,270,172,271,171,276,186,278,175,279,293,274,294,290,296,297,298,299,301,169,304,305,306,194,307,308,310,168,311,316,319,320],"node_modules/react-native/Libraries/Core/InitializeCore.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  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 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, _objectSpread({}, descriptor, {
        value: object[name]
      }));
    }

    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
  };
},264,[185],"node_modules/react-native/Libraries/Utilities/PolyfillFunctions.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function _shouldActuallyPolyfillES6Collection(collectionName) {
    var Collection = global[collectionName];

    if (Collection == null) {
      return true;
    }

    if (typeof global.Symbol !== 'function') {
      return true;
    }

    var proto = Collection.prototype;
    return Collection == null || typeof Collection !== 'function' || typeof proto.clear !== 'function' || new Collection().size !== 0 || typeof proto.keys !== 'function' || typeof proto.forEach !== 'function';
  }

  var cache = {};

  function _shouldPolyfillES6Collection(collectionName) {
    var result = cache[collectionName];

    if (result !== undefined) {
      return result;
    }

    result = _shouldActuallyPolyfillES6Collection(collectionName);
    cache[collectionName] = result;
    return result;
  }

  module.exports = _shouldPolyfillES6Collection;
},265,[],"node_modules/react-native/Libraries/vendor/core/_shouldPolyfillES6Collection.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  var _shouldPolyfillES6Collection = _$$_REQUIRE(_dependencyMap[0], '_shouldPolyfillES6Collection');

  var guid = _$$_REQUIRE(_dependencyMap[1], 'guid');

  var isNode = _$$_REQUIRE(_dependencyMap[2], 'fbjs/lib/isNode');

  var toIterator = _$$_REQUIRE(_dependencyMap[3], 'toIterator');

  module.exports = function (global, undefined) {
    if (!_shouldPolyfillES6Collection('Map')) {
      return global.Map;
    }

    var KIND_KEY = 'key';
    var KIND_VALUE = 'value';
    var KIND_KEY_VALUE = 'key+value';
    var KEY_PREFIX = '$map_';
    var SECRET_SIZE_PROP;

    if (__DEV__) {
      SECRET_SIZE_PROP = '$size' + guid();
    }

    var OLD_IE_HASH_PREFIX = 'IE_HASH_';

    var Map = function () {
      function Map(iterable) {
        _classCallCheck(this, Map);

        if (!isObject(this)) {
          throw new TypeError('Wrong map object type.');
        }

        initMap(this);

        if (iterable != null) {
          var it = toIterator(iterable);
          var next;

          while (!(next = it.next()).done) {
            if (!isObject(next.value)) {
              throw new TypeError('Expected iterable items to be pair objects.');
            }

            this.set(next.value[0], next.value[1]);
          }
        }
      }

      _createClass(Map, [{
        key: "clear",
        value: function clear() {
          initMap(this);
        }
      }, {
        key: "has",
        value: function has(key) {
          var index = getIndex(this, key);
          return !!(index != null && this._mapData[index]);
        }
      }, {
        key: "set",
        value: function set(key, value) {
          var index = getIndex(this, key);

          if (index != null && this._mapData[index]) {
            this._mapData[index][1] = value;
          } else {
            index = this._mapData.push([key, value]) - 1;
            setIndex(this, key, index);

            if (__DEV__) {
              this[SECRET_SIZE_PROP] += 1;
            } else {
              this.size += 1;
            }
          }

          return this;
        }
      }, {
        key: "get",
        value: function get(key) {
          var index = getIndex(this, key);

          if (index == null) {
            return undefined;
          } else {
            return this._mapData[index][1];
          }
        }
      }, {
        key: "delete",
        value: function _delete(key) {
          var index = getIndex(this, key);

          if (index != null && this._mapData[index]) {
            setIndex(this, key, undefined);
            this._mapData[index] = undefined;

            if (__DEV__) {
              this[SECRET_SIZE_PROP] -= 1;
            } else {
              this.size -= 1;
            }

            return true;
          } else {
            return false;
          }
        }
      }, {
        key: "entries",
        value: function entries() {
          return new MapIterator(this, KIND_KEY_VALUE);
        }
      }, {
        key: "keys",
        value: function keys() {
          return new MapIterator(this, KIND_KEY);
        }
      }, {
        key: "values",
        value: function values() {
          return new MapIterator(this, KIND_VALUE);
        }
      }, {
        key: "forEach",
        value: function forEach(callback, thisArg) {
          if (typeof callback !== 'function') {
            throw new TypeError('Callback must be callable.');
          }

          var boundCallback = callback.bind(thisArg || undefined);
          var mapData = this._mapData;

          for (var i = 0; i < mapData.length; i++) {
            var entry = mapData[i];

            if (entry != null) {
              boundCallback(entry[1], entry[0], this);
            }
          }
        }
      }]);

      return Map;
    }();

    Map.prototype[toIterator.ITERATOR_SYMBOL] = Map.prototype.entries;

    var MapIterator = function () {
      function MapIterator(map, kind) {
        _classCallCheck(this, MapIterator);

        if (!(isObject(map) && map._mapData)) {
          throw new TypeError('Object is not a map.');
        }

        if ([KIND_KEY, KIND_KEY_VALUE, KIND_VALUE].indexOf(kind) === -1) {
          throw new Error('Invalid iteration kind.');
        }

        this._map = map;
        this._nextIndex = 0;
        this._kind = kind;
      }

      _createClass(MapIterator, [{
        key: "next",
        value: function next() {
          if (!this instanceof Map) {
            throw new TypeError('Expected to be called on a MapIterator.');
          }

          var map = this._map;
          var index = this._nextIndex;
          var kind = this._kind;

          if (map == null) {
            return createIterResultObject(undefined, true);
          }

          var entries = map._mapData;

          while (index < entries.length) {
            var record = entries[index];
            index += 1;
            this._nextIndex = index;

            if (record) {
              if (kind === KIND_KEY) {
                return createIterResultObject(record[0], false);
              } else if (kind === KIND_VALUE) {
                return createIterResultObject(record[1], false);
              } else if (kind) {
                return createIterResultObject(record, false);
              }
            }
          }

          this._map = undefined;
          return createIterResultObject(undefined, true);
        }
      }]);

      return MapIterator;
    }();

    MapIterator.prototype[toIterator.ITERATOR_SYMBOL] = function () {
      return this;
    };

    function getIndex(map, key) {
      if (isObject(key)) {
        var hash = getHash(key);
        return map._objectIndex[hash];
      } else {
        var prefixedKey = KEY_PREFIX + key;

        if (typeof key === 'string') {
          return map._stringIndex[prefixedKey];
        } else {
          return map._otherIndex[prefixedKey];
        }
      }
    }

    function setIndex(map, key, index) {
      var shouldDelete = index == null;

      if (isObject(key)) {
        var hash = getHash(key);

        if (shouldDelete) {
          delete map._objectIndex[hash];
        } else {
          map._objectIndex[hash] = index;
        }
      } else {
        var prefixedKey = KEY_PREFIX + key;

        if (typeof key === 'string') {
          if (shouldDelete) {
            delete map._stringIndex[prefixedKey];
          } else {
            map._stringIndex[prefixedKey] = index;
          }
        } else {
          if (shouldDelete) {
            delete map._otherIndex[prefixedKey];
          } else {
            map._otherIndex[prefixedKey] = index;
          }
        }
      }
    }

    function initMap(map) {
      map._mapData = [];
      map._objectIndex = {};
      map._stringIndex = {};
      map._otherIndex = {};

      if (__DEV__) {
        if (isES5) {
          if (map.hasOwnProperty(SECRET_SIZE_PROP)) {
            map[SECRET_SIZE_PROP] = 0;
          } else {
            Object.defineProperty(map, SECRET_SIZE_PROP, {
              value: 0,
              writable: true
            });
            Object.defineProperty(map, 'size', {
              set: function set(v) {
                console.error('PLEASE FIX ME: You are changing the map size property which ' + 'should not be writable and will break in production.');
                throw new Error('The map size property is not writable.');
              },
              get: function get() {
                return map[SECRET_SIZE_PROP];
              }
            });
          }

          return;
        }
      }

      map.size = 0;
    }

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

    function createIterResultObject(value, done) {
      return {
        value: value,
        done: done
      };
    }

    var isES5 = function () {
      try {
        Object.defineProperty({}, 'x', {});
        return true;
      } catch (e) {
        return false;
      }
    }();

    function isExtensible(o) {
      if (!isES5) {
        return true;
      } else {
        return Object.isExtensible(o);
      }
    }

    function getIENodeHash(node) {
      var uniqueID;

      switch (node.nodeType) {
        case 1:
          uniqueID = node.uniqueID;
          break;

        case 9:
          uniqueID = node.documentElement.uniqueID;
          break;

        default:
          return null;
      }

      if (uniqueID) {
        return OLD_IE_HASH_PREFIX + uniqueID;
      } else {
        return null;
      }
    }

    var getHash = function () {
      var propIsEnumerable = Object.prototype.propertyIsEnumerable;
      var hashProperty = guid();
      var hashCounter = 0;
      return function getHash(o) {
        if (o[hashProperty]) {
          return o[hashProperty];
        } else if (!isES5 && o.propertyIsEnumerable && o.propertyIsEnumerable[hashProperty]) {
          return o.propertyIsEnumerable[hashProperty];
        } else if (!isES5 && isNode(o) && getIENodeHash(o)) {
          return getIENodeHash(o);
        } else if (!isES5 && o[hashProperty]) {
          return o[hashProperty];
        }

        if (isExtensible(o)) {
          hashCounter += 1;

          if (isES5) {
            Object.defineProperty(o, hashProperty, {
              enumerable: false,
              writable: false,
              configurable: false,
              value: hashCounter
            });
          } else if (o.propertyIsEnumerable) {
            o.propertyIsEnumerable = function () {
              return propIsEnumerable.apply(this, arguments);
            };

            o.propertyIsEnumerable[hashProperty] = hashCounter;
          } else if (isNode(o)) {
            o[hashProperty] = hashCounter;
          } else {
            throw new Error('Unable to set a non-enumerable property on object.');
          }

          return hashCounter;
        } else {
          throw new Error('Non-extensible objects are not allowed as keys.');
        }
      };
    }();

    return Map;
  }(Function('return this')());
},266,[265,267,268,269],"node_modules/react-native/Libraries/vendor/core/Map.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function guid() {
    return 'f' + (Math.random() * (1 << 30)).toString(16).replace('.', '');
  }

  module.exports = guid;
},267,[],"node_modules/react-native/Libraries/vendor/core/guid.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function isNode(object) {
    var doc = object ? object.ownerDocument || object : document;
    var defaultView = doc.defaultView || window;
    return !!(object && (typeof defaultView.Node === 'function' ? object instanceof defaultView.Node : typeof object === 'object' && typeof object.nodeType === 'number' && typeof object.nodeName === 'string'));
  }

  module.exports = isNode;
},268,[],"node_modules/react-native/node_modules/fbjs/lib/isNode.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  var KIND_KEY = 'key';
  var KIND_VALUE = 'value';
  var KIND_KEY_VAL = 'key+value';
  var ITERATOR_SYMBOL = typeof Symbol === 'function' ? typeof Symbol === "function" ? Symbol.iterator : "@@iterator" : '@@iterator';

  var toIterator = function () {
    if (!(Array.prototype[ITERATOR_SYMBOL] && String.prototype[ITERATOR_SYMBOL])) {
      return function () {
        var ArrayIterator = function () {
          function ArrayIterator(array, kind) {
            _classCallCheck(this, ArrayIterator);

            if (!Array.isArray(array)) {
              throw new TypeError('Object is not an Array');
            }

            this._iteratedObject = array;
            this._kind = kind;
            this._nextIndex = 0;
          }

          _createClass(ArrayIterator, [{
            key: "next",
            value: function next() {
              if (!this instanceof ArrayIterator) {
                throw new TypeError('Object is not an ArrayIterator');
              }

              if (this._iteratedObject == null) {
                return createIterResultObject(undefined, true);
              }

              var array = this._iteratedObject;
              var len = this._iteratedObject.length;
              var index = this._nextIndex;
              var kind = this._kind;

              if (index >= len) {
                this._iteratedObject = undefined;
                return createIterResultObject(undefined, true);
              }

              this._nextIndex = index + 1;

              if (kind === KIND_KEY) {
                return createIterResultObject(index, false);
              } else if (kind === KIND_VALUE) {
                return createIterResultObject(array[index], false);
              } else if (kind === KIND_KEY_VAL) {
                return createIterResultObject([index, array[index]], false);
              }
            }
          }, {
            key: '@@iterator',
            value: function iterator() {
              return this;
            }
          }]);

          return ArrayIterator;
        }();

        var StringIterator = function () {
          function StringIterator(string) {
            _classCallCheck(this, StringIterator);

            if (typeof string !== 'string') {
              throw new TypeError('Object is not a string');
            }

            this._iteratedString = string;
            this._nextIndex = 0;
          }

          _createClass(StringIterator, [{
            key: "next",
            value: function next() {
              if (!this instanceof StringIterator) {
                throw new TypeError('Object is not a StringIterator');
              }

              if (this._iteratedString == null) {
                return createIterResultObject(undefined, true);
              }

              var index = this._nextIndex;
              var s = this._iteratedString;
              var len = s.length;

              if (index >= len) {
                this._iteratedString = undefined;
                return createIterResultObject(undefined, true);
              }

              var ret;
              var first = s.charCodeAt(index);

              if (first < 0xd800 || first > 0xdbff || index + 1 === len) {
                ret = s[index];
              } else {
                var second = s.charCodeAt(index + 1);

                if (second < 0xdc00 || second > 0xdfff) {
                  ret = s[index];
                } else {
                  ret = s[index] + s[index + 1];
                }
              }

              this._nextIndex = index + ret.length;
              return createIterResultObject(ret, false);
            }
          }, {
            key: '@@iterator',
            value: function iterator() {
              return this;
            }
          }]);

          return StringIterator;
        }();

        function createIterResultObject(value, done) {
          return {
            value: value,
            done: done
          };
        }

        return function (object, kind) {
          if (typeof object === 'string') {
            return new StringIterator(object);
          } else if (Array.isArray(object)) {
            return new ArrayIterator(object, kind || KIND_VALUE);
          } else {
            return object[ITERATOR_SYMBOL]();
          }
        };
      }();
    } else {
      return function (object) {
        return object[ITERATOR_SYMBOL]();
      };
    }
  }();

  _extends(toIterator, {
    KIND_KEY: KIND_KEY,
    KIND_VALUE: KIND_VALUE,
    KIND_KEY_VAL: KIND_KEY_VAL,
    ITERATOR_SYMBOL: ITERATOR_SYMBOL
  });

  module.exports = toIterator;
},269,[],"node_modules/react-native/Libraries/vendor/core/toIterator.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  var Map = _$$_REQUIRE(_dependencyMap[0], 'Map');

  var _shouldPolyfillES6Collection = _$$_REQUIRE(_dependencyMap[1], '_shouldPolyfillES6Collection');

  var toIterator = _$$_REQUIRE(_dependencyMap[2], 'toIterator');

  module.exports = function (global) {
    if (!_shouldPolyfillES6Collection('Set')) {
      return global.Set;
    }

    var Set = function () {
      function Set(iterable) {
        _classCallCheck(this, Set);

        if (this == null || typeof this !== 'object' && typeof this !== 'function') {
          throw new TypeError('Wrong set object type.');
        }

        initSet(this);

        if (iterable != null) {
          var it = toIterator(iterable);
          var next;

          while (!(next = it.next()).done) {
            this.add(next.value);
          }
        }
      }

      _createClass(Set, [{
        key: "add",
        value: function add(value) {
          this._map.set(value, value);

          this.size = this._map.size;
          return this;
        }
      }, {
        key: "clear",
        value: function clear() {
          initSet(this);
        }
      }, {
        key: "delete",
        value: function _delete(value) {
          var ret = this._map.delete(value);

          this.size = this._map.size;
          return ret;
        }
      }, {
        key: "entries",
        value: function entries() {
          return this._map.entries();
        }
      }, {
        key: "forEach",
        value: function forEach(callback) {
          var thisArg = arguments[1];

          var it = this._map.keys();

          var next;

          while (!(next = it.next()).done) {
            callback.call(thisArg, next.value, next.value, this);
          }
        }
      }, {
        key: "has",
        value: function has(value) {
          return this._map.has(value);
        }
      }, {
        key: "values",
        value: function values() {
          return this._map.values();
        }
      }]);

      return Set;
    }();

    Set.prototype[toIterator.ITERATOR_SYMBOL] = Set.prototype.values;
    Set.prototype.keys = Set.prototype.values;

    function initSet(set) {
      set._map = new Map();
      set.size = set._map.size;
    }

    return Set;
  }(Function('return this')());
},270,[266,265,269],"node_modules/react-native/Libraries/vendor/core/Set.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var exceptionID = 0;

  function reportException(e, isFatal) {
    var _require = _$$_REQUIRE(_dependencyMap[0], 'NativeModules'),
        ExceptionsManager = _require.ExceptionsManager;

    if (ExceptionsManager) {
      var parseErrorStack = _$$_REQUIRE(_dependencyMap[1], 'parseErrorStack');

      var stack = parseErrorStack(e);
      var currentExceptionID = ++exceptionID;

      if (isFatal) {
        ExceptionsManager.reportFatalException(e.message, stack, currentExceptionID);
      } else {
        ExceptionsManager.reportSoftException(e.message, stack, currentExceptionID);
      }

      if (__DEV__) {
        var symbolicateStackTrace = _$$_REQUIRE(_dependencyMap[2], 'symbolicateStackTrace');

        symbolicateStackTrace(stack).then(function (prettyStack) {
          if (prettyStack) {
            ExceptionsManager.updateExceptionMessage(e.message, prettyStack, currentExceptionID);
          } else {
            throw new Error('The stack is null');
          }
        }).catch(function (error) {
          return console.warn('Unable to symbolicate stack trace: ' + error.message);
        });
      }
    }
  }

  function handleException(e, isFatal) {
    if (!e.message) {
      e = new Error(e);
    }

    if (console._errorOriginal) {
      console._errorOriginal(e.message);
    } else {
      console.error(e.message);
    }

    reportException(e, isFatal);
  }

  function reactConsoleErrorHandler() {
    console._errorOriginal.apply(console, arguments);

    if (!console.reportErrorsAsExceptions) {
      return;
    }

    if (arguments[0] && arguments[0].stack) {
      reportException(arguments[0], false);
    } else {
      var stringifySafe = _$$_REQUIRE(_dependencyMap[3], 'stringifySafe');

      var str = Array.prototype.map.call(arguments, stringifySafe).join(', ');

      if (str.slice(0, 10) === '"Warning: ') {
        return;
      }

      var error = new Error('console.error: ' + str);
      error.framesToPop = 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
  };
},271,[168,180,272,174],"node_modules/react-native/Libraries/Core/ExceptionsManager.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  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 getDevServer = _$$_REQUIRE(_dependencyMap[0], 'getDevServer');

  var _require = _$$_REQUIRE(_dependencyMap[1], 'NativeModules'),
      SourceCode = _require.SourceCode;

  var fetch;

  function isSourcedFromDisk(sourcePath) {
    return !/^http/.test(sourcePath) && /[\\/]/.test(sourcePath);
  }

  function symbolicateStackTrace(stack) {
    var devServer, stackCopy, foundInternalSource, response, json;
    return regeneratorRuntime.async(function symbolicateStackTrace$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            if (!fetch) {
              fetch = global.fetch || _$$_REQUIRE(_dependencyMap[2], '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;

            if (SourceCode.scriptURL) {
              foundInternalSource = false;
              stackCopy = stack.map(function (frame) {
                if (!foundInternalSource && isSourcedFromDisk(frame.file)) {
                  return _objectSpread({}, frame, {
                    file: SourceCode.scriptURL
                  });
                }

                foundInternalSource = true;
                return frame;
              });
            }

            _context.next = 8;
            return regeneratorRuntime.awrap(fetch(devServer.url + 'symbolicate', {
              method: 'POST',
              body: JSON.stringify({
                stack: stackCopy
              })
            }));

          case 8:
            response = _context.sent;
            _context.next = 11;
            return regeneratorRuntime.awrap(response.json());

          case 11:
            json = _context.sent;
            return _context.abrupt("return", json.stack);

          case 13:
          case "end":
            return _context.stop();
        }
      }
    }, null, this);
  }

  module.exports = symbolicateStackTrace;
},272,[273,168,274],"node_modules/react-native/Libraries/Core/Devtools/symbolicateStackTrace.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _require = _$$_REQUIRE(_dependencyMap[0], 'NativeModules'),
      SourceCode = _require.SourceCode;

  var _cachedDevServerURL;

  var FALLBACK = 'http://localhost:8081/';

  function getDevServer() {
    if (_cachedDevServerURL === undefined) {
      var match = SourceCode && SourceCode.scriptURL && SourceCode.scriptURL.match(/^https?:\/\/.*?\//);
      _cachedDevServerURL = match ? match[0] : null;
    }

    return {
      url: _cachedDevServerURL || FALLBACK,
      bundleLoadedFromServer: _cachedDevServerURL !== null
    };
  }

  module.exports = getDevServer;
},273,[168],"node_modules/react-native/Libraries/Core/Devtools/getDevServer.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var whatwg = _$$_REQUIRE(_dependencyMap[0], 'whatwg-fetch');

  if (whatwg && whatwg.fetch) {
    module.exports = whatwg;
  } else {
    module.exports = {
      fetch: fetch,
      Headers: Headers,
      Request: Request,
      Response: Response
    };
  }
},274,[275],"node_modules/react-native/Libraries/Network/fetch.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  (function (self) {
    'use strict';

    if (self.fetch) {
      return;
    }

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

    if (support.arrayBuffer) {
      var viewClasses = ['[object Int8Array]', '[object Uint8Array]', '[object Uint8ClampedArray]', '[object Int16Array]', '[object Uint16Array]', '[object Int32Array]', '[object Uint32Array]', '[object Float32Array]', '[object Float64Array]'];

      var isDataView = function isDataView(obj) {
        return obj && DataView.prototype.isPrototypeOf(obj);
      };

      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 {
          throw new Error('unsupported BodyInit type');
        }

        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;

        if (!body && input._bodyInit != null) {
          body = input._bodyInit;
          input.bodyUsed = true;
        }
      } else {
        this.url = String(input);
      }

      this.credentials = options.credentials || this.credentials || 'omit';

      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.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
        }
      });
    };

    self.Headers = Headers;
    self.Request = Request;
    self.Response = Response;

    self.fetch = function (input, init) {
      return new Promise(function (resolve, reject) {
        var request = new Request(input, init);
        var xhr = new XMLHttpRequest();

        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.open(request.method, request.url, true);

        if (request.credentials === 'include') {
          xhr.withCredentials = true;
        } else if (request.credentials === 'omit') {
          xhr.withCredentials = false;
        }

        request.headers.forEach(function (value, name) {
          xhr.setRequestHeader(name, value);
        });
        xhr.send(typeof request._bodyInit === 'undefined' ? null : request._bodyInit);
      });
    };

    self.fetch.polyfill = true;
  })(typeof self !== 'undefined' ? self : this);
},275,[],"node_modules/react-native/Libraries/vendor/core/whatwg-fetch.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _require = _$$_REQUIRE(_dependencyMap[0], 'NativeModules'),
      PlatformConstants = _require.PlatformConstants;

  var ReactNativeVersion = _$$_REQUIRE(_dependencyMap[1], 'ReactNativeVersion');

  exports.checkVersions = function checkVersions() {
    if (!PlatformConstants) {
      return;
    }

    var nativeVersion = PlatformConstants.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 !== null ? "-" + version.prerelease : '');
  }
},276,[168,277],"node_modules/react-native/Libraries/Core/ReactNativeVersionCheck.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  exports.version = {
    major: 0,
    minor: 56,
    patch: 0,
    prerelease: null
  };
},277,[],"node_modules/react-native/Libraries/Core/ReactNativeVersion.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  !function (global) {
    "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";
    var inModule = typeof module === "object";
    var runtime = global.regeneratorRuntime;

    if (runtime) {
      if (inModule) {
        module.exports = runtime;
      }

      return;
    }

    runtime = global.regeneratorRuntime = inModule ? module.exports : {};

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

    runtime.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);
        };
      });
    }

    runtime.isGeneratorFunction = function (genFun) {
      var ctor = typeof genFun === "function" && genFun.constructor;
      return ctor ? ctor === GeneratorFunction || (ctor.displayName || ctor.name) === "GeneratorFunction" : false;
    };

    runtime.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;
    };

    runtime.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);
          }, 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;
    };

    runtime.AsyncIterator = AsyncIterator;

    runtime.async = function (innerFn, outerFn, self, tryLocsList) {
      var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList));
      return runtime.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);
    }

    runtime.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
      };
    }

    runtime.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;
      }
    };
  }(function () {
    return this;
  }() || Function("return this")());
},278,[],"node_modules/regenerator-runtime/runtime.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }

  function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); }

  function _iterableToArray(iter) { if ((typeof Symbol === "function" ? Symbol.iterator : "@@iterator") in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); }

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

  function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _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); }

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

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

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

  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 _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var EventTarget = _$$_REQUIRE(_dependencyMap[0], 'event-target-shim');

  var RCTNetworking = _$$_REQUIRE(_dependencyMap[1], 'RCTNetworking');

  var base64 = _$$_REQUIRE(_dependencyMap[2], 'base64-js');

  var invariant = _$$_REQUIRE(_dependencyMap[3], 'fbjs/lib/invariant');

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

  var BlobManager = _$$_REQUIRE(_dependencyMap[5], 'BlobManager');

  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 (_EventTarget) {
    function XMLHttpRequestEventTarget() {
      _classCallCheck(this, XMLHttpRequestEventTarget);

      return _possibleConstructorReturn(this, _getPrototypeOf(XMLHttpRequestEventTarget).apply(this, arguments));
    }

    _inherits(XMLHttpRequestEventTarget, _EventTarget);

    return XMLHttpRequestEventTarget;
  }(EventTarget.apply(void 0, REQUEST_EVENTS));

  var XMLHttpRequest = function (_EventTarget2) {
    _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 {
              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;
      }
    }]);

    _inherits(XMLHttpRequest, _EventTarget2);

    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;
},279,[280,284,289,166,183,291],"node_modules/react-native/Libraries/Network/XMLHttpRequest.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  "use strict";

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

  var CustomEventTarget = _$$_REQUIRE(_dependencyMap[1], "./custom-event-target");

  var EventWrapper = _$$_REQUIRE(_dependencyMap[2], "./event-wrapper");

  var LISTENERS = Commons.LISTENERS;
  var CAPTURE = Commons.CAPTURE;
  var BUBBLE = Commons.BUBBLE;
  var ATTRIBUTE = Commons.ATTRIBUTE;
  var newNode = Commons.newNode;
  var defineCustomEventTarget = CustomEventTarget.defineCustomEventTarget;
  var createEventWrapper = EventWrapper.createEventWrapper;
  var STOP_IMMEDIATE_PROPAGATION_FLAG = EventWrapper.STOP_IMMEDIATE_PROPAGATION_FLAG;
  var HAS_EVENTTARGET_INTERFACE = typeof window !== "undefined" && typeof window.EventTarget !== "undefined";

  var EventTarget = module.exports = function EventTarget() {
    if (this instanceof EventTarget) {
      Object.defineProperty(this, LISTENERS, {
        value: Object.create(null)
      });
    } else if (arguments.length === 1 && Array.isArray(arguments[0])) {
      return defineCustomEventTarget(EventTarget, arguments[0]);
    } else if (arguments.length > 0) {
      var types = Array(arguments.length);

      for (var i = 0; i < arguments.length; ++i) {
        types[i] = arguments[i];
      }

      return defineCustomEventTarget(EventTarget, types);
    } else {
      throw new TypeError("Cannot call a class as a function");
    }
  };

  EventTarget.prototype = Object.create((HAS_EVENTTARGET_INTERFACE ? window.EventTarget : Object).prototype, {
    constructor: {
      value: EventTarget,
      writable: true,
      configurable: true
    },
    addEventListener: {
      value: function addEventListener(type, listener, capture) {
        if (listener == null) {
          return false;
        }

        if (typeof listener !== "function" && typeof listener !== "object") {
          throw new TypeError("\"listener\" is not an object.");
        }

        var kind = capture ? CAPTURE : BUBBLE;
        var node = this[LISTENERS][type];

        if (node == null) {
          this[LISTENERS][type] = newNode(listener, kind);
          return true;
        }

        var prev = null;

        while (node != null) {
          if (node.listener === listener && node.kind === kind) {
            return false;
          }

          prev = node;
          node = node.next;
        }

        prev.next = newNode(listener, kind);
        return true;
      },
      configurable: true,
      writable: true
    },
    removeEventListener: {
      value: function removeEventListener(type, listener, capture) {
        if (listener == null) {
          return false;
        }

        var kind = capture ? CAPTURE : BUBBLE;
        var prev = null;
        var node = this[LISTENERS][type];

        while (node != null) {
          if (node.listener === listener && node.kind === kind) {
            if (prev == null) {
              this[LISTENERS][type] = node.next;
            } else {
              prev.next = node.next;
            }

            return true;
          }

          prev = node;
          node = node.next;
        }

        return false;
      },
      configurable: true,
      writable: true
    },
    dispatchEvent: {
      value: function dispatchEvent(event) {
        var node = this[LISTENERS][event.type];

        if (node == null) {
          return true;
        }

        var wrapped = createEventWrapper(event, this);

        while (node != null) {
          if (typeof node.listener === "function") {
            node.listener.call(this, wrapped);
          } else if (node.kind !== ATTRIBUTE && typeof node.listener.handleEvent === "function") {
            node.listener.handleEvent(wrapped);
          }

          if (wrapped[STOP_IMMEDIATE_PROPAGATION_FLAG]) {
            break;
          }

          node = node.next;
        }

        return !wrapped.defaultPrevented;
      },
      configurable: true,
      writable: true
    }
  });
},280,[281,282,283],"node_modules/event-target-shim/lib/event-target.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  "use strict";

  var createUniqueKey = exports.createUniqueKey = typeof Symbol !== "undefined" ? Symbol : function createUniqueKey(name) {
    return "[[" + name + "_" + Math.random().toFixed(8).slice(2) + "]]";
  };
  exports.LISTENERS = createUniqueKey("listeners");
  exports.CAPTURE = 1;
  exports.BUBBLE = 2;
  exports.ATTRIBUTE = 3;

  exports.newNode = function newNode(listener, kind) {
    return {
      listener: listener,
      kind: kind,
      next: null
    };
  };
},281,[],"node_modules/event-target-shim/lib/commons.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  "use strict";

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

  var LISTENERS = Commons.LISTENERS;
  var ATTRIBUTE = Commons.ATTRIBUTE;
  var newNode = Commons.newNode;

  function getAttributeListener(eventTarget, type) {
    var node = eventTarget[LISTENERS][type];

    while (node != null) {
      if (node.kind === ATTRIBUTE) {
        return node.listener;
      }

      node = node.next;
    }

    return null;
  }

  function setAttributeListener(eventTarget, type, listener) {
    if (typeof listener !== "function" && typeof listener !== "object") {
      listener = null;
    }

    var prev = null;
    var node = eventTarget[LISTENERS][type];

    while (node != null) {
      if (node.kind === ATTRIBUTE) {
        if (prev == null) {
          eventTarget[LISTENERS][type] = node.next;
        } else {
          prev.next = node.next;
        }
      } else {
        prev = node;
      }

      node = node.next;
    }

    if (listener != null) {
      if (prev == null) {
        eventTarget[LISTENERS][type] = newNode(listener, ATTRIBUTE);
      } else {
        prev.next = newNode(listener, ATTRIBUTE);
      }
    }
  }

  exports.defineCustomEventTarget = function (EventTargetBase, types) {
    function EventTarget() {
      EventTargetBase.call(this);
    }

    var descripter = {
      constructor: {
        value: EventTarget,
        configurable: true,
        writable: true
      }
    };
    types.forEach(function (type) {
      descripter["on" + type] = {
        get: function get() {
          return getAttributeListener(this, type);
        },
        set: function set(listener) {
          setAttributeListener(this, type, listener);
        },
        configurable: true,
        enumerable: true
      };
    });
    EventTarget.prototype = Object.create(EventTargetBase.prototype, descripter);
    return EventTarget;
  };
},282,[281],"node_modules/event-target-shim/lib/custom-event-target.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  "use strict";

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

  var STOP_IMMEDIATE_PROPAGATION_FLAG = createUniqueKey("stop_immediate_propagation_flag");
  var CANCELED_FLAG = createUniqueKey("canceled_flag");
  var ORIGINAL_EVENT = createUniqueKey("original_event");
  var wrapperPrototypeDefinition = Object.freeze({
    stopPropagation: Object.freeze({
      value: function stopPropagation() {
        var e = this[ORIGINAL_EVENT];

        if (typeof e.stopPropagation === "function") {
          e.stopPropagation();
        }
      },
      writable: true,
      configurable: true
    }),
    stopImmediatePropagation: Object.freeze({
      value: function stopImmediatePropagation() {
        this[STOP_IMMEDIATE_PROPAGATION_FLAG] = true;
        var e = this[ORIGINAL_EVENT];

        if (typeof e.stopImmediatePropagation === "function") {
          e.stopImmediatePropagation();
        }
      },
      writable: true,
      configurable: true
    }),
    preventDefault: Object.freeze({
      value: function preventDefault() {
        if (this.cancelable === true) {
          this[CANCELED_FLAG] = true;
        }

        var e = this[ORIGINAL_EVENT];

        if (typeof e.preventDefault === "function") {
          e.preventDefault();
        }
      },
      writable: true,
      configurable: true
    }),
    defaultPrevented: Object.freeze({
      get: function defaultPrevented() {
        return this[CANCELED_FLAG];
      },
      enumerable: true,
      configurable: true
    })
  });
  exports.STOP_IMMEDIATE_PROPAGATION_FLAG = STOP_IMMEDIATE_PROPAGATION_FLAG;

  exports.createEventWrapper = function createEventWrapper(event, eventTarget) {
    var timeStamp = typeof event.timeStamp === "number" ? event.timeStamp : Date.now();
    var propertyDefinition = {
      type: {
        value: event.type,
        enumerable: true
      },
      target: {
        value: eventTarget,
        enumerable: true
      },
      currentTarget: {
        value: eventTarget,
        enumerable: true
      },
      eventPhase: {
        value: 2,
        enumerable: true
      },
      bubbles: {
        value: Boolean(event.bubbles),
        enumerable: true
      },
      cancelable: {
        value: Boolean(event.cancelable),
        enumerable: true
      },
      timeStamp: {
        value: timeStamp,
        enumerable: true
      },
      isTrusted: {
        value: false,
        enumerable: true
      }
    };
    propertyDefinition[STOP_IMMEDIATE_PROPAGATION_FLAG] = {
      value: false,
      writable: true
    };
    propertyDefinition[CANCELED_FLAG] = {
      value: false,
      writable: true
    };
    propertyDefinition[ORIGINAL_EVENT] = {
      value: event
    };

    if (typeof event.detail !== "undefined") {
      propertyDefinition.detail = {
        value: event.detail,
        enumerable: true
      };
    }

    return Object.create(Object.create(event, wrapperPrototypeDefinition), propertyDefinition);
  };
},283,[281],"node_modules/event-target-shim/lib/event-wrapper.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

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

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var MissingNativeEventEmitterShim = _$$_REQUIRE(_dependencyMap[0], 'MissingNativeEventEmitterShim');

  var NativeEventEmitter = _$$_REQUIRE(_dependencyMap[1], 'NativeEventEmitter');

  var RCTNetworkingNative = _$$_REQUIRE(_dependencyMap[2], 'NativeModules').Networking;

  var convertRequestBody = _$$_REQUIRE(_dependencyMap[3], 'convertRequestBody');

  var RCTNetworking = function (_NativeEventEmitter) {
    function RCTNetworking() {
      var _this;

      _classCallCheck(this, RCTNetworking);

      _this = _possibleConstructorReturn(this, _getPrototypeOf(RCTNetworking).call(this, RCTNetworkingNative));
      _this.isAvailable = true;
      return _this;
    }

    _createClass(RCTNetworking, [{
      key: "sendRequest",
      value: function sendRequest(method, trackingName, url, headers, data, responseType, incrementalUpdates, timeout, callback, withCredentials) {
        var body = convertRequestBody(data);
        RCTNetworkingNative.sendRequest({
          method: method,
          url: url,
          data: _objectSpread({}, body, {
            trackingName: trackingName
          }),
          headers: headers,
          responseType: responseType,
          incrementalUpdates: incrementalUpdates,
          timeout: timeout,
          withCredentials: withCredentials
        }, callback);
      }
    }, {
      key: "abortRequest",
      value: function abortRequest(requestId) {
        RCTNetworkingNative.abortRequest(requestId);
      }
    }, {
      key: "clearCookies",
      value: function clearCookies(callback) {
        RCTNetworkingNative.clearCookies(callback);
      }
    }]);

    _inherits(RCTNetworking, _NativeEventEmitter);

    return RCTNetworking;
  }(NativeEventEmitter);

  if (__DEV__ && !RCTNetworkingNative) {
    var MissingNativeRCTNetworkingShim = function (_MissingNativeEventEm) {
      function MissingNativeRCTNetworkingShim() {
        _classCallCheck(this, MissingNativeRCTNetworkingShim);

        return _possibleConstructorReturn(this, _getPrototypeOf(MissingNativeRCTNetworkingShim).call(this, 'RCTNetworking', 'Networking'));
      }

      _createClass(MissingNativeRCTNetworkingShim, [{
        key: "sendRequest",
        value: function sendRequest() {
          this.throwMissingNativeModule();
        }
      }, {
        key: "abortRequest",
        value: function abortRequest() {
          this.throwMissingNativeModule();
        }
      }, {
        key: "clearCookies",
        value: function clearCookies() {
          this.throwMissingNativeModule();
        }
      }]);

      _inherits(MissingNativeRCTNetworkingShim, _MissingNativeEventEm);

      return MissingNativeRCTNetworkingShim;
    }(MissingNativeEventEmitterShim);

    RCTNetworking = new MissingNativeRCTNetworkingShim();
  } else {
    RCTNetworking = new RCTNetworking();
  }

  module.exports = RCTNetworking;
},284,[285,286,168,287],"node_modules/react-native/Libraries/Network/RCTNetworking.ios.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var EmitterSubscription = _$$_REQUIRE(_dependencyMap[0], 'EmitterSubscription');

  var EventEmitter = _$$_REQUIRE(_dependencyMap[1], 'EventEmitter');

  var invariant = _$$_REQUIRE(_dependencyMap[2], 'fbjs/lib/invariant');

  var MissingNativeEventEmitterShim = function (_EventEmitter) {
    function MissingNativeEventEmitterShim(nativeModuleName, nativeEventEmitterName) {
      var _this;

      _classCallCheck(this, MissingNativeEventEmitterShim);

      _this = _possibleConstructorReturn(this, _getPrototypeOf(MissingNativeEventEmitterShim).call(this, null));
      _this.isAvailable = false;
      _this._nativeModuleName = nativeModuleName;
      _this._nativeEventEmitterName = nativeEventEmitterName;
      return _this;
    }

    _createClass(MissingNativeEventEmitterShim, [{
      key: "throwMissingNativeModule",
      value: function throwMissingNativeModule() {
        invariant(false, "Cannot use '" + this._nativeEventEmitterName + "' module when " + ("native '" + this._nativeModuleName + "' is not included in the build. ") + ("Either include it, or check '" + this._nativeEventEmitterName + "'.isAvailable ") + 'before calling any methods.');
      }
    }, {
      key: "addListener",
      value: function addListener(eventType, listener, context) {
        this.throwMissingNativeModule();
      }
    }, {
      key: "removeAllListeners",
      value: function removeAllListeners(eventType) {
        this.throwMissingNativeModule();
      }
    }, {
      key: "removeSubscription",
      value: function removeSubscription(subscription) {
        this.throwMissingNativeModule();
      }
    }]);

    _inherits(MissingNativeEventEmitterShim, _EventEmitter);

    return MissingNativeEventEmitterShim;
  }(EventEmitter);

  module.exports = MissingNativeEventEmitterShim;
},285,[196,195,166],"node_modules/react-native/Libraries/EventEmitter/MissingNativeEventEmitterShim.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _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); }

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

  function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var EventEmitter = _$$_REQUIRE(_dependencyMap[0], 'EventEmitter');

  var Platform = _$$_REQUIRE(_dependencyMap[1], 'Platform');

  var RCTDeviceEventEmitter = _$$_REQUIRE(_dependencyMap[2], 'RCTDeviceEventEmitter');

  var invariant = _$$_REQUIRE(_dependencyMap[3], 'fbjs/lib/invariant');

  var NativeEventEmitter = function (_EventEmitter) {
    function NativeEventEmitter(nativeModule) {
      var _this;

      _classCallCheck(this, NativeEventEmitter);

      _this = _possibleConstructorReturn(this, _getPrototypeOf(NativeEventEmitter).call(this, RCTDeviceEventEmitter.sharedSubscriber));

      if (Platform.OS === '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);
      }
    }]);

    _inherits(NativeEventEmitter, _EventEmitter);

    return NativeEventEmitter;
  }(EventEmitter);

  module.exports = NativeEventEmitter;
},286,[195,176,194,166],"node_modules/react-native/Libraries/EventEmitter/NativeEventEmitter.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var binaryToBase64 = _$$_REQUIRE(_dependencyMap[0], 'binaryToBase64');

  var Blob = _$$_REQUIRE(_dependencyMap[1], '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;
},287,[288,290,293],"node_modules/react-native/Libraries/Network/convertRequestBody.js");
__d(function (global, _$$_REQUIRE, 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;
},288,[289],"node_modules/react-native/Libraries/Utilities/binaryToBase64.js");
__d(function (global, _$$_REQUIRE, 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;

    for (var 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('');
  }
},289,[],"node_modules/base64-js/index.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  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[0], 'BlobManager');

      this.data = BlobManager.createFromParts(parts, options).data;
    }

    _createClass(Blob, [{
      key: "slice",
      value: function slice(start, end) {
        var BlobManager = _$$_REQUIRE(_dependencyMap[0], '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[0], '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;
},290,[291],"node_modules/react-native/Libraries/Blob/Blob.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  var Blob = _$$_REQUIRE(_dependencyMap[0], 'Blob');

  var BlobRegistry = _$$_REQUIRE(_dependencyMap[1], 'BlobRegistry');

  var _require = _$$_REQUIRE(_dependencyMap[2], 'NativeModules'),
      BlobModule = _require.BlobModule;

  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);
    });
  }

  var BlobManager = function () {
    function BlobManager() {
      _classCallCheck(this, BlobManager);
    }

    _createClass(BlobManager, null, [{
      key: "createFromParts",
      value: function createFromParts(parts, options) {
        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);
        BlobModule.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 _extends(Object.create(Blob.prototype), {
          data: options
        });
      }
    }, {
      key: "release",
      value: function release(blobId) {
        BlobRegistry.unregister(blobId);

        if (BlobRegistry.has(blobId)) {
          return;
        }

        BlobModule.release(blobId);
      }
    }, {
      key: "addNetworkingHandler",
      value: function addNetworkingHandler() {
        BlobModule.addNetworkingHandler();
      }
    }, {
      key: "addWebSocketHandler",
      value: function addWebSocketHandler(socketId) {
        BlobModule.addWebSocketHandler(socketId);
      }
    }, {
      key: "removeWebSocketHandler",
      value: function removeWebSocketHandler(socketId) {
        BlobModule.removeWebSocketHandler(socketId);
      }
    }, {
      key: "sendOverSocket",
      value: function sendOverSocket(blob, socketId) {
        BlobModule.sendOverSocket(blob.data, socketId);
      }
    }]);

    return BlobManager;
  }();

  BlobManager.isAvailable = !!BlobModule;
  module.exports = BlobManager;
},291,[290,292,168],"node_modules/react-native/Libraries/Blob/BlobManager.js");
__d(function (global, _$$_REQUIRE, 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
  };
},292,[],"node_modules/react-native/Libraries/Blob/BlobRegistry.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

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

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

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  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;
},293,[],"node_modules/react-native/Libraries/Network/FormData.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function _objectWithoutProperties(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]; } 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; }

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var Blob = _$$_REQUIRE(_dependencyMap[0], 'Blob');

  var EventTarget = _$$_REQUIRE(_dependencyMap[1], 'event-target-shim');

  var NativeEventEmitter = _$$_REQUIRE(_dependencyMap[2], 'NativeEventEmitter');

  var BlobManager = _$$_REQUIRE(_dependencyMap[3], 'BlobManager');

  var NativeModules = _$$_REQUIRE(_dependencyMap[4], 'NativeModules');

  var Platform = _$$_REQUIRE(_dependencyMap[5], 'Platform');

  var WebSocketEvent = _$$_REQUIRE(_dependencyMap[6], 'WebSocketEvent');

  var base64 = _$$_REQUIRE(_dependencyMap[7], 'base64-js');

  var binaryToBase64 = _$$_REQUIRE(_dependencyMap[8], 'binaryToBase64');

  var invariant = _$$_REQUIRE(_dependencyMap[9], 'fbjs/lib/invariant');

  var WebSocketModule = NativeModules.WebSocketModule;
  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 (_EventTarget) {
    function WebSocket(url, protocols, options) {
      var _this;

      _classCallCheck(this, WebSocket);

      _this = _possibleConstructorReturn(this, _getPrototypeOf(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 _ref = options || {},
          _ref$headers = _ref.headers,
          headers = _ref$headers === void 0 ? {} : _ref$headers,
          unrecognized = _objectWithoutProperties(_ref, ["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;
      }

      if (!WebSocket.isAvailable) {
        throw new Error('Cannot initialize WebSocket module. ' + 'Native module WebSocketModule is missing.');
      }

      _this._eventEmitter = new NativeEventEmitter(WebSocketModule);
      _this._socketId = nextWebSocketId++;

      _this._registerEvents();

      WebSocketModule.connect(url, protocols, {
        headers: headers
      }, _this._socketId);
      return _this;
    }

    _createClass(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') {
          WebSocketModule.send(data, this._socketId);
          return;
        }

        if (data instanceof ArrayBuffer || ArrayBuffer.isView(data)) {
          WebSocketModule.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');
        }

        WebSocketModule.ping(this._socketId);
      }
    }, {
      key: "_close",
      value: function _close(code, reason) {
        if (Platform.OS === 'android') {
          var statusCode = typeof code === 'number' ? code : CLOSE_NORMAL;
          var closeReason = typeof reason === 'string' ? reason : '';
          WebSocketModule.close(statusCode, closeReason, this._socketId);
        } else {
          WebSocketModule.close(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.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;
      }
    }]);

    _inherits(WebSocket, _EventTarget);

    return WebSocket;
  }(EventTarget.apply(void 0, WEBSOCKET_EVENTS));

  WebSocket.CONNECTING = CONNECTING;
  WebSocket.OPEN = OPEN;
  WebSocket.CLOSING = CLOSING;
  WebSocket.CLOSED = CLOSED;
  WebSocket.isAvailable = !!WebSocketModule;
  module.exports = WebSocket;
},294,[290,280,286,291,168,176,295,289,288,166],"node_modules/react-native/Libraries/WebSocket/WebSocket.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

  var WebSocketEvent = function WebSocketEvent(type, eventInitDict) {
    _classCallCheck(this, WebSocketEvent);

    this.type = type.toString();

    _extends(this, eventInitDict);
  };

  module.exports = WebSocketEvent;
},295,[],"node_modules/react-native/Libraries/WebSocket/WebSocketEvent.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var Blob = _$$_REQUIRE(_dependencyMap[0], 'Blob');

  var invariant = _$$_REQUIRE(_dependencyMap[1], 'fbjs/lib/invariant');

  var File = function (_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;
      }
    }]);

    _inherits(File, _Blob);

    return File;
  }(Blob);

  module.exports = File;
},296,[290,166],"node_modules/react-native/Libraries/Blob/File.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var EventTarget = _$$_REQUIRE(_dependencyMap[0], 'event-target-shim');

  var Blob = _$$_REQUIRE(_dependencyMap[1], 'Blob');

  var _require = _$$_REQUIRE(_dependencyMap[2], 'NativeModules'),
      FileReaderModule = _require.FileReaderModule;

  var READER_EVENTS = ['abort', 'error', 'load', 'loadstart', 'loadend', 'progress'];
  var EMPTY = 0;
  var LOADING = 1;
  var DONE = 2;

  var FileReader = function (_EventTarget) {
    function FileReader() {
      var _this;

      _classCallCheck(this, FileReader);

      _this = _possibleConstructorReturn(this, _getPrototypeOf(FileReader).call(this));
      _this.EMPTY = EMPTY;
      _this.LOADING = LOADING;
      _this.DONE = DONE;
      _this._aborted = false;
      _this._subscriptions = [];

      _this._reset();

      return _this;
    }

    _createClass(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;
        FileReaderModule.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;
        FileReaderModule.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;
      }
    }]);

    _inherits(FileReader, _EventTarget);

    return FileReader;
  }(EventTarget.apply(void 0, READER_EVENTS));

  FileReader.EMPTY = EMPTY;
  FileReader.LOADING = LOADING;
  FileReader.DONE = DONE;
  module.exports = FileReader;
},297,[280,290,168],"node_modules/react-native/Libraries/Blob/FileReader.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  var Blob = _$$_REQUIRE(_dependencyMap[0], 'Blob');

  var _require = _$$_REQUIRE(_dependencyMap[1], 'NativeModules'),
      BlobModule = _require.BlobModule;

  var BLOB_URL_PREFIX = null;

  if (BlobModule && typeof BlobModule.BLOB_URI_SCHEME === 'string') {
    BLOB_URL_PREFIX = BlobModule.BLOB_URI_SCHEME + ':';

    if (typeof BlobModule.BLOB_URI_HOST === 'string') {
      BLOB_URL_PREFIX += "//" + BlobModule.BLOB_URI_HOST + "/";
    }
  }

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

      throw new Error('Creating URL objects is not supported yet.');
    }

    _createClass(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) {}
    }]);

    return URL;
  }();

  module.exports = URL;
},298,[290,168],"node_modules/react-native/Libraries/Blob/URL.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

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

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  var AlertIOS = _$$_REQUIRE(_dependencyMap[0], 'AlertIOS');

  var NativeModules = _$$_REQUIRE(_dependencyMap[1], 'NativeModules');

  var Platform = _$$_REQUIRE(_dependencyMap[2], 'Platform');

  var Alert = function () {
    function Alert() {
      _classCallCheck(this, Alert);
    }

    _createClass(Alert, null, [{
      key: "alert",
      value: function alert(title, message, buttons, options, type) {
        if (Platform.OS === 'ios') {
          if (typeof type !== 'undefined') {
            console.warn('Alert.alert() with a 5th "type" parameter is deprecated and will be removed. Use AlertIOS.prompt() instead.');
            AlertIOS.alert(title, message, buttons, type);
            return;
          }

          AlertIOS.alert(title, message, buttons);
        } else if (Platform.OS === 'android') {
          AlertAndroid.alert(title, message, buttons, options);
        }
      }
    }]);

    return Alert;
  }();

  var AlertAndroid = function () {
    function AlertAndroid() {
      _classCallCheck(this, AlertAndroid);
    }

    _createClass(AlertAndroid, null, [{
      key: "alert",
      value: function alert(title, message, buttons, options) {
        var config = {
          title: title || '',
          message: message || ''
        };

        if (options) {
          config = _objectSpread({}, config, {
            cancelable: options.cancelable
          });
        }

        var validButtons = buttons ? buttons.slice(0, 3) : [{
          text: 'OK'
        }];
        var buttonPositive = validButtons.pop();
        var buttonNegative = validButtons.pop();
        var buttonNeutral = validButtons.pop();

        if (buttonNeutral) {
          config = _objectSpread({}, config, {
            buttonNeutral: buttonNeutral.text || ''
          });
        }

        if (buttonNegative) {
          config = _objectSpread({}, config, {
            buttonNegative: buttonNegative.text || ''
          });
        }

        if (buttonPositive) {
          config = _objectSpread({}, config, {
            buttonPositive: buttonPositive.text || ''
          });
        }

        NativeModules.DialogManagerAndroid.showAlert(config, function (errorMessage) {
          return console.warn(errorMessage);
        }, function (action, buttonKey) {
          if (action === NativeModules.DialogManagerAndroid.buttonClicked) {
            if (buttonKey === NativeModules.DialogManagerAndroid.buttonNeutral) {
              buttonNeutral.onPress && buttonNeutral.onPress();
            } else if (buttonKey === NativeModules.DialogManagerAndroid.buttonNegative) {
              buttonNegative.onPress && buttonNegative.onPress();
            } else if (buttonKey === NativeModules.DialogManagerAndroid.buttonPositive) {
              buttonPositive.onPress && buttonPositive.onPress();
            }
          } else if (action === NativeModules.DialogManagerAndroid.dismissed) {
            options && options.onDismiss && options.onDismiss();
          }
        });
      }
    }]);

    return AlertAndroid;
  }();

  module.exports = Alert;
},299,[300,168,176],"node_modules/react-native/Libraries/Alert/Alert.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  var RCTAlertManager = _$$_REQUIRE(_dependencyMap[0], 'NativeModules').AlertManager;

  var AlertIOS = function () {
    function AlertIOS() {
      _classCallCheck(this, AlertIOS);
    }

    _createClass(AlertIOS, null, [{
      key: "alert",
      value: function alert(title, message, callbackOrButtons, type) {
        if (typeof type !== 'undefined') {
          console.warn('AlertIOS.alert() with a 4th "type" parameter is deprecated and will be removed. Use AlertIOS.prompt() instead.');
          this.prompt(title, message, callbackOrButtons, type);
          return;
        }

        this.prompt(title, message, callbackOrButtons, 'default');
      }
    }, {
      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 (typeof type === 'function') {
          console.warn('You passed a callback function as the "type" argument to AlertIOS.prompt(). React Native is ' + 'assuming  you want to use the deprecated AlertIOS.prompt(title, defaultValue, buttons, callback) ' + 'signature. The current signature is AlertIOS.prompt(title, message, callbackOrButtons, type, defaultValue, ' + 'keyboardType) and the old syntax will be removed in a future version.');
          var callback = type;
          RCTAlertManager.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 (callbackOrButtons instanceof Array) {
          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.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 AlertIOS;
  }();

  module.exports = AlertIOS;
},300,[168],"node_modules/react-native/Libraries/Alert/AlertIOS.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var NativeEventEmitter = _$$_REQUIRE(_dependencyMap[0], 'NativeEventEmitter');

  var RCTLocationObserver = _$$_REQUIRE(_dependencyMap[1], 'NativeModules').LocationObserver;

  var invariant = _$$_REQUIRE(_dependencyMap[2], 'fbjs/lib/invariant');

  var logError = _$$_REQUIRE(_dependencyMap[3], 'logError');

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

  var LocationEventEmitter = new NativeEventEmitter(RCTLocationObserver);

  var Platform = _$$_REQUIRE(_dependencyMap[5], 'Platform');

  var PermissionsAndroid = _$$_REQUIRE(_dependencyMap[6], 'PermissionsAndroid');

  var subscriptions = [];
  var updatesEnabled = false;
  var Geolocation = {
    setRNConfiguration: function setRNConfiguration(config) {
      if (RCTLocationObserver.setConfiguration) {
        RCTLocationObserver.setConfiguration(config);
      }
    },
    requestAuthorization: function requestAuthorization() {
      RCTLocationObserver.requestAuthorization();
    },
    getCurrentPosition: function getCurrentPosition(geo_success, geo_error, geo_options) {
      var hasPermission, status;
      return regeneratorRuntime.async(function getCurrentPosition$(_context) {
        while (1) {
          switch (_context.prev = _context.next) {
            case 0:
              invariant(typeof geo_success === 'function', 'Must provide a valid geo_success callback.');
              hasPermission = true;

              if (!(Platform.OS === 'android' && Platform.Version >= 23)) {
                _context.next = 11;
                break;
              }

              _context.next = 5;
              return regeneratorRuntime.awrap(PermissionsAndroid.check(PermissionsAndroid.PERMISSIONS.ACCESS_FINE_LOCATION));

            case 5:
              hasPermission = _context.sent;

              if (hasPermission) {
                _context.next = 11;
                break;
              }

              _context.next = 9;
              return regeneratorRuntime.awrap(PermissionsAndroid.request(PermissionsAndroid.PERMISSIONS.ACCESS_FINE_LOCATION));

            case 9:
              status = _context.sent;
              hasPermission = status === PermissionsAndroid.RESULTS.GRANTED;

            case 11:
              if (hasPermission) {
                RCTLocationObserver.getCurrentPosition(geo_options || {}, geo_success, geo_error || logError);
              }

            case 12:
            case "end":
              return _context.stop();
          }
        }
      }, null, this);
    },
    watchPosition: function watchPosition(success, error, options) {
      if (!updatesEnabled) {
        RCTLocationObserver.startObserving(options || {});
        updatesEnabled = true;
      }

      var watchID = subscriptions.length;
      subscriptions.push([LocationEventEmitter.addListener('geolocationDidChange', success), error ? LocationEventEmitter.addListener('geolocationError', error) : null]);
      return watchID;
    },
    clearWatch: function clearWatch(watchID) {
      var sub = subscriptions[watchID];

      if (!sub) {
        return;
      }

      sub[0].remove();
      var sub1 = sub[1];
      sub1 && sub1.remove();
      subscriptions[watchID] = undefined;
      var noWatchers = true;

      for (var ii = 0; ii < subscriptions.length; ii++) {
        if (subscriptions[ii]) {
          noWatchers = false;
        }
      }

      if (noWatchers) {
        Geolocation.stopObserving();
      }
    },
    stopObserving: function stopObserving() {
      if (updatesEnabled) {
        RCTLocationObserver.stopObserving();
        updatesEnabled = false;

        for (var ii = 0; ii < subscriptions.length; ii++) {
          var sub = subscriptions[ii];

          if (sub) {
            warning(false, 'Called stopObserving with existing subscriptions.');
            sub[0].remove();
            var sub1 = sub[1];
            sub1 && sub1.remove();
          }
        }

        subscriptions = [];
      }
    }
  };
  module.exports = Geolocation;
},301,[286,168,166,302,183,176,303],"node_modules/react-native/Libraries/Geolocation/Geolocation.js");
__d(function (global, _$$_REQUIRE, 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;
},302,[],"node_modules/react-native/Libraries/Utilities/logError.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  var NativeModules = _$$_REQUIRE(_dependencyMap[0], 'NativeModules');

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

      this.PERMISSIONS = {
        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'
      };
      this.RESULTS = {
        GRANTED: 'granted',
        DENIED: 'denied',
        NEVER_ASK_AGAIN: 'never_ask_again'
      };
    }

    _createClass(PermissionsAndroid, [{
      key: "checkPermission",
      value: function checkPermission(permission) {
        console.warn('"PermissionsAndroid.checkPermission" is deprecated. Use "PermissionsAndroid.check" instead');
        return NativeModules.PermissionsAndroid.checkPermission(permission);
      }
    }, {
      key: "check",
      value: function check(permission) {
        return NativeModules.PermissionsAndroid.checkPermission(permission);
      }
    }, {
      key: "requestPermission",
      value: function requestPermission(permission, rationale) {
        var response;
        return regeneratorRuntime.async(function requestPermission$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                console.warn('"PermissionsAndroid.requestPermission" is deprecated. Use "PermissionsAndroid.request" instead');
                _context.next = 3;
                return regeneratorRuntime.awrap(this.request(permission, rationale));

              case 3:
                response = _context.sent;
                return _context.abrupt("return", response === this.RESULTS.GRANTED);

              case 5:
              case "end":
                return _context.stop();
            }
          }
        }, null, this);
      }
    }, {
      key: "request",
      value: function request(permission, rationale) {
        var shouldShowRationale;
        return regeneratorRuntime.async(function request$(_context2) {
          while (1) {
            switch (_context2.prev = _context2.next) {
              case 0:
                if (!rationale) {
                  _context2.next = 6;
                  break;
                }

                _context2.next = 3;
                return regeneratorRuntime.awrap(NativeModules.PermissionsAndroid.shouldShowRequestPermissionRationale(permission));

              case 3:
                shouldShowRationale = _context2.sent;

                if (!shouldShowRationale) {
                  _context2.next = 6;
                  break;
                }

                return _context2.abrupt("return", new Promise(function (resolve, reject) {
                  NativeModules.DialogManagerAndroid.showAlert(rationale, function () {
                    return reject(new Error('Error showing rationale'));
                  }, function () {
                    return resolve(NativeModules.PermissionsAndroid.requestPermission(permission));
                  });
                }));

              case 6:
                return _context2.abrupt("return", NativeModules.PermissionsAndroid.requestPermission(permission));

              case 7:
              case "end":
                return _context2.stop();
            }
          }
        }, null, this);
      }
    }, {
      key: "requestMultiple",
      value: function requestMultiple(permissions) {
        return NativeModules.PermissionsAndroid.requestMultiplePermissions(permissions);
      }
    }]);

    return PermissionsAndroid;
  }();

  PermissionsAndroid = new PermissionsAndroid();
  module.exports = PermissionsAndroid;
},303,[168],"node_modules/react-native/Libraries/PermissionsAndroid/PermissionsAndroid.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  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();
      }

      _$$_REQUIRE(_dependencyMap[0], 'NativeModules').JSCHeapCapture.captureComplete(path, error);
    }
  };
  module.exports = HeapCapture;
},304,[168],"node_modules/react-native/Libraries/Utilities/HeapCapture.js");
__d(function (global, _$$_REQUIRE, 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 _require = _$$_REQUIRE(_dependencyMap[0], 'NativeModules'),
          JSCSamplingProfiler = _require.JSCSamplingProfiler;

      JSCSamplingProfiler.operationComplete(token, result, error);
    }
  };
  module.exports = SamplingProfiler;
},305,[168],"node_modules/react-native/Libraries/Performance/SamplingProfiler.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var invariant = _$$_REQUIRE(_dependencyMap[0], 'fbjs/lib/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;
},306,[166],"node_modules/react-native/Libraries/Utilities/RCTLog.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var RCTDeviceEventEmitter = _$$_REQUIRE(_dependencyMap[0], 'RCTDeviceEventEmitter');

  var RCTNativeAppEventEmitter = RCTDeviceEventEmitter;
  module.exports = RCTNativeAppEventEmitter;
},307,[194],"node_modules/react-native/Libraries/EventEmitter/RCTNativeAppEventEmitter.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var Systrace = _$$_REQUIRE(_dependencyMap[0], 'Systrace');

  var infoLog = _$$_REQUIRE(_dependencyMap[1], 'infoLog');

  var performanceNow = global.nativeQPLTimestamp || global.nativePerformanceNow || _$$_REQUIRE(_dependencyMap[2], 'fbjs/lib/performanceNow');

  var timespans = {};
  var extras = {};
  var cookies = {};
  var PRINT_TO_CONSOLE = false;
  var PerformanceLogger = {
    addTimespan: function addTimespan(key, lengthInMs, description) {
      if (timespans[key]) {
        if (__DEV__) {
          infoLog('PerformanceLogger: Attempting to add a timespan that already exists ', key);
        }

        return;
      }

      timespans[key] = {
        description: description,
        totalTime: lengthInMs
      };
    },
    startTimespan: function startTimespan(key, description) {
      if (timespans[key]) {
        if (__DEV__) {
          infoLog('PerformanceLogger: Attempting to start a timespan that already exists ', key);
        }

        return;
      }

      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 = timespans[key];

      if (!timespan || !timespan.startTime) {
        if (__DEV__) {
          infoLog('PerformanceLogger: Attempting to end a timespan that has not started ', key);
        }

        return;
      }

      if (timespan.endTime) {
        if (__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() {
      timespans = {};
      extras = {};

      if (PRINT_TO_CONSOLE) {
        infoLog('PerformanceLogger.js', 'clear');
      }
    },
    clearCompleted: function clearCompleted() {
      for (var _key in timespans) {
        if (timespans[_key].totalTime) {
          delete timespans[_key];
        }
      }

      extras = {};

      if (PRINT_TO_CONSOLE) {
        infoLog('PerformanceLogger.js', 'clearCompleted');
      }
    },
    clearExceptTimespans: function clearExceptTimespans(keys) {
      timespans = Object.keys(timespans).reduce(function (previous, key) {
        if (keys.indexOf(key) !== -1) {
          previous[key] = timespans[key];
        }

        return previous;
      }, {});
      extras = {};

      if (PRINT_TO_CONSOLE) {
        infoLog('PerformanceLogger.js', 'clearExceptTimespans', keys);
      }
    },
    currentTimestamp: function currentTimestamp() {
      return performanceNow();
    },
    getTimespans: function getTimespans() {
      return timespans;
    },
    hasTimespan: function hasTimespan(key) {
      return !!timespans[key];
    },
    logTimespans: function logTimespans() {
      for (var _key2 in timespans) {
        if (timespans[_key2].totalTime) {
          infoLog(_key2 + ': ' + 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];
        PerformanceLogger.addTimespan(label, newTimespans[ii + 1] - newTimespans[ii], label);
      }
    },
    setExtra: function setExtra(key, value) {
      if (extras[key]) {
        if (__DEV__) {
          infoLog('PerformanceLogger: Attempting to set an extra that already exists ', {
            key: key,
            currentValue: extras[key],
            attemptedValue: value
          });
        }

        return;
      }

      extras[key] = value;
    },
    getExtras: function getExtras() {
      return extras;
    },
    logExtras: function logExtras() {
      infoLog(extras);
    }
  };
  module.exports = PerformanceLogger;
},308,[172,309,177],"node_modules/react-native/Libraries/Utilities/PerformanceLogger.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function infoLog() {
    var _console;

    return (_console = console).log.apply(_console, arguments);
  }

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

  var JSDevSupport = _$$_REQUIRE(_dependencyMap[0], 'NativeModules').JSDevSupport;

  var ReactNative = _$$_REQUIRE(_dependencyMap[1], 'ReactNative');

  var JSDevSupportModule = {
    getJSHierarchy: function getJSHierarchy(tag) {
      try {
        var computeComponentStackForErrorReporting = ReactNative.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.computeComponentStackForErrorReporting;
        var componentStack = computeComponentStackForErrorReporting(tag);

        if (!componentStack) {
          JSDevSupport.onFailure(JSDevSupport.ERROR_CODE_VIEW_NOT_FOUND, "Component stack doesn't exist for tag " + tag);
        } else {
          JSDevSupport.onSuccess(componentStack);
        }
      } catch (e) {
        JSDevSupport.onFailure(JSDevSupport.ERROR_CODE_EXCEPTION, e.message);
      }
    }
  };
  module.exports = JSDevSupportModule;
},310,[168,261],"node_modules/react-native/Libraries/Utilities/JSDevSupportModule.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var Platform = _$$_REQUIRE(_dependencyMap[0], 'Platform');

  var invariant = _$$_REQUIRE(_dependencyMap[1], 'fbjs/lib/invariant');

  var MetroHMRClient = _$$_REQUIRE(_dependencyMap[2], 'metro/src/lib/bundle-modules/HMRClient');

  var HMRClient = {
    enable: function enable(platform, bundleEntry, host, port) {
      invariant(platform, 'Missing required parameter `platform`');
      invariant(bundleEntry, 'Missing required paramenter `bundleEntry`');
      invariant(host, 'Missing required paramenter `host`');

      var HMRLoadingView = _$$_REQUIRE(_dependencyMap[3], 'HMRLoadingView');

      var wsHostPort = port !== null && port !== '' ? host + ":" + port : host;
      bundleEntry = bundleEntry.replace(/\.(bundle|delta)/, '.js');
      var wsUrl = "ws://" + wsHostPort + "/hot?" + ("platform=" + platform + "&") + ("bundleEntry=" + bundleEntry);
      var hmrClient = new MetroHMRClient(wsUrl);
      hmrClient.on('connection-error', function (e) {
        var error = "Hot loading isn't working because it cannot connect to the development server.\n\nTry the following to fix the issue:\n- Ensure that the packager server is running and available on the same network";

        if (Platform.OS === 'ios') {
          error += "\n- Ensure that the Packager 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;
        throw new Error(error);
      });
      hmrClient.on('update-start', function () {
        HMRLoadingView.showMessage('Hot Loading...');
      });
      hmrClient.on('update', function () {
        if (Platform.OS === 'ios') {
          var RCTRedBox = _$$_REQUIRE(_dependencyMap[4], 'NativeModules').RedBox;

          RCTRedBox && RCTRedBox.dismiss && RCTRedBox.dismiss();
        } else {
          var RCTExceptionsManager = _$$_REQUIRE(_dependencyMap[4], 'NativeModules').ExceptionsManager;

          RCTExceptionsManager && RCTExceptionsManager.dismissRedbox && RCTExceptionsManager.dismissRedbox();
        }
      });
      hmrClient.on('update-done', function () {
        HMRLoadingView.hide();
      });
      hmrClient.on('error', function (data) {
        HMRLoadingView.hide();
        throw new Error(data.type + " " + data.message);
      });
      hmrClient.enable();
    }
  };
  module.exports = HMRClient;
},311,[176,166,312,315,168],"node_modules/react-native/Libraries/Utilities/HMRClient.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  module.exports = _$$_REQUIRE(_dependencyMap[0], './MetroClient');
},312,[313],"node_modules/metro/src/lib/bundle-modules/HMRClient.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var EventEmitter = _$$_REQUIRE(_dependencyMap[0], 'eventemitter3');

  var MetroClient = function (_EventEmitter) {
    function MetroClient(url) {
      var _this;

      _classCallCheck(this, MetroClient);

      _this = _possibleConstructorReturn(this, _getPrototypeOf(MetroClient).call(this));
      _this._url = url;
      return _this;
    }

    _createClass(MetroClient, [{
      key: "enable",
      value: function enable() {
        var _this2 = this;

        if (this._ws) {
          this.disable();
        }

        this._ws = new global.WebSocket(this._url);

        this._ws.onerror = function (error) {
          _this2.emit('connection-error', error);
        };

        this._ws.onclose = function () {
          _this2.emit('close');
        };

        this._ws.onmessage = function (message) {
          var data = JSON.parse(message.data);

          switch (data.type) {
            case 'update-start':
              _this2.emit('update-start');

              break;

            case 'update':
              var _data$body = data.body;
              var modules = _data$body.modules,
                  sourceMappingURLs = _data$body.sourceMappingURLs,
                  sourceURLs = _data$body.sourceURLs;

              _this2.emit('update');

              modules.forEach(function (_ref, i) {
                var id = _ref.id,
                    code = _ref.code;
                code += '\n\n' + sourceMappingURLs[i];
                var injectFunction = typeof global.nativeInjectHMRUpdate === 'function' ? global.nativeInjectHMRUpdate : eval;
                injectFunction(code, sourceURLs[i]);
              });
              break;

            case 'update-done':
              _this2.emit('update-done');

              break;

            case 'error':
              _this2.emit('error', data.body);

              break;

            default:
              _this2.emit('error', {
                type: 'unknown-message',
                message: data
              });

          }
        };
      }
    }, {
      key: "disable",
      value: function disable() {
        if (this._ws) {
          this._ws.close();

          this._ws = undefined;
        }
      }
    }]);

    _inherits(MetroClient, _EventEmitter);

    return MetroClient;
  }(EventEmitter);

  module.exports = MetroClient;
},313,[314],"node_modules/metro/src/lib/bundle-modules/MetroClient.js");
__d(function (global, _$$_REQUIRE, 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;
  }
},314,[],"node_modules/eventemitter3/index.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  var processColor = _$$_REQUIRE(_dependencyMap[0], 'processColor');

  var _require = _$$_REQUIRE(_dependencyMap[1], 'NativeModules'),
      DevLoadingView = _require.DevLoadingView;

  var HMRLoadingView = function () {
    function HMRLoadingView() {
      _classCallCheck(this, HMRLoadingView);
    }

    _createClass(HMRLoadingView, null, [{
      key: "showMessage",
      value: function showMessage(message) {
        DevLoadingView.showMessage(message, processColor('#000000'), processColor('#aaaaaa'));
      }
    }, {
      key: "hide",
      value: function hide() {
        DevLoadingView.hide();
      }
    }]);

    return HMRLoadingView;
  }();

  module.exports = HMRLoadingView;
},315,[221,168],"node_modules/react-native/Libraries/Utilities/HMRLoadingView.ios.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var register = function register() {};

  if (__DEV__) {
    var AppState = _$$_REQUIRE(_dependencyMap[0], 'AppState');

    var WebSocket = _$$_REQUIRE(_dependencyMap[1], 'WebSocket');

    var reactDevTools = _$$_REQUIRE(_dependencyMap[2], 'react-devtools-core');

    var getDevServer = _$$_REQUIRE(_dependencyMap[3], 'getDevServer');

    if (WebSocket.isAvailable) {
      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[4], 'flattenStyle')
      });
    }
  }

  module.exports = {
    register: register
  };
},316,[317,294,318,273,226],"node_modules/react-native/Libraries/Core/Devtools/setupDevtools.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var MissingNativeEventEmitterShim = _$$_REQUIRE(_dependencyMap[0], 'MissingNativeEventEmitterShim');

  var NativeEventEmitter = _$$_REQUIRE(_dependencyMap[1], 'NativeEventEmitter');

  var NativeModules = _$$_REQUIRE(_dependencyMap[2], 'NativeModules');

  var RCTAppState = NativeModules.AppState;

  var logError = _$$_REQUIRE(_dependencyMap[3], 'logError');

  var invariant = _$$_REQUIRE(_dependencyMap[4], 'fbjs/lib/invariant');

  var AppState = function (_NativeEventEmitter) {
    function AppState() {
      var _this;

      _classCallCheck(this, AppState);

      _this = _possibleConstructorReturn(this, _getPrototypeOf(AppState).call(this, RCTAppState));
      _this.isAvailable = true;
      _this.isAvailable = true;
      _this._eventHandlers = {
        change: new Map(),
        memoryWarning: new Map()
      };
      _this.currentState = RCTAppState.initialAppState || 'active';
      var eventUpdated = false;

      _this.addListener('appStateDidChange', function (appStateData) {
        eventUpdated = true;
        _this.currentState = appStateData.app_state;
      });

      RCTAppState.getCurrentAppState(function (appStateData) {
        if (!eventUpdated && _this.currentState !== appStateData.app_state) {
          _this.currentState = appStateData.app_state;

          _this.emit('appStateDidChange', appStateData);
        }
      }, logError);
      return _this;
    }

    _createClass(AppState, [{
      key: "addEventListener",
      value: function addEventListener(type, handler) {
        invariant(['change', 'memoryWarning'].indexOf(type) !== -1, 'Trying to subscribe to unknown event: "%s"', type);

        if (type === 'change') {
          this._eventHandlers[type].set(handler, this.addListener('appStateDidChange', function (appStateData) {
            handler(appStateData.app_state);
          }));
        } else if (type === 'memoryWarning') {
          this._eventHandlers[type].set(handler, this.addListener('memoryWarning', handler));
        }
      }
    }, {
      key: "removeEventListener",
      value: function removeEventListener(type, handler) {
        invariant(['change', 'memoryWarning'].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);
      }
    }]);

    _inherits(AppState, _NativeEventEmitter);

    return AppState;
  }(NativeEventEmitter);

  if (__DEV__ && !RCTAppState) {
    var MissingNativeAppStateShim = function (_MissingNativeEventEm) {
      function MissingNativeAppStateShim() {
        _classCallCheck(this, MissingNativeAppStateShim);

        return _possibleConstructorReturn(this, _getPrototypeOf(MissingNativeAppStateShim).call(this, 'RCTAppState', 'AppState'));
      }

      _createClass(MissingNativeAppStateShim, [{
        key: "addEventListener",
        value: function addEventListener() {
          this.throwMissingNativeModule();
        }
      }, {
        key: "removeEventListener",
        value: function removeEventListener() {
          this.throwMissingNativeModule();
        }
      }, {
        key: "currentState",
        get: function get() {
          this.throwMissingNativeModule();
        }
      }]);

      _inherits(MissingNativeAppStateShim, _MissingNativeEventEm);

      return MissingNativeAppStateShim;
    }(MissingNativeEventEmitterShim);

    AppState = new MissingNativeAppStateShim();
  } else {
    AppState = new AppState();
  }

  module.exports = AppState;
},317,[285,286,168,302,166],"node_modules/react-native/Libraries/AppState/AppState.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

  !function (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 = x, E.onerror = x, 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 x() {
            O || (O = !0, b(), w.forEach(function (e) {
              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);
      }

      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]
            });
          }
        }]) && 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", 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), {
            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;
      });
    }]);
  });
},318,[],"node_modules/react-devtools-core/build/backend.js");
__d(function (global, _$$_REQUIRE, 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;
},319,[],"node_modules/react-native/Libraries/JSInspector/JSInspector.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

  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 _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  var InspectorAgent = _$$_REQUIRE(_dependencyMap[0], 'InspectorAgent');

  var JSInspector = _$$_REQUIRE(_dependencyMap[1], 'JSInspector');

  var Map = _$$_REQUIRE(_dependencyMap[2], 'Map');

  var XMLHttpRequest = _$$_REQUIRE(_dependencyMap[3], '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) {
    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');
        }
      }
    }]);

    _inherits(NetworkAgent, _InspectorAgent);

    return NetworkAgent;
  }(InspectorAgent);

  NetworkAgent.DOMAIN = 'Network';
  module.exports = NetworkAgent;
},320,[321,319,266,279],"node_modules/react-native/Libraries/JSInspector/NetworkAgent.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  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;
},321,[],"node_modules/react-native/Libraries/JSInspector/InspectorAgent.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var BatchedBridge = _$$_REQUIRE(_dependencyMap[0], 'BatchedBridge');

  var RCTEventEmitter = {
    register: function register(eventEmitter) {
      BatchedBridge.registerCallableModule('RCTEventEmitter', eventEmitter);
    }
  };
  module.exports = RCTEventEmitter;
},322,[169],"node_modules/react-native/Libraries/EventEmitter/RCTEventEmitter.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var emptyObject = {};

  if (process.env.NODE_ENV !== 'production') {
    Object.freeze(emptyObject);
  }

  module.exports = emptyObject;
},323,[],"node_modules/react-native/node_modules/fbjs/lib/emptyObject.js");
__d(function (global, _$$_REQUIRE, 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;
},324,[],"node_modules/react-native/Libraries/Utilities/differ/deepDiffer.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var Platform = _$$_REQUIRE(_dependencyMap[0], 'Platform');

  var UIManager = _$$_REQUIRE(_dependencyMap[1], 'UIManager');

  var inputs = new Set();
  var TextInputState = {
    _currentlyFocusedID: null,
    currentlyFocusedField: function currentlyFocusedField() {
      return this._currentlyFocusedID;
    },
    focusTextInput: function focusTextInput(textFieldID) {
      if (this._currentlyFocusedID !== textFieldID && textFieldID !== null) {
        this._currentlyFocusedID = textFieldID;

        if (Platform.OS === 'ios') {
          UIManager.focus(textFieldID);
        } else if (Platform.OS === 'android') {
          UIManager.dispatchViewManagerCommand(textFieldID, UIManager.AndroidTextInput.Commands.focusTextInput, null);
        }
      }
    },
    blurTextInput: function blurTextInput(textFieldID) {
      if (this._currentlyFocusedID === textFieldID && textFieldID !== null) {
        this._currentlyFocusedID = null;

        if (Platform.OS === 'ios') {
          UIManager.blur(textFieldID);
        } else if (Platform.OS === 'android') {
          UIManager.dispatchViewManagerCommand(textFieldID, UIManager.AndroidTextInput.Commands.blurTextInput, null);
        }
      }
    },
    registerInput: function registerInput(textFieldID) {
      inputs.add(textFieldID);
    },
    unregisterInput: function unregisterInput(textFieldID) {
      inputs.delete(textFieldID);
    },
    isTextInput: function isTextInput(textFieldID) {
      return inputs.has(textFieldID);
    }
  };
  module.exports = TextInputState;
},325,[176,218],"node_modules/react-native/Libraries/Components/TextInput/TextInputState.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  "use strict";

  function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

  _$$_REQUIRE(_dependencyMap[0], "InitializeCore");

  var invariant = _$$_REQUIRE(_dependencyMap[1], "fbjs/lib/invariant"),
      ReactNativeViewConfigRegistry = _$$_REQUIRE(_dependencyMap[2], "ReactNativeViewConfigRegistry"),
      UIManager = _$$_REQUIRE(_dependencyMap[3], "UIManager"),
      RCTEventEmitter = _$$_REQUIRE(_dependencyMap[4], "RCTEventEmitter"),
      React = _$$_REQUIRE(_dependencyMap[5], "react"),
      emptyObject = _$$_REQUIRE(_dependencyMap[6], "fbjs/lib/emptyObject"),
      deepDiffer = _$$_REQUIRE(_dependencyMap[7], "deepDiffer"),
      flattenStyle = _$$_REQUIRE(_dependencyMap[8], "flattenStyle"),
      TextInputState = _$$_REQUIRE(_dependencyMap[9], "TextInputState"),
      ExceptionsManager = _$$_REQUIRE(_dependencyMap[10], "ExceptionsManager");

  function _invokeGuardedCallback(name, func, context, a, b, c, d, e, f) {
    this._hasCaughtError = !1;
    this._caughtError = null;
    var funcArgs = Array.prototype.slice.call(arguments, 3);

    try {
      func.apply(context, funcArgs);
    } catch (error) {
      this._caughtError = error, this._hasCaughtError = !0;
    }
  }

  var ReactErrorUtils = {
    _caughtError: null,
    _hasCaughtError: !1,
    _rethrowError: null,
    _hasRethrowError: !1,
    invokeGuardedCallback: function invokeGuardedCallback(name, func, context, a, b, c, d, e, f) {
      _invokeGuardedCallback.apply(ReactErrorUtils, arguments);
    },
    invokeGuardedCallbackAndCatchFirstError: function invokeGuardedCallbackAndCatchFirstError(name, func, context, a, b, c, d, e, f) {
      ReactErrorUtils.invokeGuardedCallback.apply(this, arguments);

      if (ReactErrorUtils.hasCaughtError()) {
        var error = ReactErrorUtils.clearCaughtError();
        ReactErrorUtils._hasRethrowError || (ReactErrorUtils._hasRethrowError = !0, ReactErrorUtils._rethrowError = error);
      }
    },
    rethrowCaughtError: function rethrowCaughtError() {
      return _rethrowCaughtError.apply(ReactErrorUtils, arguments);
    },
    hasCaughtError: function hasCaughtError() {
      return ReactErrorUtils._hasCaughtError;
    },
    clearCaughtError: function clearCaughtError() {
      if (ReactErrorUtils._hasCaughtError) {
        var error = ReactErrorUtils._caughtError;
        ReactErrorUtils._caughtError = null;
        ReactErrorUtils._hasCaughtError = !1;
        return error;
      }

      invariant(!1, "clearCaughtError was called but no error was captured. This error is likely caused by a bug in React. Please file an issue.");
    }
  };

  function _rethrowCaughtError() {
    if (ReactErrorUtils._hasRethrowError) {
      var error = ReactErrorUtils._rethrowError;
      ReactErrorUtils._rethrowError = null;
      ReactErrorUtils._hasRethrowError = !1;
      throw error;
    }
  }

  var eventPluginOrder = null,
      namesToPlugins = {};

  function recomputePluginOrdering() {
    if (eventPluginOrder) for (var pluginName in namesToPlugins) {
      var pluginModule = namesToPlugins[pluginName],
          pluginIndex = eventPluginOrder.indexOf(pluginName);
      invariant(-1 < pluginIndex, "EventPluginRegistry: Cannot inject event plugins that do not exist in the plugin ordering, `%s`.", pluginName);

      if (!plugins[pluginIndex]) {
        invariant(pluginModule.extractEvents, "EventPluginRegistry: Event plugins must implement an `extractEvents` method, but `%s` does not.", pluginName);
        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;
          invariant(!eventNameDispatchConfigs.hasOwnProperty(eventName$jscomp$0), "EventPluginHub: More than one plugin attempted to publish the same event name, `%s`.", 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;

          invariant(JSCompiler_inline_result, "EventPluginRegistry: Failed to publish event `%s` for plugin `%s`.", eventName, pluginName);
        }
      }
    }
  }

  function publishRegistrationName(registrationName, pluginModule) {
    invariant(!registrationNameModules[registrationName], "EventPluginHub: More than one plugin attempted to publish the same registration name, `%s`.", registrationName);
    registrationNameModules[registrationName] = pluginModule;
  }

  var plugins = [],
      eventNameDispatchConfigs = {},
      registrationNameModules = {},
      getFiberCurrentPropsFromNode = null,
      getInstanceFromNode = null,
      getNodeFromInstance = null;

  function executeDispatch(event, simulated, listener, inst) {
    simulated = event.type || "unknown-event";
    event.currentTarget = getNodeFromInstance(inst);
    ReactErrorUtils.invokeGuardedCallbackAndCatchFirstError(simulated, listener, void 0, event);
    event.currentTarget = null;
  }

  function executeDirectDispatch(event) {
    var dispatchListener = event._dispatchListeners,
        dispatchInstance = event._dispatchInstances;
    invariant(!Array.isArray(dispatchListener), "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) {
    invariant(null != next, "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, !1, dispatchListeners[i], dispatchInstances[i]);
      } else dispatchListeners && executeDispatch(e, !1, dispatchListeners, dispatchInstances);
      e._dispatchListeners = null;
      e._dispatchInstances = null;
      e.isPersistent() || e.constructor.release(e);
    }
  }

  var injection = {
    injectEventPluginOrder: function injectEventPluginOrder(injectedEventPluginOrder) {
      invariant(!eventPluginOrder, "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];
          namesToPlugins.hasOwnProperty(pluginName) && namesToPlugins[pluginName] === pluginModule || (invariant(!namesToPlugins[pluginName], "EventPluginRegistry: Cannot inject two different event plugins using the same name, `%s`.", 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;
    invariant(!listener || "function" === typeof listener, "Expected `%s` listener to be a function, instead got a value of `%s` type.", registrationName, typeof listener);
    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));
      }
    }
  }

  var shouldBeReleasedProperties = "dispatchConfig _targetInst nativeEvent isDefaultPrevented isPropagationStopped _dispatchListeners _dispatchInstances".split(" ");

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

      for (Interface = 0; Interface < shouldBeReleasedProperties.length; Interface++) {
        this[shouldBeReleasedProperties[Interface]] = 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) {
    invariant(event instanceof this, "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;
    invariant(null != _ref, "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.error("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.error("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) {
    invariant(null != next, "accumulate(...): Accumulated items must be 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$1 = {
    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$1,
    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$1.startShouldSetResponder : isMoveish(topLevelType) ? eventTypes$1.moveShouldSetResponder : "topSelectionChange" === topLevelType ? eventTypes$1.selectionChangeShouldSetResponder : eventTypes$1.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$1.responderGrant, JSCompiler_temp, nativeEvent, nativeEventTarget), targetInst.touchHistory = ResponderTouchHistoryStore.touchHistory, forEachAccumulated(targetInst, accumulateDirectDispatchesSingle), depthA = !0 === executeDirectDispatch(targetInst), responderInst ? (tempA = ResponderSyntheticEvent.getPooled(eventTypes$1.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$1.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$1.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$1.responderStart : targetInst ? eventTypes$1.responderMove : depthA ? eventTypes$1.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$1.responderTerminate : topLevelType ? eventTypes$1.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$1 = ReactNativeViewConfigRegistry.customBubblingEventTypes,
      customDirectEventTypes$1 = ReactNativeViewConfigRegistry.customDirectEventTypes,
      ReactNativeBridgeEventPlugin = {
    eventTypes: ReactNativeViewConfigRegistry.eventTypes,
    extractEvents: function extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
      if (null == targetInst) return null;
      var bubbleDispatchConfig = customBubblingEventTypes$1[topLevelType],
          directDispatchConfig = customDirectEventTypes$1[topLevelType];
      invariant(bubbleDispatchConfig || directDispatchConfig, 'Unsupported top level event type "%s" dispatched', topLevelType);
      topLevelType = SyntheticEvent.getPooled(bubbleDispatchConfig || directDispatchConfig, targetInst, nativeEvent, nativeEventTarget);
      if (bubbleDispatchConfig) forEachAccumulated(topLevelType, accumulateTwoPhaseDispatchesSingle);else if (directDispatchConfig) forEachAccumulated(topLevelType, accumulateDirectDispatchesSingle);else return null;
      return topLevelType;
    }
  };
  injection.injectEventPluginOrder(["ResponderEventPlugin", "ReactNativeBridgeEventPlugin"]);
  injection.injectEventPluginsByName({
    ResponderEventPlugin: ResponderEventPlugin,
    ReactNativeBridgeEventPlugin: ReactNativeBridgeEventPlugin
  });
  var instanceCache = {},
      instanceProps = {};

  function uncacheFiberNode(tag) {
    delete instanceCache[tag];
    delete instanceProps[tag];
  }

  function getInstanceFromTag(tag) {
    return instanceCache[tag] || null;
  }

  var ReactNativeComponentTree = {
    precacheFiberNode: function precacheFiberNode(hostInst, tag) {
      instanceCache[tag] = hostInst;
    },
    uncacheFiberNode: uncacheFiberNode,
    getClosestInstanceFromNode: getInstanceFromTag,
    getInstanceFromNode: getInstanceFromTag,
    getNodeFromInstance: function getNodeFromInstance(inst) {
      var tag = inst.stateNode._nativeTag;
      void 0 === tag && (tag = inst.stateNode.canonical._nativeTag);
      invariant(tag, "All native instances should have a tag.");
      return tag;
    },
    getFiberCurrentPropsFromNode: function getFiberCurrentPropsFromNode(stateNode) {
      return instanceProps[stateNode._nativeTag] || null;
    },
    updateFiberProps: function updateFiberProps(tag, props) {
      instanceProps[tag] = props;
    }
  },
      restoreTarget = null,
      restoreQueue = null;

  function restoreStateOfTarget(target) {
    if (target = getInstanceFromNode(target)) {
      invariant(null, "Fiber needs to be injected to handle a fiber target for controlled events. This error is likely caused by a bug in React. Please file an issue.");
      var props = getFiberCurrentPropsFromNode(target.stateNode);
      null.restoreControlledState(target.stateNode, target.type, props);
    }
  }

  function _batchedUpdates(fn, bookkeeping) {
    return fn(bookkeeping);
  }

  function _flushInteractiveUpdates() {}

  var isBatching = !1;

  function batchedUpdates(fn, bookkeeping) {
    if (isBatching) return fn(bookkeeping);
    isBatching = !0;

    try {
      return _batchedUpdates(fn, bookkeeping);
    } finally {
      if (isBatching = !1, null !== restoreTarget || null !== restoreQueue) if (_flushInteractiveUpdates(), 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;
      events && (forEachAccumulated(events, executeDispatchesAndReleaseTopLevel), invariant(!eventQueue, "processEventQueue(): Additional events were enqueued while processing an event queue. Support for this has not yet been implemented."), ReactErrorUtils.rethrowCaughtError());
    });
  }

  RCTEventEmitter.register({
    getListener: getListener,
    registrationNames: registrationNameModules,
    _receiveRootNodeIDEvent: _receiveRootNodeIDEvent,
    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 = ReactNativeComponentTree.getFiberCurrentPropsFromNode;
  getInstanceFromNode = ReactNativeComponentTree.getInstanceFromNode;
  getNodeFromInstance = ReactNativeComponentTree.getNodeFromInstance;
  ResponderEventPlugin.injection.injectGlobalResponderHandler({
    onChange: function onChange(from, to, blockNativeResponder) {
      null !== to ? UIManager.setJSResponder(to.stateNode._nativeTag, blockNativeResponder) : UIManager.clearJSResponder();
    }
  });
  var ReactCurrentOwner = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner,
      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_ASYNC_MODE_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.async_mode") : 60111,
      REACT_FORWARD_REF_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.forward_ref") : 60112,
      REACT_TIMEOUT_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.timeout") : 60113,
      MAYBE_ITERATOR_SYMBOL = "function" === typeof Symbol && (typeof Symbol === "function" ? Symbol.iterator : "@@iterator");

  function getIteratorFn(maybeIterable) {
    if (null === maybeIterable || "undefined" === typeof maybeIterable) return null;
    maybeIterable = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable["@@iterator"];
    return "function" === typeof maybeIterable ? maybeIterable : null;
  }

  function getComponentName(fiber) {
    var type = fiber.type;
    if ("function" === typeof type) return type.displayName || type.name;
    if ("string" === typeof type) return type;

    switch (type) {
      case REACT_ASYNC_MODE_TYPE:
        return "AsyncMode";

      case REACT_CONTEXT_TYPE:
        return "Context.Consumer";

      case REACT_FRAGMENT_TYPE:
        return "ReactFragment";

      case REACT_PORTAL_TYPE:
        return "ReactPortal";

      case REACT_PROFILER_TYPE:
        return "Profiler(" + fiber.pendingProps.id + ")";

      case REACT_PROVIDER_TYPE:
        return "Context.Provider";

      case REACT_STRICT_MODE_TYPE:
        return "StrictMode";

      case REACT_TIMEOUT_TYPE:
        return "Timeout";
    }

    if ("object" === typeof type && null !== type) switch (type.$$typeof) {
      case REACT_FORWARD_REF_TYPE:
        return fiber = type.render.displayName || type.render.name || "", "" !== fiber ? "ForwardRef(" + fiber + ")" : "ForwardRef";
    }
    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) {
    invariant(2 === isFiberMountedImpl(fiber), "Unable to find node on an unmounted component.");
  }

  function findCurrentFiberUsingSlowPath(fiber) {
    var alternate = fiber.alternate;
    if (!alternate) return alternate = isFiberMountedImpl(fiber), invariant(3 !== alternate, "Unable to find node on an unmounted component."), 1 === alternate ? null : fiber;

    for (var a = fiber, b = alternate;;) {
      var parentA = a.return,
          parentB = parentA ? parentA.alternate : null;
      if (!parentA || !parentB) break;

      if (parentA.child === parentB.child) {
        for (var child = parentA.child; child;) {
          if (child === a) return assertIsMounted(parentA), fiber;
          if (child === b) return assertIsMounted(parentA), alternate;
          child = child.sibling;
        }

        invariant(!1, "Unable to find node on an unmounted component.");
      }

      if (a.return !== b.return) a = parentA, b = parentB;else {
        child = !1;

        for (var _child = parentA.child; _child;) {
          if (_child === a) {
            child = !0;
            a = parentA;
            b = parentB;
            break;
          }

          if (_child === b) {
            child = !0;
            b = parentA;
            a = parentB;
            break;
          }

          _child = _child.sibling;
        }

        if (!child) {
          for (_child = parentB.child; _child;) {
            if (_child === a) {
              child = !0;
              a = parentB;
              b = parentA;
              break;
            }

            if (_child === b) {
              child = !0;
              b = parentB;
              a = parentA;
              break;
            }

            _child = _child.sibling;
          }

          invariant(child, "Child was not found in either parent set. This indicates a bug in React related to the return pointer. Please file an issue.");
        }
      }
      invariant(a.alternate === b, "Return fibers should always be each others' alternates. This error is likely caused by a bug in React. Please file an issue.");
    }

    invariant(3 === a.tag, "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 findCurrentHostFiberWithNoPortals(parent) {
    parent = findCurrentFiberUsingSlowPath(parent);
    if (!parent) return null;

    for (var node = parent;;) {
      if (5 === node.tag || 6 === node.tag) return node;
      if (node.child && 4 !== node.tag) 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$1 = {},
      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, flattenStyle(prevProp), nextProp, validAttributes) : diffProperties(updatePayload, prevProp, flattenStyle(nextProp), validAttributes);
  }

  function addNestedProperty(updatePayload, nextProp, validAttributes) {
    if (!nextProp) return updatePayload;
    if (!Array.isArray(nextProp)) return diffProperties(updatePayload, emptyObject$1, 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$1, 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 || 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 || 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(context, callback) {
    return function () {
      if (callback) {
        if ("boolean" === typeof context.__isMounted) {
          if (!context.__isMounted) return;
        } else if ("function" === typeof context.isMounted && !context.isMounted()) return;

        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 () {
      TextInputState.blurTextInput(this._nativeTag);
    };

    ReactNativeFiberHostComponent.prototype.focus = function () {
      TextInputState.focusTextInput(this._nativeTag);
    };

    ReactNativeFiberHostComponent.prototype.measure = function (callback) {
      UIManager.measure(this._nativeTag, mountSafeCallback(this, callback));
    };

    ReactNativeFiberHostComponent.prototype.measureInWindow = function (callback) {
      UIManager.measureInWindow(this._nativeTag, mountSafeCallback(this, callback));
    };

    ReactNativeFiberHostComponent.prototype.measureLayout = function (relativeToNativeNode, onSuccess, onFail) {
      UIManager.measureLayout(this._nativeTag, relativeToNativeNode, mountSafeCallback(this, onFail), mountSafeCallback(this, onSuccess));
    };

    ReactNativeFiberHostComponent.prototype.setNativeProps = function (nativeProps) {
      nativeProps = diffProperties(null, emptyObject$1, nativeProps, this.viewConfig.validAttributes);
      null != nativeProps && UIManager.updateView(this._nativeTag, this.viewConfig.uiViewClassName, nativeProps);
    };

    return ReactNativeFiberHostComponent;
  }(),
      now$1 = "object" === typeof performance && "function" === typeof performance.now ? function () {
    return performance.now();
  } : function () {
    return Date.now();
  },
      scheduledCallback = null,
      frameDeadline = 0,
      frameDeadlineObject = {
    timeRemaining: function timeRemaining() {
      return frameDeadline - now$1();
    },
    didTimeout: !1
  };

  function setTimeoutCallback() {
    frameDeadline = now$1() + 5;
    var callback = scheduledCallback;
    scheduledCallback = null;
    null !== callback && callback(frameDeadlineObject);
  }

  function shim$1() {
    invariant(!1, "The current renderer does not support hyration. This error is likely caused by a bug in React. Please file an issue.");
  }

  var nextReactTag = 3;

  function allocateTag() {
    var tag = nextReactTag;
    1 === tag % 10 && (tag += 2);
    nextReactTag = tag + 2;
    return tag;
  }

  function recursivelyUncacheFiberNode(node) {
    "number" === typeof node ? uncacheFiberNode(node) : (uncacheFiberNode(node._nativeTag), 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;
    });

    UIManager.setChildren(parentInstance._nativeTag, nativeTags);
    return !1;
  }

  function getStackAddendumByWorkInProgressFiber(workInProgress) {
    var info = "";

    do {
      a: switch (workInProgress.tag) {
        case 0:
        case 1:
        case 2:
        case 5:
          var owner = workInProgress._debugOwner,
              source = workInProgress._debugSource;
          var JSCompiler_inline_result = getComponentName(workInProgress);
          var ownerName = null;
          owner && (ownerName = getComponentName(owner));
          owner = source;
          JSCompiler_inline_result = "\n    in " + (JSCompiler_inline_result || "Unknown") + (owner ? " (at " + owner.fileName.replace(/^.*[\\\/]/, "") + ":" + owner.lineNumber + ")" : ownerName ? " (created by " + ownerName + ")" : "");
          break a;

        default:
          JSCompiler_inline_result = "";
      }

      info += JSCompiler_inline_result;
      workInProgress = workInProgress.return;
    } while (workInProgress);

    return info;
  }

  new Set();
  var valueStack = [],
      index = -1;

  function createCursor(defaultValue) {
    return {
      current: defaultValue
    };
  }

  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 contextStackCursor = createCursor(emptyObject),
      didPerformWorkStackCursor = createCursor(!1),
      previousContext = emptyObject;

  function getUnmaskedContext(workInProgress) {
    return isContextProvider(workInProgress) ? previousContext : contextStackCursor.current;
  }

  function getMaskedContext(workInProgress, unmaskedContext) {
    var contextTypes = workInProgress.type.contextTypes;
    if (!contextTypes) return emptyObject;
    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(fiber) {
    return 2 === fiber.tag && null != fiber.type.childContextTypes;
  }

  function popContextProvider(fiber) {
    isContextProvider(fiber) && (pop(didPerformWorkStackCursor, fiber), pop(contextStackCursor, fiber));
  }

  function popTopLevelContextObject(fiber) {
    pop(didPerformWorkStackCursor, fiber);
    pop(contextStackCursor, fiber);
  }

  function pushTopLevelContextObject(fiber, context, didChange) {
    invariant(contextStackCursor.current === emptyObject, "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, parentContext) {
    var instance = fiber.stateNode,
        childContextTypes = fiber.type.childContextTypes;
    if ("function" !== typeof instance.getChildContext) return parentContext;
    instance = instance.getChildContext();

    for (var contextKey in instance) {
      invariant(contextKey in childContextTypes, '%s.getChildContext(): key "%s" is not defined in childContextTypes.', getComponentName(fiber) || "Unknown", contextKey);
    }

    return _extends({}, parentContext, instance);
  }

  function pushContextProvider(workInProgress) {
    if (!isContextProvider(workInProgress)) return !1;
    var instance = workInProgress.stateNode;
    instance = instance && instance.__reactInternalMemoizedMergedChildContext || emptyObject;
    previousContext = contextStackCursor.current;
    push(contextStackCursor, instance, workInProgress);
    push(didPerformWorkStackCursor, didPerformWorkStackCursor.current, workInProgress);
    return !0;
  }

  function invalidateContextProvider(workInProgress, didChange) {
    var instance = workInProgress.stateNode;
    invariant(instance, "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, previousContext);
      instance.__reactInternalMemoizedMergedChildContext = mergedContext;
      pop(didPerformWorkStackCursor, workInProgress);
      pop(contextStackCursor, workInProgress);
      push(contextStackCursor, mergedContext, workInProgress);
    } else pop(didPerformWorkStackCursor, workInProgress);

    push(didPerformWorkStackCursor, didChange, workInProgress);
  }

  function FiberNode(tag, pendingProps, key, mode) {
    this.tag = tag;
    this.key = key;
    this.sibling = this.child = this.return = this.stateNode = this.type = null;
    this.index = 0;
    this.ref = null;
    this.pendingProps = pendingProps;
    this.memoizedState = this.updateQueue = this.memoizedProps = null;
    this.mode = mode;
    this.effectTag = 0;
    this.lastEffect = this.firstEffect = this.nextEffect = null;
    this.expirationTime = 0;
    this.alternate = null;
  }

  function createWorkInProgress(current, pendingProps, expirationTime) {
    var workInProgress = current.alternate;
    null === workInProgress ? (workInProgress = new FiberNode(current.tag, pendingProps, current.key, current.mode), 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.expirationTime = expirationTime;
    workInProgress.child = current.child;
    workInProgress.memoizedProps = current.memoizedProps;
    workInProgress.memoizedState = current.memoizedState;
    workInProgress.updateQueue = current.updateQueue;
    workInProgress.sibling = current.sibling;
    workInProgress.index = current.index;
    workInProgress.ref = current.ref;
    return workInProgress;
  }

  function createFiberFromElement(element, mode, expirationTime) {
    var type = element.type,
        key = element.key;
    element = element.props;
    if ("function" === typeof type) var fiberTag = type.prototype && type.prototype.isReactComponent ? 2 : 0;else if ("string" === typeof type) fiberTag = 5;else switch (type) {
      case REACT_FRAGMENT_TYPE:
        return createFiberFromFragment(element.children, mode, expirationTime, key);

      case REACT_ASYNC_MODE_TYPE:
        fiberTag = 11;
        mode |= 3;
        break;

      case REACT_STRICT_MODE_TYPE:
        fiberTag = 11;
        mode |= 2;
        break;

      case REACT_PROFILER_TYPE:
        return type = new FiberNode(15, element, key, mode | 4), type.type = REACT_PROFILER_TYPE, type.expirationTime = expirationTime, type;

      case REACT_TIMEOUT_TYPE:
        fiberTag = 16;
        mode |= 2;
        break;

      default:
        a: {
          switch ("object" === typeof type && null !== type ? type.$$typeof : null) {
            case REACT_PROVIDER_TYPE:
              fiberTag = 13;
              break a;

            case REACT_CONTEXT_TYPE:
              fiberTag = 12;
              break a;

            case REACT_FORWARD_REF_TYPE:
              fiberTag = 14;
              break a;

            default:
              invariant(!1, "Element type is invalid: expected a string (for built-in components) or a class/function (for composite components) but got: %s.%s", null == type ? type : typeof type, "");
          }

          fiberTag = void 0;
        }

    }
    mode = new FiberNode(fiberTag, element, key, mode);
    mode.type = type;
    mode.expirationTime = expirationTime;
    return mode;
  }

  function createFiberFromFragment(elements, mode, expirationTime, key) {
    elements = new FiberNode(10, elements, key, mode);
    elements.expirationTime = expirationTime;
    return elements;
  }

  function createFiberFromText(content, mode, expirationTime) {
    content = new FiberNode(6, content, null, mode);
    content.expirationTime = expirationTime;
    return content;
  }

  function createFiberFromPortal(portal, mode, expirationTime) {
    mode = new FiberNode(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 createFiberRoot(containerInfo, isAsync, hydrate) {
    isAsync = new FiberNode(3, null, null, isAsync ? 3 : 0);
    containerInfo = {
      current: isAsync,
      containerInfo: containerInfo,
      pendingChildren: null,
      earliestPendingTime: 0,
      latestPendingTime: 0,
      earliestSuspendedTime: 0,
      latestSuspendedTime: 0,
      latestPingedTime: 0,
      didError: !1,
      pendingCommitExpirationTime: 0,
      finishedWork: null,
      context: null,
      pendingContext: null,
      hydrate: hydrate,
      nextExpirationTimeToWorkOn: 0,
      expirationTime: 0,
      firstBatch: null,
      nextScheduledRoot: null
    };
    return isAsync.stateNode = containerInfo;
  }

  var onCommitFiberRoot = null,
      onCommitFiberUnmount = null;

  function catchErrors(fn) {
    return function (arg) {
      try {
        return fn(arg);
      } catch (err) {}
    };
  }

  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 = catchErrors(function (root) {
        return hook.onCommitFiberRoot(rendererID, root);
      });
      onCommitFiberUnmount = catchErrors(function (fiber) {
        return hook.onCommitFiberUnmount(rendererID, fiber);
      });
    } catch (err) {}

    return !0;
  }

  function onCommitRoot(root) {
    "function" === typeof onCommitFiberRoot && onCommitFiberRoot(root);
  }

  function onCommitUnmount(fiber) {
    "function" === typeof onCommitFiberUnmount && onCommitFiberUnmount(fiber);
  }

  function markPendingPriorityLevel(root, expirationTime) {
    root.didError = !1;
    var earliestPendingTime = root.earliestPendingTime;
    0 === earliestPendingTime ? root.earliestPendingTime = root.latestPendingTime = expirationTime : earliestPendingTime > expirationTime ? root.earliestPendingTime = expirationTime : root.latestPendingTime < expirationTime && (root.latestPendingTime = expirationTime);
    findNextPendingPriorityLevel(root);
  }

  function findNextPendingPriorityLevel(root) {
    var earliestSuspendedTime = root.earliestSuspendedTime,
        earliestPendingTime = root.earliestPendingTime;
    if (0 === earliestSuspendedTime) var nextExpirationTimeToWorkOn = earliestSuspendedTime = earliestPendingTime;else 0 !== earliestPendingTime ? (nextExpirationTimeToWorkOn = earliestPendingTime, earliestSuspendedTime = earliestSuspendedTime < earliestPendingTime ? earliestSuspendedTime : earliestPendingTime) : nextExpirationTimeToWorkOn = earliestSuspendedTime = root.latestPingedTime;
    root.didError && (earliestSuspendedTime = 1);
    root.nextExpirationTimeToWorkOn = nextExpirationTimeToWorkOn;
    root.expirationTime = earliestSuspendedTime;
  }

  var hasForceUpdate = !1;

  function createUpdateQueue(baseState) {
    return {
      expirationTime: 0,
      baseState: baseState,
      firstUpdate: null,
      lastUpdate: null,
      firstCapturedUpdate: null,
      lastCapturedUpdate: null,
      firstEffect: null,
      lastEffect: null,
      firstCapturedEffect: null,
      lastCapturedEffect: null
    };
  }

  function cloneUpdateQueue(currentQueue) {
    return {
      expirationTime: currentQueue.expirationTime,
      baseState: currentQueue.baseState,
      firstUpdate: currentQueue.firstUpdate,
      lastUpdate: currentQueue.lastUpdate,
      firstCapturedUpdate: null,
      lastCapturedUpdate: null,
      firstEffect: null,
      lastEffect: null,
      firstCapturedEffect: null,
      lastCapturedEffect: null
    };
  }

  function createUpdate(expirationTime) {
    return {
      expirationTime: expirationTime,
      tag: 0,
      payload: null,
      callback: null,
      next: null,
      nextEffect: null
    };
  }

  function appendUpdateToQueue(queue, update, expirationTime) {
    null === queue.lastUpdate ? queue.firstUpdate = queue.lastUpdate = update : (queue.lastUpdate.next = update, queue.lastUpdate = update);
    if (0 === queue.expirationTime || queue.expirationTime > expirationTime) queue.expirationTime = expirationTime;
  }

  function enqueueUpdate(fiber, update, expirationTime) {
    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, expirationTime) : null === queue1.lastUpdate || null === queue2.lastUpdate ? (appendUpdateToQueue(queue1, update, expirationTime), appendUpdateToQueue(queue2, update, expirationTime)) : (appendUpdateToQueue(queue1, update, expirationTime), queue2.lastUpdate = update);
  }

  function enqueueCapturedUpdate(workInProgress, update, renderExpirationTime) {
    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);
    if (0 === workInProgressQueue.expirationTime || workInProgressQueue.expirationTime > renderExpirationTime) workInProgressQueue.expirationTime = renderExpirationTime;
  }

  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 & -1025 | 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;

    if (!(0 === queue.expirationTime || queue.expirationTime > renderExpirationTime)) {
      queue = ensureWorkInProgressQueueIsAClone(workInProgress, queue);

      for (var newBaseState = queue.baseState, newFirstUpdate = null, newExpirationTime = 0, update = queue.firstUpdate, resultState = newBaseState; null !== update;) {
        var updateExpirationTime = update.expirationTime;

        if (updateExpirationTime > renderExpirationTime) {
          if (null === newFirstUpdate && (newFirstUpdate = update, newBaseState = resultState), 0 === newExpirationTime || newExpirationTime > updateExpirationTime) newExpirationTime = updateExpirationTime;
        } else 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;

        if (_updateExpirationTime > renderExpirationTime) {
          if (null === updateExpirationTime && (updateExpirationTime = update, null === newFirstUpdate && (newBaseState = resultState)), 0 === newExpirationTime || newExpirationTime > _updateExpirationTime) newExpirationTime = _updateExpirationTime;
        } else 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;
      queue.expirationTime = newExpirationTime;
      workInProgress.memoizedState = resultState;
    }
  }

  function callCallback(callback, context) {
    invariant("function" === typeof callback, "Invalid argument passed as callback. Expected a function. Instead received: %s", callback);
    callback.call(context);
  }

  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);
    finishedWork = finishedQueue.firstEffect;

    for (finishedQueue.firstEffect = finishedQueue.lastEffect = null; null !== finishedWork;) {
      var _callback3 = finishedWork.callback;
      null !== _callback3 && (finishedWork.callback = null, callCallback(_callback3, instance));
      finishedWork = finishedWork.nextEffect;
    }

    finishedWork = finishedQueue.firstCapturedEffect;

    for (finishedQueue.firstCapturedEffect = finishedQueue.lastCapturedEffect = null; null !== finishedWork;) {
      finishedQueue = finishedWork.callback, null !== finishedQueue && (finishedWork.callback = null, callCallback(finishedQueue, instance)), finishedWork = finishedWork.nextEffect;
    }
  }

  function createCapturedValue(value, source) {
    return {
      value: value,
      source: source,
      stack: getStackAddendumByWorkInProgressFiber(source)
    };
  }

  var providerCursor = createCursor(null),
      valueCursor = createCursor(null),
      changedBitsCursor = createCursor(0);

  function pushProvider(providerFiber) {
    var context = providerFiber.type._context;
    push(changedBitsCursor, context._changedBits, providerFiber);
    push(valueCursor, context._currentValue, providerFiber);
    push(providerCursor, providerFiber, providerFiber);
    context._currentValue = providerFiber.pendingProps.value;
    context._changedBits = providerFiber.stateNode;
  }

  function popProvider(providerFiber) {
    var changedBits = changedBitsCursor.current,
        currentValue = valueCursor.current;
    pop(providerCursor, providerFiber);
    pop(valueCursor, providerFiber);
    pop(changedBitsCursor, providerFiber);
    providerFiber = providerFiber.type._context;
    providerFiber._currentValue = currentValue;
    providerFiber._changedBits = changedBits;
  }

  var NO_CONTEXT = {},
      contextStackCursor$1 = createCursor(NO_CONTEXT),
      contextFiberStackCursor = createCursor(NO_CONTEXT),
      rootInstanceStackCursor = createCursor(NO_CONTEXT);

  function requiredContext(c) {
    invariant(c !== NO_CONTEXT, "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 popHostContext(fiber) {
    contextFiberStackCursor.current === fiber && (pop(contextStackCursor$1, fiber), pop(contextFiberStackCursor, fiber));
  }

  var hasOwnProperty = Object.prototype.hasOwnProperty;

  function is(x, y) {
    return x === y ? 0 !== x || 0 !== y || 1 / x === 1 / y : x !== x && y !== y;
  }

  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 applyDerivedStateFromProps(workInProgress, getDerivedStateFromProps, nextProps) {
    var prevState = workInProgress.memoizedState;
    getDerivedStateFromProps = getDerivedStateFromProps(nextProps, prevState);
    prevState = null === getDerivedStateFromProps || void 0 === getDerivedStateFromProps ? prevState : _extends({}, prevState, getDerivedStateFromProps);
    workInProgress.memoizedState = prevState;
    workInProgress = workInProgress.updateQueue;
    null !== workInProgress && 0 === workInProgress.expirationTime && (workInProgress.baseState = prevState);
  }

  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 = recalculateCurrentTime();
      currentTime = computeExpirationForFiber(currentTime, inst);
      var update = createUpdate(currentTime);
      update.payload = payload;
      void 0 !== callback && null !== callback && (update.callback = callback);
      enqueueUpdate(inst, update, currentTime);
      scheduleWork(inst, currentTime);
    },
    enqueueReplaceState: function enqueueReplaceState(inst, payload, callback) {
      inst = inst._reactInternalFiber;
      var currentTime = recalculateCurrentTime();
      currentTime = computeExpirationForFiber(currentTime, inst);
      var update = createUpdate(currentTime);
      update.tag = 1;
      update.payload = payload;
      void 0 !== callback && null !== callback && (update.callback = callback);
      enqueueUpdate(inst, update, currentTime);
      scheduleWork(inst, currentTime);
    },
    enqueueForceUpdate: function enqueueForceUpdate(inst, callback) {
      inst = inst._reactInternalFiber;
      var currentTime = recalculateCurrentTime();
      currentTime = computeExpirationForFiber(currentTime, inst);
      var update = createUpdate(currentTime);
      update.tag = 2;
      void 0 !== callback && null !== callback && (update.callback = callback);
      enqueueUpdate(inst, update, currentTime);
      scheduleWork(inst, currentTime);
    }
  };

  function checkShouldComponentUpdate(workInProgress, oldProps, newProps, oldState, newState, newContext) {
    var instance = workInProgress.stateNode;
    workInProgress = workInProgress.type;
    return "function" === typeof instance.shouldComponentUpdate ? instance.shouldComponentUpdate(newProps, newState, newContext) : workInProgress.prototype && workInProgress.prototype.isPureReactComponent ? !shallowEqual(oldProps, newProps) || !shallowEqual(oldState, newState) : !0;
  }

  function callComponentWillReceiveProps(workInProgress, instance, newProps, newContext) {
    workInProgress = instance.state;
    "function" === typeof instance.componentWillReceiveProps && instance.componentWillReceiveProps(newProps, newContext);
    "function" === typeof instance.UNSAFE_componentWillReceiveProps && instance.UNSAFE_componentWillReceiveProps(newProps, newContext);
    instance.state !== workInProgress && classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
  }

  function mountClassInstance(workInProgress, renderExpirationTime) {
    var ctor = workInProgress.type,
        instance = workInProgress.stateNode,
        props = workInProgress.pendingProps,
        unmaskedContext = getUnmaskedContext(workInProgress);
    instance.props = props;
    instance.state = workInProgress.memoizedState;
    instance.refs = emptyObject;
    instance.context = getMaskedContext(workInProgress, unmaskedContext);
    unmaskedContext = workInProgress.updateQueue;
    null !== unmaskedContext && (processUpdateQueue(workInProgress, unmaskedContext, props, instance, renderExpirationTime), instance.state = workInProgress.memoizedState);
    unmaskedContext = workInProgress.type.getDerivedStateFromProps;
    "function" === typeof unmaskedContext && (applyDerivedStateFromProps(workInProgress, unmaskedContext, props), 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), unmaskedContext = workInProgress.updateQueue, null !== unmaskedContext && (processUpdateQueue(workInProgress, unmaskedContext, props, instance, renderExpirationTime), instance.state = workInProgress.memoizedState));
    "function" === typeof instance.componentDidMount && (workInProgress.effectTag |= 4);
  }

  var isArray$1 = Array.isArray;

  function coerceRef(returnFiber, current, element) {
    returnFiber = element.ref;

    if (null !== returnFiber && "function" !== typeof returnFiber && "object" !== typeof returnFiber) {
      if (element._owner) {
        element = element._owner;
        var inst = void 0;
        element && (invariant(2 === element.tag, "Stateless function components cannot have refs."), inst = element.stateNode);
        invariant(inst, "Missing owner for string ref %s. This error is likely caused by a bug in React. Please file an issue.", returnFiber);
        var stringRef = "" + returnFiber;
        if (null !== current && null !== current.ref && "function" === typeof current.ref && current.ref._stringRef === stringRef) return current.ref;

        current = function current(value) {
          var refs = inst.refs === emptyObject ? inst.refs = {} : inst.refs;
          null === value ? delete refs[stringRef] : refs[stringRef] = value;
        };

        current._stringRef = stringRef;
        return current;
      }

      invariant("string" === typeof returnFiber, "Expected ref to be a function or a string.");
      invariant(element._owner, "Element ref was specified as a string (%s) but no owner was set. This could happen for one of the following reasons:\n1. You may be adding a ref to a functional 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.", returnFiber);
    }

    return returnFiber;
  }

  function throwOnInvalidObjectType(returnFiber, newChild) {
    "textarea" !== returnFiber.type && invariant(!1, "Objects are not valid as a React child (found: %s).%s", "[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, textContent, expirationTime) {
      if (null === current || 6 !== current.tag) return current = createFiberFromText(textContent, returnFiber.mode, expirationTime), current.return = returnFiber, current;
      current = useFiber(current, textContent, expirationTime);
      current.return = returnFiber;
      return current;
    }

    function updateElement(returnFiber, current, element, expirationTime) {
      if (null !== current && current.type === element.type) return expirationTime = useFiber(current, element.props, expirationTime), expirationTime.ref = coerceRef(returnFiber, current, element), expirationTime.return = returnFiber, expirationTime;
      expirationTime = createFiberFromElement(element, returnFiber.mode, expirationTime);
      expirationTime.ref = coerceRef(returnFiber, current, element);
      expirationTime.return = returnFiber;
      return expirationTime;
    }

    function updatePortal(returnFiber, current, portal, expirationTime) {
      if (null === current || 4 !== current.tag || current.stateNode.containerInfo !== portal.containerInfo || current.stateNode.implementation !== portal.implementation) return current = createFiberFromPortal(portal, returnFiber.mode, expirationTime), current.return = returnFiber, current;
      current = useFiber(current, portal.children || [], expirationTime);
      current.return = returnFiber;
      return current;
    }

    function updateFragment(returnFiber, current, fragment, expirationTime, key) {
      if (null === current || 10 !== current.tag) return current = createFiberFromFragment(fragment, returnFiber.mode, expirationTime, key), current.return = returnFiber, current;
      current = useFiber(current, fragment, expirationTime);
      current.return = returnFiber;
      return current;
    }

    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 = createFiberFromElement(newChild, 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$1(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$1(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$1(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++) {
          if (oldFiber = createChild(returnFiber, newChildren[newIdx], expirationTime)) 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++) {
        if (nextOldFiber = updateFromMap(oldFiber, returnFiber, newIdx, newChildren[newIdx], expirationTime)) 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);
      invariant("function" === typeof iteratorFn, "An object is not an iterable. This error is likely caused by a bug in React. Please file an issue.");
      newChildrenIterable = iteratorFn.call(newChildrenIterable);
      invariant(null != newChildrenIterable, "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) {
          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 (10 === isUnkeyedTopLevelFragment.tag ? newChild.type === REACT_FRAGMENT_TYPE : isUnkeyedTopLevelFragment.type === 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;
                } else {
                  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 = createFiberFromElement(newChild, 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;
                } else {
                  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$1(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 2:
        case 1:
          expirationTime = returnFiber.type, invariant(!1, "%s(...): Nothing was returned from render. This usually means a return statement is missing. Or, to render nothing, return null.", expirationTime.displayName || expirationTime.name || "Component");
      }
      return deleteRemainingChildren(returnFiber, currentFirstChild);
    };
  }

  var reconcileChildFibers = ChildReconciler(!0),
      mountChildFibers = ChildReconciler(!1),
      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;

      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 = new FiberNode(5, null, null, 0);
          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;
    }
  }

  function reconcileChildren(current, workInProgress, nextChildren) {
    reconcileChildrenAtExpirationTime(current, workInProgress, nextChildren, workInProgress.expirationTime);
  }

  function reconcileChildrenAtExpirationTime(current, workInProgress, nextChildren, renderExpirationTime) {
    workInProgress.child = null === current ? mountChildFibers(workInProgress, null, nextChildren, renderExpirationTime) : reconcileChildFibers(workInProgress, current.child, nextChildren, renderExpirationTime);
  }

  function markRef(current, workInProgress) {
    var ref = workInProgress.ref;
    if (null === current && null !== ref || null !== current && current.ref !== ref) workInProgress.effectTag |= 128;
  }

  function finishClassComponent(current, workInProgress, shouldUpdate, hasContext, renderExpirationTime) {
    markRef(current, workInProgress);
    var didCaptureError = 0 !== (workInProgress.effectTag & 64);
    if (!shouldUpdate && !didCaptureError) return hasContext && invalidateContextProvider(workInProgress, !1), bailoutOnAlreadyFinishedWork(current, workInProgress);
    shouldUpdate = workInProgress.stateNode;
    ReactCurrentOwner.current = workInProgress;
    var nextChildren = didCaptureError ? null : shouldUpdate.render();
    workInProgress.effectTag |= 1;
    didCaptureError && (reconcileChildrenAtExpirationTime(current, workInProgress, null, renderExpirationTime), workInProgress.child = null);
    reconcileChildrenAtExpirationTime(current, workInProgress, nextChildren, renderExpirationTime);
    workInProgress.memoizedState = shouldUpdate.state;
    workInProgress.memoizedProps = shouldUpdate.props;
    hasContext && invalidateContextProvider(workInProgress, !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);
  }

  function propagateContextChange(workInProgress, context, changedBits, renderExpirationTime) {
    var fiber = workInProgress.child;
    null !== fiber && (fiber.return = workInProgress);

    for (; null !== fiber;) {
      switch (fiber.tag) {
        case 12:
          var nextFiber = fiber.stateNode | 0;

          if (fiber.type === context && 0 !== (nextFiber & changedBits)) {
            for (nextFiber = fiber; null !== nextFiber;) {
              var alternate = nextFiber.alternate;
              if (0 === nextFiber.expirationTime || nextFiber.expirationTime > renderExpirationTime) nextFiber.expirationTime = renderExpirationTime, null !== alternate && (0 === alternate.expirationTime || alternate.expirationTime > renderExpirationTime) && (alternate.expirationTime = renderExpirationTime);else if (null !== alternate && (0 === alternate.expirationTime || alternate.expirationTime > renderExpirationTime)) alternate.expirationTime = renderExpirationTime;else break;
              nextFiber = nextFiber.return;
            }

            nextFiber = null;
          } else nextFiber = fiber.child;

          break;

        case 13:
          nextFiber = fiber.type === workInProgress.type ? null : fiber.child;
          break;

        default:
          nextFiber = fiber.child;
      }

      if (null !== nextFiber) nextFiber.return = fiber;else for (nextFiber = fiber; null !== nextFiber;) {
        if (nextFiber === workInProgress) {
          nextFiber = null;
          break;
        }

        fiber = nextFiber.sibling;

        if (null !== fiber) {
          fiber.return = nextFiber.return;
          nextFiber = fiber;
          break;
        }

        nextFiber = nextFiber.return;
      }
      fiber = nextFiber;
    }
  }

  function updateContextProvider(current, workInProgress, renderExpirationTime) {
    var context = workInProgress.type._context,
        newProps = workInProgress.pendingProps,
        oldProps = workInProgress.memoizedProps,
        canBailOnProps = !0;
    if (didPerformWorkStackCursor.current) canBailOnProps = !1;else if (oldProps === newProps) return workInProgress.stateNode = 0, pushProvider(workInProgress), bailoutOnAlreadyFinishedWork(current, workInProgress);
    var newValue = newProps.value;
    workInProgress.memoizedProps = newProps;
    if (null === oldProps) newValue = 1073741823;else if (oldProps.value === newProps.value) {
      if (oldProps.children === newProps.children && canBailOnProps) return workInProgress.stateNode = 0, pushProvider(workInProgress), bailoutOnAlreadyFinishedWork(current, workInProgress);
      newValue = 0;
    } else {
      var oldValue = oldProps.value;

      if (oldValue === newValue && (0 !== oldValue || 1 / oldValue === 1 / newValue) || oldValue !== oldValue && newValue !== newValue) {
        if (oldProps.children === newProps.children && canBailOnProps) return workInProgress.stateNode = 0, pushProvider(workInProgress), bailoutOnAlreadyFinishedWork(current, workInProgress);
        newValue = 0;
      } else if (newValue = "function" === typeof context._calculateChangedBits ? context._calculateChangedBits(oldValue, newValue) : 1073741823, newValue |= 0, 0 === newValue) {
        if (oldProps.children === newProps.children && canBailOnProps) return workInProgress.stateNode = 0, pushProvider(workInProgress), bailoutOnAlreadyFinishedWork(current, workInProgress);
      } else propagateContextChange(workInProgress, context, newValue, renderExpirationTime);
    }
    workInProgress.stateNode = newValue;
    pushProvider(workInProgress);
    reconcileChildren(current, workInProgress, newProps.children);
    return workInProgress.child;
  }

  function bailoutOnAlreadyFinishedWork(current, workInProgress) {
    invariant(null === current || workInProgress.child === current.child, "Resuming work not yet implemented.");

    if (null !== workInProgress.child) {
      current = workInProgress.child;
      var newChild = createWorkInProgress(current, current.pendingProps, current.expirationTime);
      workInProgress.child = newChild;

      for (newChild.return = workInProgress; null !== current.sibling;) {
        current = current.sibling, newChild = newChild.sibling = createWorkInProgress(current, current.pendingProps, current.expirationTime), newChild.return = workInProgress;
      }

      newChild.sibling = null;
    }

    return workInProgress.child;
  }

  function beginWork(current, workInProgress, renderExpirationTime) {
    if (0 === workInProgress.expirationTime || workInProgress.expirationTime > renderExpirationTime) {
      switch (workInProgress.tag) {
        case 3:
          pushHostRootContext(workInProgress);
          break;

        case 2:
          pushContextProvider(workInProgress);
          break;

        case 4:
          pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
          break;

        case 13:
          pushProvider(workInProgress);
      }

      return null;
    }

    switch (workInProgress.tag) {
      case 0:
        invariant(null === current, "An indeterminate component should never have mounted. This error is likely caused by a bug in React. Please file an issue.");
        var fn = workInProgress.type,
            props = workInProgress.pendingProps,
            unmaskedContext = getUnmaskedContext(workInProgress);
        unmaskedContext = getMaskedContext(workInProgress, unmaskedContext);
        fn = fn(props, unmaskedContext);
        workInProgress.effectTag |= 1;
        "object" === typeof fn && null !== fn && "function" === typeof fn.render && void 0 === fn.$$typeof ? (unmaskedContext = workInProgress.type, workInProgress.tag = 2, workInProgress.memoizedState = null !== fn.state && void 0 !== fn.state ? fn.state : null, unmaskedContext = unmaskedContext.getDerivedStateFromProps, "function" === typeof unmaskedContext && applyDerivedStateFromProps(workInProgress, unmaskedContext, props), props = pushContextProvider(workInProgress), fn.updater = classComponentUpdater, workInProgress.stateNode = fn, fn._reactInternalFiber = workInProgress, mountClassInstance(workInProgress, renderExpirationTime), current = finishClassComponent(current, workInProgress, !0, props, renderExpirationTime)) : (workInProgress.tag = 1, reconcileChildren(current, workInProgress, fn), workInProgress.memoizedProps = props, current = workInProgress.child);
        return current;

      case 1:
        return props = workInProgress.type, renderExpirationTime = workInProgress.pendingProps, didPerformWorkStackCursor.current || workInProgress.memoizedProps !== renderExpirationTime ? (fn = getUnmaskedContext(workInProgress), fn = getMaskedContext(workInProgress, fn), props = props(renderExpirationTime, fn), workInProgress.effectTag |= 1, reconcileChildren(current, workInProgress, props), workInProgress.memoizedProps = renderExpirationTime, current = workInProgress.child) : current = bailoutOnAlreadyFinishedWork(current, workInProgress), current;

      case 2:
        props = pushContextProvider(workInProgress);
        if (null === current) {
          if (null === workInProgress.stateNode) {
            var props$jscomp$0 = workInProgress.pendingProps,
                ctor = workInProgress.type;
            fn = getUnmaskedContext(workInProgress);
            var needsContext = 2 === workInProgress.tag && null != workInProgress.type.contextTypes;
            unmaskedContext = needsContext ? getMaskedContext(workInProgress, fn) : emptyObject;
            props$jscomp$0 = new ctor(props$jscomp$0, unmaskedContext);
            workInProgress.memoizedState = null !== props$jscomp$0.state && void 0 !== props$jscomp$0.state ? props$jscomp$0.state : null;
            props$jscomp$0.updater = classComponentUpdater;
            workInProgress.stateNode = props$jscomp$0;
            props$jscomp$0._reactInternalFiber = workInProgress;
            needsContext && (needsContext = workInProgress.stateNode, needsContext.__reactInternalMemoizedUnmaskedChildContext = fn, needsContext.__reactInternalMemoizedMaskedChildContext = unmaskedContext);
            mountClassInstance(workInProgress, renderExpirationTime);
            fn = !0;
          } else {
            ctor = workInProgress.type;
            fn = workInProgress.stateNode;
            needsContext = workInProgress.memoizedProps;
            unmaskedContext = workInProgress.pendingProps;
            fn.props = needsContext;
            var oldContext = fn.context;
            props$jscomp$0 = getUnmaskedContext(workInProgress);
            props$jscomp$0 = getMaskedContext(workInProgress, props$jscomp$0);
            var getDerivedStateFromProps = ctor.getDerivedStateFromProps;
            (ctor = "function" === typeof getDerivedStateFromProps || "function" === typeof fn.getSnapshotBeforeUpdate) || "function" !== typeof fn.UNSAFE_componentWillReceiveProps && "function" !== typeof fn.componentWillReceiveProps || (needsContext !== unmaskedContext || oldContext !== props$jscomp$0) && callComponentWillReceiveProps(workInProgress, fn, unmaskedContext, props$jscomp$0);
            hasForceUpdate = !1;
            var oldState = workInProgress.memoizedState;
            oldContext = fn.state = oldState;
            var updateQueue = workInProgress.updateQueue;
            null !== updateQueue && (processUpdateQueue(workInProgress, updateQueue, unmaskedContext, fn, renderExpirationTime), oldContext = workInProgress.memoizedState);
            needsContext !== unmaskedContext || oldState !== oldContext || didPerformWorkStackCursor.current || hasForceUpdate ? ("function" === typeof getDerivedStateFromProps && (applyDerivedStateFromProps(workInProgress, getDerivedStateFromProps, unmaskedContext), oldContext = workInProgress.memoizedState), (needsContext = hasForceUpdate || checkShouldComponentUpdate(workInProgress, needsContext, unmaskedContext, oldState, oldContext, props$jscomp$0)) ? (ctor || "function" !== typeof fn.UNSAFE_componentWillMount && "function" !== typeof fn.componentWillMount || ("function" === typeof fn.componentWillMount && fn.componentWillMount(), "function" === typeof fn.UNSAFE_componentWillMount && fn.UNSAFE_componentWillMount()), "function" === typeof fn.componentDidMount && (workInProgress.effectTag |= 4)) : ("function" === typeof fn.componentDidMount && (workInProgress.effectTag |= 4), workInProgress.memoizedProps = unmaskedContext, workInProgress.memoizedState = oldContext), fn.props = unmaskedContext, fn.state = oldContext, fn.context = props$jscomp$0, fn = needsContext) : ("function" === typeof fn.componentDidMount && (workInProgress.effectTag |= 4), fn = !1);
          }
        } else ctor = workInProgress.type, fn = workInProgress.stateNode, unmaskedContext = workInProgress.memoizedProps, needsContext = workInProgress.pendingProps, fn.props = unmaskedContext, oldContext = fn.context, props$jscomp$0 = getUnmaskedContext(workInProgress), props$jscomp$0 = getMaskedContext(workInProgress, props$jscomp$0), getDerivedStateFromProps = ctor.getDerivedStateFromProps, (ctor = "function" === typeof getDerivedStateFromProps || "function" === typeof fn.getSnapshotBeforeUpdate) || "function" !== typeof fn.UNSAFE_componentWillReceiveProps && "function" !== typeof fn.componentWillReceiveProps || (unmaskedContext !== needsContext || oldContext !== props$jscomp$0) && callComponentWillReceiveProps(workInProgress, fn, needsContext, props$jscomp$0), hasForceUpdate = !1, oldContext = workInProgress.memoizedState, oldState = fn.state = oldContext, updateQueue = workInProgress.updateQueue, null !== updateQueue && (processUpdateQueue(workInProgress, updateQueue, needsContext, fn, renderExpirationTime), oldState = workInProgress.memoizedState), unmaskedContext !== needsContext || oldContext !== oldState || didPerformWorkStackCursor.current || hasForceUpdate ? ("function" === typeof getDerivedStateFromProps && (applyDerivedStateFromProps(workInProgress, getDerivedStateFromProps, needsContext), oldState = workInProgress.memoizedState), (getDerivedStateFromProps = hasForceUpdate || checkShouldComponentUpdate(workInProgress, unmaskedContext, needsContext, oldContext, oldState, props$jscomp$0)) ? (ctor || "function" !== typeof fn.UNSAFE_componentWillUpdate && "function" !== typeof fn.componentWillUpdate || ("function" === typeof fn.componentWillUpdate && fn.componentWillUpdate(needsContext, oldState, props$jscomp$0), "function" === typeof fn.UNSAFE_componentWillUpdate && fn.UNSAFE_componentWillUpdate(needsContext, oldState, props$jscomp$0)), "function" === typeof fn.componentDidUpdate && (workInProgress.effectTag |= 4), "function" === typeof fn.getSnapshotBeforeUpdate && (workInProgress.effectTag |= 256)) : ("function" !== typeof fn.componentDidUpdate || unmaskedContext === current.memoizedProps && oldContext === current.memoizedState || (workInProgress.effectTag |= 4), "function" !== typeof fn.getSnapshotBeforeUpdate || unmaskedContext === current.memoizedProps && oldContext === current.memoizedState || (workInProgress.effectTag |= 256), workInProgress.memoizedProps = needsContext, workInProgress.memoizedState = oldState), fn.props = needsContext, fn.state = oldState, fn.context = props$jscomp$0, fn = getDerivedStateFromProps) : ("function" !== typeof fn.componentDidUpdate || unmaskedContext === current.memoizedProps && oldContext === current.memoizedState || (workInProgress.effectTag |= 4), "function" !== typeof fn.getSnapshotBeforeUpdate || unmaskedContext === current.memoizedProps && oldContext === current.memoizedState || (workInProgress.effectTag |= 256), fn = !1);
        return finishClassComponent(current, workInProgress, fn, props, renderExpirationTime);

      case 3:
        return pushHostRootContext(workInProgress), props = workInProgress.updateQueue, null !== props ? (fn = workInProgress.memoizedState, fn = null !== fn ? fn.element : null, processUpdateQueue(workInProgress, props, workInProgress.pendingProps, null, renderExpirationTime), renderExpirationTime = workInProgress.memoizedState.element, renderExpirationTime === fn ? current = bailoutOnAlreadyFinishedWork(current, workInProgress) : (reconcileChildren(current, workInProgress, renderExpirationTime), current = workInProgress.child)) : current = bailoutOnAlreadyFinishedWork(current, workInProgress), current;

      case 5:
        return requiredContext(rootInstanceStackCursor.current), renderExpirationTime = requiredContext(contextStackCursor$1.current), props = workInProgress.type, props = "AndroidTextInput" === props || "RCTMultilineTextInputView" === props || "RCTSinglelineTextInputView" === props || "RCTText" === props || "RCTVirtualText" === props, props = renderExpirationTime.isInAParentText !== props ? {
          isInAParentText: props
        } : renderExpirationTime, renderExpirationTime !== props && (push(contextFiberStackCursor, workInProgress, workInProgress), push(contextStackCursor$1, props, workInProgress)), null === current && tryToClaimNextHydratableInstance(workInProgress), props = workInProgress.memoizedProps, renderExpirationTime = workInProgress.pendingProps, didPerformWorkStackCursor.current || props !== renderExpirationTime ? (props = renderExpirationTime.children, markRef(current, workInProgress), reconcileChildren(current, workInProgress, props), workInProgress.memoizedProps = renderExpirationTime, current = workInProgress.child) : current = bailoutOnAlreadyFinishedWork(current, workInProgress), current;

      case 6:
        return null === current && tryToClaimNextHydratableInstance(workInProgress), workInProgress.memoizedProps = workInProgress.pendingProps, null;

      case 16:
        return null;

      case 4:
        return pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo), props = workInProgress.pendingProps, didPerformWorkStackCursor.current || workInProgress.memoizedProps !== props ? (null === current ? workInProgress.child = reconcileChildFibers(workInProgress, null, props, renderExpirationTime) : reconcileChildren(current, workInProgress, props), workInProgress.memoizedProps = props, current = workInProgress.child) : current = bailoutOnAlreadyFinishedWork(current, workInProgress), current;

      case 14:
        return props = workInProgress.type.render, renderExpirationTime = workInProgress.pendingProps, fn = workInProgress.ref, didPerformWorkStackCursor.current || workInProgress.memoizedProps !== renderExpirationTime || fn !== (null !== current ? current.ref : null) ? (props = props(renderExpirationTime, fn), reconcileChildren(current, workInProgress, props), workInProgress.memoizedProps = renderExpirationTime, current = workInProgress.child) : current = bailoutOnAlreadyFinishedWork(current, workInProgress), current;

      case 10:
        return renderExpirationTime = workInProgress.pendingProps, didPerformWorkStackCursor.current || workInProgress.memoizedProps !== renderExpirationTime ? (reconcileChildren(current, workInProgress, renderExpirationTime), workInProgress.memoizedProps = renderExpirationTime, current = workInProgress.child) : current = bailoutOnAlreadyFinishedWork(current, workInProgress), current;

      case 11:
        return renderExpirationTime = workInProgress.pendingProps.children, didPerformWorkStackCursor.current || null !== renderExpirationTime && workInProgress.memoizedProps !== renderExpirationTime ? (reconcileChildren(current, workInProgress, renderExpirationTime), workInProgress.memoizedProps = renderExpirationTime, current = workInProgress.child) : current = bailoutOnAlreadyFinishedWork(current, workInProgress), current;

      case 15:
        return renderExpirationTime = workInProgress.pendingProps, workInProgress.memoizedProps === renderExpirationTime ? current = bailoutOnAlreadyFinishedWork(current, workInProgress) : (reconcileChildren(current, workInProgress, renderExpirationTime.children), workInProgress.memoizedProps = renderExpirationTime, current = workInProgress.child), current;

      case 13:
        return updateContextProvider(current, workInProgress, renderExpirationTime);

      case 12:
        a: if (fn = workInProgress.type, unmaskedContext = workInProgress.pendingProps, needsContext = workInProgress.memoizedProps, props = fn._currentValue, props$jscomp$0 = fn._changedBits, didPerformWorkStackCursor.current || 0 !== props$jscomp$0 || needsContext !== unmaskedContext) {
          workInProgress.memoizedProps = unmaskedContext;
          ctor = unmaskedContext.unstable_observedBits;
          if (void 0 === ctor || null === ctor) ctor = 1073741823;
          workInProgress.stateNode = ctor;
          if (0 !== (props$jscomp$0 & ctor)) propagateContextChange(workInProgress, fn, props$jscomp$0, renderExpirationTime);else if (needsContext === unmaskedContext) {
            current = bailoutOnAlreadyFinishedWork(current, workInProgress);
            break a;
          }
          renderExpirationTime = unmaskedContext.children;
          renderExpirationTime = renderExpirationTime(props);
          workInProgress.effectTag |= 1;
          reconcileChildren(current, workInProgress, renderExpirationTime);
          current = workInProgress.child;
        } else current = bailoutOnAlreadyFinishedWork(current, workInProgress);

        return current;

      default:
        invariant(!1, "Unknown unit of work tag. This error is likely caused by a bug in React. Please file an issue.");
    }
  }

  var updateHostContainer = void 0,
      updateHostComponent$1 = void 0,
      updateHostText$1 = void 0;

  updateHostContainer = function updateHostContainer() {};

  updateHostComponent$1 = function updateHostComponent$1(current, workInProgress, updatePayload) {
    if (workInProgress.updateQueue = updatePayload) workInProgress.effectTag |= 4;
  };

  updateHostText$1 = function updateHostText$1(current, workInProgress, oldText, newText) {
    oldText !== newText && (workInProgress.effectTag |= 4);
  };

  function completeWork(current, workInProgress) {
    var newProps = workInProgress.pendingProps;

    switch (workInProgress.tag) {
      case 1:
        return null;

      case 2:
        return popContextProvider(workInProgress), null;

      case 3:
        popHostContainer(workInProgress);
        popTopLevelContextObject(workInProgress);
        newProps = workInProgress.stateNode;
        newProps.pendingContext && (newProps.context = newProps.pendingContext, newProps.pendingContext = null);
        if (null === current || null === current.child) workInProgress.effectTag &= -3;
        updateHostContainer(workInProgress);
        return null;

      case 5:
        popHostContext(workInProgress);
        var rootContainerInstance = requiredContext(rootInstanceStackCursor.current),
            type = workInProgress.type;

        if (null !== current && null != workInProgress.stateNode) {
          var oldProps = current.memoizedProps,
              currentHostContext = requiredContext(contextStackCursor$1.current);
          updateHostComponent$1(current, workInProgress, emptyObject, type, oldProps, newProps, rootContainerInstance, currentHostContext);
          current.ref !== workInProgress.ref && (workInProgress.effectTag |= 128);
        } else {
          if (!newProps) return invariant(null !== workInProgress.stateNode, "We must have new props for new mounts. This error is likely caused by a bug in React. Please file an issue."), null;
          current = requiredContext(contextStackCursor$1.current);
          oldProps = allocateTag();
          currentHostContext = ReactNativeViewConfigRegistry.get(type);
          invariant("RCTView" !== type || !current.isInAParentText, "Nesting of <View> within <Text> is not currently supported.");
          var updatePayload = diffProperties(null, emptyObject$1, newProps, currentHostContext.validAttributes);
          UIManager.createView(oldProps, currentHostContext.uiViewClassName, rootContainerInstance, updatePayload);
          currentHostContext = new ReactNativeFiberHostComponent(oldProps, currentHostContext);
          instanceCache[oldProps] = workInProgress;
          instanceProps[oldProps] = newProps;

          a: for (oldProps = workInProgress.child; null !== oldProps;) {
            if (5 === oldProps.tag || 6 === oldProps.tag) currentHostContext._children.push(oldProps.stateNode);else if (4 !== oldProps.tag && null !== oldProps.child) {
              oldProps.child.return = oldProps;
              oldProps = oldProps.child;
              continue;
            }
            if (oldProps === workInProgress) break;

            for (; null === oldProps.sibling;) {
              if (null === oldProps.return || oldProps.return === workInProgress) break a;
              oldProps = oldProps.return;
            }

            oldProps.sibling.return = oldProps.return;
            oldProps = oldProps.sibling;
          }

          finalizeInitialChildren(currentHostContext, type, newProps, rootContainerInstance, current) && (workInProgress.effectTag |= 4);
          workInProgress.stateNode = currentHostContext;
          null !== workInProgress.ref && (workInProgress.effectTag |= 128);
        }

        return null;

      case 6:
        if (current && null != workInProgress.stateNode) updateHostText$1(current, workInProgress, current.memoizedProps, newProps);else {
          if ("string" !== typeof newProps) return invariant(null !== workInProgress.stateNode, "We must have new props for new mounts. This error is likely caused by a bug in React. Please file an issue."), null;
          rootContainerInstance = requiredContext(rootInstanceStackCursor.current);
          type = requiredContext(contextStackCursor$1.current);
          invariant(type.isInAParentText, "Text strings must be rendered within a <Text> component.");
          type = allocateTag();
          UIManager.createView(type, "RCTRawText", rootContainerInstance, {
            text: newProps
          });
          instanceCache[type] = workInProgress;
          workInProgress.stateNode = type;
        }
        return null;

      case 14:
        return null;

      case 16:
        return null;

      case 10:
        return null;

      case 11:
        return null;

      case 15:
        return null;

      case 4:
        return popHostContainer(workInProgress), updateHostContainer(workInProgress), null;

      case 13:
        return popProvider(workInProgress), null;

      case 12:
        return null;

      case 0:
        invariant(!1, "An indeterminate component should have become determinate before completing. This error is likely caused by a bug in React. Please file an issue.");

      default:
        invariant(!1, "Unknown unit of work tag. This error is likely caused by a bug in React. Please file an issue.");
    }
  }

  function logError(boundary, errorInfo) {
    var source = errorInfo.source,
        stack = errorInfo.stack;
    null === stack && null !== source && (stack = getStackAddendumByWorkInProgressFiber(source));
    null !== source && getComponentName(source);
    source = null !== stack ? stack : "";
    errorInfo = errorInfo.value;
    null !== boundary && 2 === boundary.tag && getComponentName(boundary);

    try {
      if (errorInfo instanceof Error) {
        var message = errorInfo.message,
            name = errorInfo.name;
        var errorToHandle = errorInfo;

        try {
          errorToHandle.message = (message ? name + ": " + message : name) + "\n\nThis error is located at:" + source;
        } catch (e) {}
      } else errorToHandle = "string" === typeof errorInfo ? Error(errorInfo + "\n\nThis error is located at:" + source) : Error("Unspecified error at:" + source);

      ExceptionsManager.handleException(errorToHandle, !1);
    } catch (e) {
      e && e.suppressReactErrorLogging || console.error(e);
    }
  }

  function safelyDetachRef(current) {
    var ref = current.ref;
    if (null !== ref) if ("function" === typeof ref) try {
      ref(null);
    } catch (refError) {
      captureCommitPhaseError(current, refError);
    } else ref.current = null;
  }

  function commitUnmount(current) {
    "function" === typeof onCommitUnmount && onCommitUnmount(current);

    switch (current.tag) {
      case 2:
        safelyDetachRef(current);
        var instance = current.stateNode;
        if ("function" === typeof instance.componentWillUnmount) try {
          instance.props = current.memoizedProps, instance.state = current.memoizedState, instance.componentWillUnmount();
        } catch (unmountError) {
          captureCommitPhaseError(current, unmountError);
        }
        break;

      case 5:
        safelyDetachRef(current);
        break;

      case 4:
        unmountHostComponents(current);
    }
  }

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

      invariant(!1, "Expected to find a host parent. This error is likely caused by a bug in React. Please file an issue.");
      parentFiber = void 0;
    }

    var isContainer = parent = void 0;

    switch (parentFiber.tag) {
      case 5:
        parent = parentFiber.stateNode;
        isContainer = !1;
        break;

      case 3:
        parent = parentFiber.stateNode.containerInfo;
        isContainer = !0;
        break;

      case 4:
        parent = parentFiber.stateNode.containerInfo;
        isContainer = !0;
        break;

      default:
        invariant(!1, "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;) {
        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;;) {
      if (5 === node.tag || 6 === node.tag) {
        if (parentFiber) {
          if (isContainer) invariant("number" !== typeof parent, "Container does not support insertBefore operation");else {
            var parentInstance = parent,
                child = node.stateNode,
                beforeChild = parentFiber,
                children = parentInstance._children,
                index = children.indexOf(child);
            0 <= index ? (children.splice(index, 1), beforeChild = children.indexOf(beforeChild), children.splice(beforeChild, 0, child), UIManager.manageChildren(parentInstance._nativeTag, [index], [beforeChild], [], [], [])) : (index = children.indexOf(beforeChild), children.splice(index, 0, child), UIManager.manageChildren(parentInstance._nativeTag, [], [], ["number" === typeof child ? child : child._nativeTag], [index], []));
          }
        } else isContainer ? (parentInstance = node.stateNode, UIManager.setChildren(parent, ["number" === typeof parentInstance ? parentInstance : parentInstance._nativeTag])) : (parentInstance = parent, child = node.stateNode, children = "number" === typeof child ? child : child._nativeTag, index = parentInstance._children, beforeChild = index.indexOf(child), 0 <= beforeChild ? (index.splice(beforeChild, 1), index.push(child), UIManager.manageChildren(parentInstance._nativeTag, [beforeChild], [index.length - 1], [], [], [])) : (index.push(child), UIManager.manageChildren(parentInstance._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) {
    for (var node = current, currentParentIsValid = !1, currentParent = void 0, currentParentIsContainer = void 0;;) {
      if (!currentParentIsValid) {
        currentParentIsValid = node.return;

        a: for (;;) {
          invariant(null !== currentParentIsValid, "Expected to find a host parent. This error is likely caused by a bug in React. Please file an issue.");

          switch (currentParentIsValid.tag) {
            case 5:
              currentParent = currentParentIsValid.stateNode;
              currentParentIsContainer = !1;
              break a;

            case 3:
              currentParent = currentParentIsValid.stateNode.containerInfo;
              currentParentIsContainer = !0;
              break a;

            case 4:
              currentParent = currentParentIsValid.stateNode.containerInfo;
              currentParentIsContainer = !0;
              break a;
          }

          currentParentIsValid = currentParentIsValid.return;
        }

        currentParentIsValid = !0;
      }

      if (5 === node.tag || 6 === node.tag) {
        a: for (var root = node, node$jscomp$0 = root;;) {
          if (commitUnmount(node$jscomp$0), 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;
          }
        }

        if (currentParentIsContainer) root = currentParent, recursivelyUncacheFiberNode(node.stateNode), UIManager.manageChildren(root, [], [], [], [], [0]);else {
          root = currentParent;
          var child = node.stateNode;
          recursivelyUncacheFiberNode(child);
          node$jscomp$0 = root._children;
          child = node$jscomp$0.indexOf(child);
          node$jscomp$0.splice(child, 1);
          UIManager.manageChildren(root._nativeTag, [], [], [], [], [child]);
        }
      } else if (4 === node.tag ? currentParent = node.stateNode.containerInfo : commitUnmount(node), null !== node.child) {
        node.child.return = node;
        node = node.child;
        continue;
      }

      if (node === current) break;

      for (; null === node.sibling;) {
        if (null === node.return || node.return === current) return;
        node = node.return;
        4 === node.tag && (currentParentIsValid = !1);
      }

      node.sibling.return = node.return;
      node = node.sibling;
    }
  }

  function commitWork(current, finishedWork) {
    switch (finishedWork.tag) {
      case 2:
        break;

      case 5:
        var instance = finishedWork.stateNode;

        if (null != instance) {
          var newProps = finishedWork.memoizedProps;
          current = null !== current ? current.memoizedProps : newProps;
          var updatePayload = finishedWork.updateQueue;
          finishedWork.updateQueue = null;
          null !== updatePayload && (finishedWork = instance.viewConfig, instanceProps[instance._nativeTag] = newProps, newProps = diffProperties(null, current, newProps, finishedWork.validAttributes), null != newProps && UIManager.updateView(instance._nativeTag, finishedWork.uiViewClassName, newProps));
        }

        break;

      case 6:
        invariant(null !== finishedWork.stateNode, "This should have a text node initialized. This error is likely caused by a bug in React. Please file an issue.");
        UIManager.updateView(finishedWork.stateNode, "RCTRawText", {
          text: finishedWork.memoizedProps
        });
        break;

      case 3:
        break;

      case 15:
        break;

      case 16:
        break;

      default:
        invariant(!1, "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 createRootErrorUpdate(fiber, errorInfo, expirationTime) {
    expirationTime = createUpdate(expirationTime);
    expirationTime.tag = 3;
    expirationTime.payload = {
      element: null
    };
    var error = errorInfo.value;

    expirationTime.callback = function () {
      onUncaughtError(error);
      logError(fiber, errorInfo);
    };

    return expirationTime;
  }

  function createClassErrorUpdate(fiber, errorInfo, expirationTime) {
    expirationTime = createUpdate(expirationTime);
    expirationTime.tag = 3;
    var inst = fiber.stateNode;
    null !== inst && "function" === typeof inst.componentDidCatch && (expirationTime.callback = function () {
      null === legacyErrorBoundariesThatAlreadyFailed ? legacyErrorBoundariesThatAlreadyFailed = new Set([this]) : legacyErrorBoundariesThatAlreadyFailed.add(this);
      var error = errorInfo.value,
          stack = errorInfo.stack;
      logError(fiber, errorInfo);
      this.componentDidCatch(error, {
        componentStack: null !== stack ? stack : ""
      });
    });
    return expirationTime;
  }

  function unwindWork(workInProgress) {
    switch (workInProgress.tag) {
      case 2:
        popContextProvider(workInProgress);
        var effectTag = workInProgress.effectTag;
        return effectTag & 1024 ? (workInProgress.effectTag = effectTag & -1025 | 64, workInProgress) : null;

      case 3:
        return popHostContainer(workInProgress), popTopLevelContextObject(workInProgress), effectTag = workInProgress.effectTag, effectTag & 1024 ? (workInProgress.effectTag = effectTag & -1025 | 64, workInProgress) : null;

      case 5:
        return popHostContext(workInProgress), null;

      case 16:
        return effectTag = workInProgress.effectTag, effectTag & 1024 ? (workInProgress.effectTag = effectTag & -1025 | 64, workInProgress) : null;

      case 4:
        return popHostContainer(workInProgress), null;

      case 13:
        return popProvider(workInProgress), null;

      default:
        return null;
    }
  }

  var originalStartTimeMs = now$1(),
      mostRecentCurrentTime = 2,
      mostRecentCurrentTimeMs = originalStartTimeMs,
      lastUniqueAsyncExpiration = 0,
      expirationContext = 0,
      isWorking = !1,
      nextUnitOfWork = null,
      nextRoot = null,
      nextRenderExpirationTime = 0,
      nextLatestTimeoutMs = -1,
      nextRenderDidError = !1,
      nextEffect = null,
      isCommitting$1 = !1,
      legacyErrorBoundariesThatAlreadyFailed = null;

  function resetStack() {
    if (null !== nextUnitOfWork) for (var interruptedWork = nextUnitOfWork.return; null !== interruptedWork;) {
      var interruptedWork$jscomp$0 = interruptedWork;

      switch (interruptedWork$jscomp$0.tag) {
        case 2:
          popContextProvider(interruptedWork$jscomp$0);
          break;

        case 3:
          popHostContainer(interruptedWork$jscomp$0);
          popTopLevelContextObject(interruptedWork$jscomp$0);
          break;

        case 5:
          popHostContext(interruptedWork$jscomp$0);
          break;

        case 4:
          popHostContainer(interruptedWork$jscomp$0);
          break;

        case 13:
          popProvider(interruptedWork$jscomp$0);
      }

      interruptedWork = interruptedWork.return;
    }
    nextRoot = null;
    nextRenderExpirationTime = 0;
    nextLatestTimeoutMs = -1;
    nextRenderDidError = !1;
    nextUnitOfWork = null;
  }

  function completeUnitOfWork(workInProgress$jscomp$0) {
    for (;;) {
      var current = workInProgress$jscomp$0.alternate,
          returnFiber = workInProgress$jscomp$0.return,
          siblingFiber = workInProgress$jscomp$0.sibling;

      if (0 === (workInProgress$jscomp$0.effectTag & 512)) {
        current = completeWork(current, workInProgress$jscomp$0, nextRenderExpirationTime);
        var workInProgress = workInProgress$jscomp$0;

        if (1073741823 === nextRenderExpirationTime || 1073741823 !== workInProgress.expirationTime) {
          var newExpirationTime = 0;

          switch (workInProgress.tag) {
            case 3:
            case 2:
              var updateQueue = workInProgress.updateQueue;
              null !== updateQueue && (newExpirationTime = updateQueue.expirationTime);
          }

          for (updateQueue = workInProgress.child; null !== updateQueue;) {
            0 !== updateQueue.expirationTime && (0 === newExpirationTime || newExpirationTime > updateQueue.expirationTime) && (newExpirationTime = updateQueue.expirationTime), updateQueue = updateQueue.sibling;
          }

          workInProgress.expirationTime = newExpirationTime;
        }

        if (null !== current) return current;
        null !== returnFiber && 0 === (returnFiber.effectTag & 512) && (null === returnFiber.firstEffect && (returnFiber.firstEffect = workInProgress$jscomp$0.firstEffect), null !== workInProgress$jscomp$0.lastEffect && (null !== returnFiber.lastEffect && (returnFiber.lastEffect.nextEffect = workInProgress$jscomp$0.firstEffect), returnFiber.lastEffect = workInProgress$jscomp$0.lastEffect), 1 < workInProgress$jscomp$0.effectTag && (null !== returnFiber.lastEffect ? returnFiber.lastEffect.nextEffect = workInProgress$jscomp$0 : returnFiber.firstEffect = workInProgress$jscomp$0, returnFiber.lastEffect = workInProgress$jscomp$0));
      } else {
        workInProgress$jscomp$0 = unwindWork(workInProgress$jscomp$0, nextRenderExpirationTime);
        if (null !== workInProgress$jscomp$0) return workInProgress$jscomp$0.effectTag &= 511, workInProgress$jscomp$0;
        null !== returnFiber && (returnFiber.firstEffect = returnFiber.lastEffect = null, returnFiber.effectTag |= 512);
      }

      if (null !== siblingFiber) return siblingFiber;
      if (null !== returnFiber) workInProgress$jscomp$0 = returnFiber;else break;
    }

    return null;
  }

  function performUnitOfWork(workInProgress) {
    var next = beginWork(workInProgress.alternate, workInProgress, nextRenderExpirationTime);
    null === next && (next = completeUnitOfWork(workInProgress));
    ReactCurrentOwner.current = null;
    return next;
  }

  function renderRoot(root$jscomp$0, isYieldy) {
    invariant(!isWorking, "renderRoot was called recursively. This error is likely caused by a bug in React. Please file an issue.");
    isWorking = !0;
    var expirationTime = root$jscomp$0.nextExpirationTimeToWorkOn;
    if (expirationTime !== nextRenderExpirationTime || root$jscomp$0 !== nextRoot || null === nextUnitOfWork) resetStack(), nextRoot = root$jscomp$0, nextRenderExpirationTime = expirationTime, nextLatestTimeoutMs = -1, nextRenderDidError = !1, nextUnitOfWork = createWorkInProgress(nextRoot.current, null, nextRenderExpirationTime), root$jscomp$0.pendingCommitExpirationTime = 0;
    var didFatal = !1;

    do {
      try {
        if (isYieldy) for (; null !== nextUnitOfWork && !shouldYield();) {
          nextUnitOfWork = performUnitOfWork(nextUnitOfWork);
        } else for (; null !== nextUnitOfWork;) {
          nextUnitOfWork = performUnitOfWork(nextUnitOfWork);
        }
      } catch (thrownValue) {
        if (null === nextUnitOfWork) didFatal = !0, onUncaughtError(thrownValue);else {
          invariant(null !== nextUnitOfWork, "Failed to replay rendering after an error. This is likely caused by a bug in React. Please file an issue with a reproducing case to help us find it.");
          isYieldy = nextUnitOfWork;
          var returnFiber = isYieldy.return;

          if (null === returnFiber) {
            didFatal = !0;
            onUncaughtError(thrownValue);
            break;
          }

          a: {
            var root = root$jscomp$0,
                returnFiber$jscomp$0 = returnFiber,
                sourceFiber = isYieldy,
                value = thrownValue;
            returnFiber = nextRenderExpirationTime;
            sourceFiber.effectTag |= 512;
            sourceFiber.firstEffect = sourceFiber.lastEffect = null;
            nextRenderDidError = !0;

            if ((root.didError || 1 === returnFiber) && (returnFiber === root.latestPendingTime || returnFiber === root.latestSuspendedTime)) {
              value = createCapturedValue(value, sourceFiber);
              root = returnFiber$jscomp$0;

              do {
                switch (root.tag) {
                  case 3:
                    root.effectTag |= 1024;
                    value = createRootErrorUpdate(root, value, returnFiber);
                    enqueueCapturedUpdate(root, value, returnFiber);
                    break a;

                  case 2:
                    if (returnFiber$jscomp$0 = value, sourceFiber = root.stateNode, 0 === (root.effectTag & 64) && null !== sourceFiber && "function" === typeof sourceFiber.componentDidCatch && (null === legacyErrorBoundariesThatAlreadyFailed || !legacyErrorBoundariesThatAlreadyFailed.has(sourceFiber))) {
                      root.effectTag |= 1024;
                      value = createClassErrorUpdate(root, returnFiber$jscomp$0, returnFiber);
                      enqueueCapturedUpdate(root, value, returnFiber);
                      break a;
                    }

                }

                root = root.return;
              } while (null !== root);
            }
          }

          nextUnitOfWork = completeUnitOfWork(isYieldy);
        }
      }

      break;
    } while (1);

    isWorking = !1;
    didFatal ? root$jscomp$0.finishedWork = null : null === nextUnitOfWork ? (didFatal = root$jscomp$0.current.alternate, invariant(null !== didFatal, "Finished root should have a work-in-progress. This error is likely caused by a bug in React. Please file an issue."), 0 === (didFatal.effectTag & 512) ? (root$jscomp$0.pendingCommitExpirationTime = expirationTime, root$jscomp$0.finishedWork = didFatal) : (!nextRenderDidError || expirationTime !== root$jscomp$0.latestPendingTime && expirationTime !== root$jscomp$0.latestSuspendedTime ? (didFatal = root$jscomp$0.earliestPendingTime, isYieldy = root$jscomp$0.latestPendingTime, didFatal === expirationTime ? root$jscomp$0.earliestPendingTime = isYieldy === expirationTime ? root$jscomp$0.latestPendingTime = 0 : isYieldy : isYieldy === expirationTime && (root$jscomp$0.latestPendingTime = didFatal), didFatal = root$jscomp$0.latestSuspendedTime, didFatal === expirationTime && (root$jscomp$0.latestPingedTime = 0), isYieldy = root$jscomp$0.earliestSuspendedTime, 0 === isYieldy ? root$jscomp$0.earliestSuspendedTime = root$jscomp$0.latestSuspendedTime = expirationTime : isYieldy > expirationTime ? root$jscomp$0.earliestSuspendedTime = expirationTime : didFatal < expirationTime && (root$jscomp$0.latestSuspendedTime = expirationTime)) : root$jscomp$0.didError = !0, findNextPendingPriorityLevel(root$jscomp$0), onSuspend(root$jscomp$0, expirationTime, root$jscomp$0.expirationTime, nextLatestTimeoutMs))) : root$jscomp$0.finishedWork = null;
  }

  function captureCommitPhaseError(fiber, error) {
    var JSCompiler_inline_result;

    a: {
      invariant(!isWorking || isCommitting$1, "dispatch: Cannot dispatch during the render phase.");

      for (JSCompiler_inline_result = fiber.return; null !== JSCompiler_inline_result;) {
        switch (JSCompiler_inline_result.tag) {
          case 2:
            var instance = JSCompiler_inline_result.stateNode;

            if ("function" === typeof JSCompiler_inline_result.type.getDerivedStateFromCatch || "function" === typeof instance.componentDidCatch && (null === legacyErrorBoundariesThatAlreadyFailed || !legacyErrorBoundariesThatAlreadyFailed.has(instance))) {
              fiber = createCapturedValue(error, fiber);
              fiber = createClassErrorUpdate(JSCompiler_inline_result, fiber, 1);
              enqueueUpdate(JSCompiler_inline_result, fiber, 1);
              scheduleWork(JSCompiler_inline_result, 1);
              JSCompiler_inline_result = void 0;
              break a;
            }

            break;

          case 3:
            fiber = createCapturedValue(error, fiber);
            fiber = createRootErrorUpdate(JSCompiler_inline_result, fiber, 1);
            enqueueUpdate(JSCompiler_inline_result, fiber, 1);
            scheduleWork(JSCompiler_inline_result, 1);
            JSCompiler_inline_result = void 0;
            break a;
        }

        JSCompiler_inline_result = JSCompiler_inline_result.return;
      }

      3 === fiber.tag && (JSCompiler_inline_result = createCapturedValue(error, fiber), JSCompiler_inline_result = createRootErrorUpdate(fiber, JSCompiler_inline_result, 1), enqueueUpdate(fiber, JSCompiler_inline_result, 1), scheduleWork(fiber, 1));
      JSCompiler_inline_result = void 0;
    }

    return JSCompiler_inline_result;
  }

  function computeExpirationForFiber(currentTime, fiber) {
    currentTime = 0 !== expirationContext ? expirationContext : isWorking ? isCommitting$1 ? 1 : nextRenderExpirationTime : fiber.mode & 1 ? isBatchingInteractiveUpdates ? 2 + 10 * (((currentTime - 2 + 15) / 10 | 0) + 1) : 2 + 25 * (((currentTime - 2 + 500) / 25 | 0) + 1) : 1;
    isBatchingInteractiveUpdates && (0 === lowestPendingInteractiveExpirationTime || currentTime > lowestPendingInteractiveExpirationTime) && (lowestPendingInteractiveExpirationTime = currentTime);
    return currentTime;
  }

  function scheduleWork(fiber, expirationTime) {
    for (; null !== fiber;) {
      if (0 === fiber.expirationTime || fiber.expirationTime > expirationTime) fiber.expirationTime = expirationTime;
      null !== fiber.alternate && (0 === fiber.alternate.expirationTime || fiber.alternate.expirationTime > expirationTime) && (fiber.alternate.expirationTime = expirationTime);
      if (null === fiber.return) if (3 === fiber.tag) {
        var root = fiber.stateNode;
        !isWorking && 0 !== nextRenderExpirationTime && expirationTime < nextRenderExpirationTime && resetStack();
        markPendingPriorityLevel(root, expirationTime);
        isWorking && !isCommitting$1 && nextRoot === root || requestWork(root, root.expirationTime);
        nestedUpdateCount > NESTED_UPDATE_LIMIT && invariant(!1, "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.");
      } else break;
      fiber = fiber.return;
    }
  }

  function recalculateCurrentTime() {
    mostRecentCurrentTimeMs = now$1() - originalStartTimeMs;
    return mostRecentCurrentTime = (mostRecentCurrentTimeMs / 10 | 0) + 2;
  }

  function syncUpdates(fn, a, b, c, d) {
    var previousExpirationContext = expirationContext;
    expirationContext = 1;

    try {
      return fn(a, b, c, d);
    } finally {
      expirationContext = previousExpirationContext;
    }
  }

  var firstScheduledRoot = null,
      lastScheduledRoot = null,
      callbackExpirationTime = 0,
      callbackID = void 0,
      isRendering = !1,
      nextFlushedRoot = null,
      nextFlushedExpirationTime = 0,
      lowestPendingInteractiveExpirationTime = 0,
      deadlineDidExpire = !1,
      hasUnhandledError = !1,
      unhandledError = null,
      deadline = null,
      isBatchingUpdates = !1,
      isUnbatchingUpdates = !1,
      isBatchingInteractiveUpdates = !1,
      completedBatches = null,
      NESTED_UPDATE_LIMIT = 1e3,
      nestedUpdateCount = 0,
      timeHeuristicForUnitOfWork = 1;

  function scheduleCallbackWithExpirationTime(expirationTime) {
    if (0 !== callbackExpirationTime) {
      if (expirationTime > callbackExpirationTime) return;

      if (null !== callbackID) {
        var callbackID$jscomp$0 = callbackID;
        scheduledCallback = null;
        clearTimeout(callbackID$jscomp$0);
      }
    }

    callbackExpirationTime = expirationTime;
    now$1();
    scheduledCallback = performAsyncWork;
    callbackID = setTimeout(setTimeoutCallback, 1);
  }

  function onSuspend(root, suspendedExpirationTime, expirationTime, timeoutMs) {
    0 <= timeoutMs && setTimeout(function () {
      var latestSuspendedTime = root.latestSuspendedTime;
      0 !== latestSuspendedTime && latestSuspendedTime <= suspendedExpirationTime && (latestSuspendedTime = root.latestPingedTime, 0 === latestSuspendedTime || latestSuspendedTime < suspendedExpirationTime) && (root.latestPingedTime = suspendedExpirationTime);
      findNextPendingPriorityLevel(root);
      latestSuspendedTime = root.expirationTime;
      0 !== latestSuspendedTime && requestWork(root, latestSuspendedTime);
    }, timeoutMs);
    root.expirationTime = expirationTime;
  }

  function requestWork(root, expirationTime) {
    if (null === root.nextScheduledRoot) root.expirationTime = expirationTime, null === lastScheduledRoot ? (firstScheduledRoot = lastScheduledRoot = root, root.nextScheduledRoot = root) : (lastScheduledRoot = lastScheduledRoot.nextScheduledRoot = root, lastScheduledRoot.nextScheduledRoot = firstScheduledRoot);else {
      var remainingExpirationTime = root.expirationTime;
      if (0 === remainingExpirationTime || expirationTime < remainingExpirationTime) root.expirationTime = expirationTime;
    }
    isRendering || (isBatchingUpdates ? isUnbatchingUpdates && (nextFlushedRoot = root, nextFlushedExpirationTime = 1, performWorkOnRoot(root, 1, !1)) : 1 === expirationTime ? performWork(1, null) : scheduleCallbackWithExpirationTime(expirationTime));
  }

  function findHighestPriorityRoot() {
    var highestPriorityWork = 0,
        highestPriorityRoot = null;
    if (null !== lastScheduledRoot) for (var previousScheduledRoot = lastScheduledRoot, root = firstScheduledRoot; null !== root;) {
      var remainingExpirationTime = root.expirationTime;

      if (0 === remainingExpirationTime) {
        invariant(null !== previousScheduledRoot && null !== lastScheduledRoot, "Should have a previous and last root. This error is likely caused by a bug in React. Please file an issue.");

        if (root === root.nextScheduledRoot) {
          firstScheduledRoot = lastScheduledRoot = root.nextScheduledRoot = null;
          break;
        } else if (root === firstScheduledRoot) firstScheduledRoot = remainingExpirationTime = root.nextScheduledRoot, lastScheduledRoot.nextScheduledRoot = remainingExpirationTime, root.nextScheduledRoot = null;else if (root === lastScheduledRoot) {
          lastScheduledRoot = previousScheduledRoot;
          lastScheduledRoot.nextScheduledRoot = firstScheduledRoot;
          root.nextScheduledRoot = null;
          break;
        } else previousScheduledRoot.nextScheduledRoot = root.nextScheduledRoot, root.nextScheduledRoot = null;

        root = previousScheduledRoot.nextScheduledRoot;
      } else {
        if (0 === highestPriorityWork || remainingExpirationTime < highestPriorityWork) highestPriorityWork = remainingExpirationTime, highestPriorityRoot = root;
        if (root === lastScheduledRoot) break;
        previousScheduledRoot = root;
        root = root.nextScheduledRoot;
      }
    }
    previousScheduledRoot = nextFlushedRoot;
    null !== previousScheduledRoot && previousScheduledRoot === highestPriorityRoot && 1 === highestPriorityWork ? nestedUpdateCount++ : nestedUpdateCount = 0;
    nextFlushedRoot = highestPriorityRoot;
    nextFlushedExpirationTime = highestPriorityWork;
  }

  function performAsyncWork(dl) {
    performWork(0, dl);
  }

  function performWork(minExpirationTime, dl) {
    deadline = dl;
    findHighestPriorityRoot();
    if (null !== deadline) for (; null !== nextFlushedRoot && 0 !== nextFlushedExpirationTime && (0 === minExpirationTime || minExpirationTime >= nextFlushedExpirationTime) && (!deadlineDidExpire || recalculateCurrentTime() >= nextFlushedExpirationTime);) {
      recalculateCurrentTime(), performWorkOnRoot(nextFlushedRoot, nextFlushedExpirationTime, !0), findHighestPriorityRoot();
    } else for (; null !== nextFlushedRoot && 0 !== nextFlushedExpirationTime && (0 === minExpirationTime || minExpirationTime >= nextFlushedExpirationTime);) {
      performWorkOnRoot(nextFlushedRoot, nextFlushedExpirationTime, !1), findHighestPriorityRoot();
    }
    null !== deadline && (callbackExpirationTime = 0, callbackID = null);
    0 !== nextFlushedExpirationTime && scheduleCallbackWithExpirationTime(nextFlushedExpirationTime);
    deadline = null;
    deadlineDidExpire = !1;
    finishRendering();
  }

  function finishRendering() {
    nestedUpdateCount = 0;

    if (null !== completedBatches) {
      var batches = completedBatches;
      completedBatches = null;

      for (var i = 0; i < batches.length; i++) {
        var batch = batches[i];

        try {
          batch._onComplete();
        } catch (error) {
          hasUnhandledError || (hasUnhandledError = !0, unhandledError = error);
        }
      }
    }

    if (hasUnhandledError) throw batches = unhandledError, unhandledError = null, hasUnhandledError = !1, batches;
  }

  function performWorkOnRoot(root, expirationTime, isYieldy) {
    invariant(!isRendering, "performWorkOnRoot was called recursively. This error is likely caused by a bug in React. Please file an issue.");
    isRendering = !0;
    isYieldy ? (isYieldy = root.finishedWork, null !== isYieldy ? completeRoot(root, isYieldy, expirationTime) : (root.finishedWork = null, renderRoot(root, !0), isYieldy = root.finishedWork, null !== isYieldy && (shouldYield() ? root.finishedWork = isYieldy : completeRoot(root, isYieldy, expirationTime)))) : (isYieldy = root.finishedWork, null !== isYieldy ? completeRoot(root, isYieldy, expirationTime) : (root.finishedWork = null, renderRoot(root, !1), isYieldy = root.finishedWork, null !== isYieldy && completeRoot(root, isYieldy, expirationTime)));
    isRendering = !1;
  }

  function completeRoot(root, finishedWork$jscomp$0, expirationTime) {
    var firstBatch = root.firstBatch;

    if (null !== firstBatch && firstBatch._expirationTime <= expirationTime && (null === completedBatches ? completedBatches = [firstBatch] : completedBatches.push(firstBatch), firstBatch._defer)) {
      root.finishedWork = finishedWork$jscomp$0;
      root.expirationTime = 0;
      return;
    }

    root.finishedWork = null;
    isCommitting$1 = isWorking = !0;
    invariant(root.current !== finishedWork$jscomp$0, "Cannot commit the same tree as before. This is probably a bug related to the return field. This error is likely caused by a bug in React. Please file an issue.");
    expirationTime = root.pendingCommitExpirationTime;
    invariant(0 !== expirationTime, "Cannot commit an incomplete root. This error is likely caused by a bug in React. Please file an issue.");
    root.pendingCommitExpirationTime = 0;
    firstBatch = finishedWork$jscomp$0.expirationTime;
    recalculateCurrentTime();
    root.didError = !1;
    if (0 === firstBatch) root.earliestPendingTime = 0, root.latestPendingTime = 0, root.earliestSuspendedTime = 0, root.latestSuspendedTime = 0, root.latestPingedTime = 0;else {
      var latestPendingTime = root.latestPendingTime;
      0 !== latestPendingTime && (latestPendingTime < firstBatch ? root.earliestPendingTime = root.latestPendingTime = 0 : root.earliestPendingTime < firstBatch && (root.earliestPendingTime = root.latestPendingTime));
      latestPendingTime = root.earliestSuspendedTime;
      0 === latestPendingTime ? markPendingPriorityLevel(root, firstBatch) : firstBatch > root.latestSuspendedTime ? (root.earliestSuspendedTime = 0, root.latestSuspendedTime = 0, root.latestPingedTime = 0, markPendingPriorityLevel(root, firstBatch)) : firstBatch < latestPendingTime && markPendingPriorityLevel(root, firstBatch);
    }
    findNextPendingPriorityLevel(root);
    ReactCurrentOwner.current = null;
    1 < finishedWork$jscomp$0.effectTag ? null !== finishedWork$jscomp$0.lastEffect ? (finishedWork$jscomp$0.lastEffect.nextEffect = finishedWork$jscomp$0, firstBatch = finishedWork$jscomp$0.firstEffect) : firstBatch = finishedWork$jscomp$0 : firstBatch = finishedWork$jscomp$0.firstEffect;

    for (nextEffect = firstBatch; null !== nextEffect;) {
      latestPendingTime = !1;
      var error = void 0;

      try {
        for (; null !== nextEffect;) {
          if (nextEffect.effectTag & 256) {
            var current = nextEffect.alternate,
                finishedWork = nextEffect;

            switch (finishedWork.tag) {
              case 2:
                if (finishedWork.effectTag & 256 && null !== current) {
                  var prevProps = current.memoizedProps,
                      prevState = current.memoizedState,
                      instance = finishedWork.stateNode;
                  instance.props = finishedWork.memoizedProps;
                  instance.state = finishedWork.memoizedState;
                  var snapshot = instance.getSnapshotBeforeUpdate(prevProps, prevState);
                  instance.__reactInternalSnapshotBeforeUpdate = snapshot;
                }

                break;

              case 3:
              case 5:
              case 6:
              case 4:
                break;

              default:
                invariant(!1, "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 (e) {
        latestPendingTime = !0, error = e;
      }

      latestPendingTime && (invariant(null !== nextEffect, "Should have next effect. This error is likely caused by a bug in React. Please file an issue."), captureCommitPhaseError(nextEffect, error), null !== nextEffect && (nextEffect = nextEffect.nextEffect));
    }

    for (nextEffect = firstBatch; null !== nextEffect;) {
      current = !1;
      prevProps = void 0;

      try {
        for (; null !== nextEffect;) {
          var effectTag = nextEffect.effectTag;

          if (effectTag & 128) {
            var current$jscomp$0 = nextEffect.alternate;

            if (null !== current$jscomp$0) {
              var currentRef = current$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:
              prevState = nextEffect, unmountHostComponents(prevState), prevState.return = null, prevState.child = null, prevState.alternate && (prevState.alternate.child = null, prevState.alternate.return = null);
          }

          nextEffect = nextEffect.nextEffect;
        }
      } catch (e) {
        current = !0, prevProps = e;
      }

      current && (invariant(null !== nextEffect, "Should have next effect. This error is likely caused by a bug in React. Please file an issue."), captureCommitPhaseError(nextEffect, prevProps), null !== nextEffect && (nextEffect = nextEffect.nextEffect));
    }

    root.current = finishedWork$jscomp$0;

    for (nextEffect = firstBatch; null !== nextEffect;) {
      effectTag = !1;
      current$jscomp$0 = void 0;

      try {
        for (currentRef = expirationTime; null !== nextEffect;) {
          var effectTag$jscomp$0 = nextEffect.effectTag;

          if (effectTag$jscomp$0 & 36) {
            var current$jscomp$1 = nextEffect.alternate;
            current = nextEffect;
            prevProps = currentRef;

            switch (current.tag) {
              case 2:
                var instance$jscomp$0 = current.stateNode;
                if (current.effectTag & 4) if (null === current$jscomp$1) instance$jscomp$0.props = current.memoizedProps, instance$jscomp$0.state = current.memoizedState, instance$jscomp$0.componentDidMount();else {
                  var prevProps$jscomp$0 = current$jscomp$1.memoizedProps,
                      prevState$jscomp$0 = current$jscomp$1.memoizedState;
                  instance$jscomp$0.props = current.memoizedProps;
                  instance$jscomp$0.state = current.memoizedState;
                  instance$jscomp$0.componentDidUpdate(prevProps$jscomp$0, prevState$jscomp$0, instance$jscomp$0.__reactInternalSnapshotBeforeUpdate);
                }
                var updateQueue = current.updateQueue;
                null !== updateQueue && (instance$jscomp$0.props = current.memoizedProps, instance$jscomp$0.state = current.memoizedState, commitUpdateQueue(current, updateQueue, instance$jscomp$0, prevProps));
                break;

              case 3:
                var _updateQueue = current.updateQueue;

                if (null !== _updateQueue) {
                  prevState = null;
                  if (null !== current.child) switch (current.child.tag) {
                    case 5:
                      prevState = current.child.stateNode;
                      break;

                    case 2:
                      prevState = current.child.stateNode;
                  }
                  commitUpdateQueue(current, _updateQueue, prevState, prevProps);
                }

                break;

              case 5:
                break;

              case 6:
                break;

              case 4:
                break;

              case 15:
                break;

              case 16:
                break;

              default:
                invariant(!1, "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) {
            current = void 0;
            var ref = nextEffect.ref;

            if (null !== ref) {
              var instance$jscomp$1 = nextEffect.stateNode;

              switch (nextEffect.tag) {
                case 5:
                  current = instance$jscomp$1;
                  break;

                default:
                  current = instance$jscomp$1;
              }

              "function" === typeof ref ? ref(current) : ref.current = current;
            }
          }

          var next = nextEffect.nextEffect;
          nextEffect.nextEffect = null;
          nextEffect = next;
        }
      } catch (e) {
        effectTag = !0, current$jscomp$0 = e;
      }

      effectTag && (invariant(null !== nextEffect, "Should have next effect. This error is likely caused by a bug in React. Please file an issue."), captureCommitPhaseError(nextEffect, current$jscomp$0), null !== nextEffect && (nextEffect = nextEffect.nextEffect));
    }

    isWorking = isCommitting$1 = !1;
    "function" === typeof onCommitRoot && onCommitRoot(finishedWork$jscomp$0.stateNode);
    finishedWork$jscomp$0 = root.expirationTime;
    0 === finishedWork$jscomp$0 && (legacyErrorBoundariesThatAlreadyFailed = null);
    root.expirationTime = finishedWork$jscomp$0;
    root.finishedWork = null;
  }

  function shouldYield() {
    return null === deadline || deadlineDidExpire || deadline.timeRemaining() > timeHeuristicForUnitOfWork ? !1 : deadlineDidExpire = !0;
  }

  function onUncaughtError(error) {
    invariant(null !== nextFlushedRoot, "Should be working on a root. This error is likely caused by a bug in React. Please file an issue.");
    nextFlushedRoot.expirationTime = 0;
    hasUnhandledError || (hasUnhandledError = !0, unhandledError = error);
  }

  function updateContainerAtExpirationTime(element, container, parentComponent, expirationTime, callback) {
    var current = container.current;

    if (parentComponent) {
      parentComponent = parentComponent._reactInternalFiber;
      var parentContext;

      b: {
        invariant(2 === isFiberMountedImpl(parentComponent) && 2 === parentComponent.tag, "Expected subtree parent to be a mounted class component. This error is likely caused by a bug in React. Please file an issue.");

        for (parentContext = parentComponent; 3 !== parentContext.tag;) {
          if (isContextProvider(parentContext)) {
            parentContext = parentContext.stateNode.__reactInternalMemoizedMergedChildContext;
            break b;
          }

          parentContext = parentContext.return;
          invariant(parentContext, "Found unexpected detached subtree parent. This error is likely caused by a bug in React. Please file an issue.");
        }

        parentContext = parentContext.stateNode.context;
      }

      parentComponent = isContextProvider(parentComponent) ? processChildContext(parentComponent, parentContext) : parentContext;
    } else parentComponent = emptyObject;

    null === container.context ? container.context = parentComponent : container.pendingContext = parentComponent;
    container = callback;
    callback = createUpdate(expirationTime);
    callback.payload = {
      element: element
    };
    container = void 0 === container ? null : container;
    null !== container && (callback.callback = container);
    enqueueUpdate(current, callback, expirationTime);
    scheduleWork(current, expirationTime);
    return expirationTime;
  }

  function findHostInstance$1(component) {
    var fiber = component._reactInternalFiber;
    void 0 === fiber && ("function" === typeof component.render ? invariant(!1, "Unable to find node on an unmounted component.") : invariant(!1, "Argument appears to not be a ReactComponent. Keys: %s", Object.keys(component)));
    component = findCurrentHostFiber(fiber);
    return null === component ? null : component.stateNode;
  }

  function updateContainer(element, container, parentComponent, callback) {
    var current = container.current,
        currentTime = recalculateCurrentTime();
    current = computeExpirationForFiber(currentTime, current);
    return updateContainerAtExpirationTime(element, container, parentComponent, current, callback);
  }

  function getPublicRootInstance(container) {
    container = container.current;
    if (!container.child) return null;

    switch (container.child.tag) {
      case 5:
        return container.child.stateNode;

      default:
        return container.child.stateNode;
    }
  }

  function injectIntoDevTools(devToolsConfig) {
    var _findFiberByHostInstance = devToolsConfig.findFiberByHostInstance;
    return injectInternals(_extends({}, devToolsConfig, {
      findHostInstanceByFiber: function findHostInstanceByFiber(fiber) {
        fiber = findCurrentHostFiber(fiber);
        return null === fiber ? null : fiber.stateNode;
      },
      findFiberByHostInstance: function findFiberByHostInstance(instance) {
        return _findFiberByHostInstance ? _findFiberByHostInstance(instance) : null;
      }
    }));
  }

  var ReactNativeFiberRenderer = {
    updateContainerAtExpirationTime: updateContainerAtExpirationTime,
    createContainer: function createContainer(containerInfo, isAsync, hydrate) {
      return createFiberRoot(containerInfo, isAsync, hydrate);
    },
    updateContainer: updateContainer,
    flushRoot: function flushRoot(root, expirationTime) {
      invariant(!isRendering, "work.commit(): Cannot commit while already rendering. This likely means you attempted to commit from inside a lifecycle method.");
      nextFlushedRoot = root;
      nextFlushedExpirationTime = expirationTime;
      performWorkOnRoot(root, expirationTime, !1);
      performWork(1, null);
      finishRendering();
    },
    requestWork: requestWork,
    computeUniqueAsyncExpiration: function computeUniqueAsyncExpiration() {
      var result = 2 + 25 * (((recalculateCurrentTime() - 2 + 500) / 25 | 0) + 1);
      result <= lastUniqueAsyncExpiration && (result = lastUniqueAsyncExpiration + 1);
      return lastUniqueAsyncExpiration = result;
    },
    batchedUpdates: function batchedUpdates(fn, a) {
      var previousIsBatchingUpdates = isBatchingUpdates;
      isBatchingUpdates = !0;

      try {
        return fn(a);
      } finally {
        (isBatchingUpdates = previousIsBatchingUpdates) || isRendering || performWork(1, null);
      }
    },
    unbatchedUpdates: function unbatchedUpdates(fn, a) {
      if (isBatchingUpdates && !isUnbatchingUpdates) {
        isUnbatchingUpdates = !0;

        try {
          return fn(a);
        } finally {
          isUnbatchingUpdates = !1;
        }
      }

      return fn(a);
    },
    deferredUpdates: function deferredUpdates(fn) {
      var previousExpirationContext = expirationContext;
      expirationContext = 2 + 25 * (((recalculateCurrentTime() - 2 + 500) / 25 | 0) + 1);

      try {
        return fn();
      } finally {
        expirationContext = previousExpirationContext;
      }
    },
    syncUpdates: syncUpdates,
    interactiveUpdates: function interactiveUpdates(fn, a, b) {
      if (isBatchingInteractiveUpdates) return fn(a, b);
      isBatchingUpdates || isRendering || 0 === lowestPendingInteractiveExpirationTime || (performWork(lowestPendingInteractiveExpirationTime, null), lowestPendingInteractiveExpirationTime = 0);
      var previousIsBatchingInteractiveUpdates = isBatchingInteractiveUpdates,
          previousIsBatchingUpdates = isBatchingUpdates;
      isBatchingUpdates = isBatchingInteractiveUpdates = !0;

      try {
        return fn(a, b);
      } finally {
        isBatchingInteractiveUpdates = previousIsBatchingInteractiveUpdates, (isBatchingUpdates = previousIsBatchingUpdates) || isRendering || performWork(1, null);
      }
    },
    flushInteractiveUpdates: function flushInteractiveUpdates() {
      isRendering || 0 === lowestPendingInteractiveExpirationTime || (performWork(lowestPendingInteractiveExpirationTime, null), lowestPendingInteractiveExpirationTime = 0);
    },
    flushControlled: function flushControlled(fn) {
      var previousIsBatchingUpdates = isBatchingUpdates;
      isBatchingUpdates = !0;

      try {
        syncUpdates(fn);
      } finally {
        (isBatchingUpdates = previousIsBatchingUpdates) || isRendering || performWork(1, null);
      }
    },
    flushSync: function flushSync(fn, a) {
      invariant(!isRendering, "flushSync was called from inside a lifecycle method. It cannot be called when React is already rendering.");
      var previousIsBatchingUpdates = isBatchingUpdates;
      isBatchingUpdates = !0;

      try {
        return syncUpdates(fn, a);
      } finally {
        isBatchingUpdates = previousIsBatchingUpdates, performWork(1, null);
      }
    },
    getPublicRootInstance: getPublicRootInstance,
    findHostInstance: findHostInstance$1,
    findHostInstanceWithNoPortals: function findHostInstanceWithNoPortals(fiber) {
      fiber = findCurrentHostFiberWithNoPortals(fiber);
      return null === fiber ? null : fiber.stateNode;
    },
    injectIntoDevTools: injectIntoDevTools
  };

  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() {
    invariant(!1, "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$1(componentOrHandle);
    return null == componentOrHandle ? componentOrHandle : componentOrHandle.canonical ? componentOrHandle.canonical._nativeTag : componentOrHandle._nativeTag;
  }

  _batchedUpdates = ReactNativeFiberRenderer.batchedUpdates;
  _flushInteractiveUpdates = ReactNativeFiberRenderer.flushInteractiveUpdates;
  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 () {
          TextInputState.blurTextInput(findNodeHandle(this));
        };

        ReactNativeComponent.prototype.focus = function () {
          TextInputState.focusTextInput(findNodeHandle(this));
        };

        ReactNativeComponent.prototype.measure = function (callback) {
          UIManager.measure(findNodeHandle(this), mountSafeCallback(this, callback));
        };

        ReactNativeComponent.prototype.measureInWindow = function (callback) {
          UIManager.measureInWindow(findNodeHandle(this), mountSafeCallback(this, callback));
        };

        ReactNativeComponent.prototype.measureLayout = function (relativeToNativeNode, onSuccess, onFail) {
          UIManager.measureLayout(findNodeHandle(this), relativeToNativeNode, mountSafeCallback(this, onFail), mountSafeCallback(this, onSuccess));
        };

        ReactNativeComponent.prototype.setNativeProps = function (nativeProps) {
          var maybeInstance = void 0;

          try {
            maybeInstance = findHostInstance(this);
          } catch (error) {}

          if (null != maybeInstance) {
            var viewConfig = maybeInstance.viewConfig || maybeInstance.canonical.viewConfig;
            nativeProps = diffProperties(null, emptyObject$1, nativeProps, viewConfig.validAttributes);
            null != nativeProps && UIManager.updateView(maybeInstance._nativeTag, viewConfig.uiViewClassName, nativeProps);
          }
        };

        return ReactNativeComponent;
      }(React.Component);
    }(findNodeHandle, findHostInstance$1),
    findNodeHandle: findNodeHandle,
    render: function render(element, containerTag, callback) {
      var root = roots.get(containerTag);
      root || (root = createFiberRoot(containerTag, !1, !1), roots.set(containerTag, root));
      updateContainer(element, root, null, callback);
      return getPublicRootInstance(root);
    },
    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);
      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) {
            UIManager.measure(findNodeHandle(this), mountSafeCallback(this, callback));
          },
          measureInWindow: function measureInWindow(callback) {
            UIManager.measureInWindow(findNodeHandle(this), mountSafeCallback(this, callback));
          },
          measureLayout: function measureLayout(relativeToNativeNode, onSuccess, onFail) {
            UIManager.measureLayout(findNodeHandle(this), relativeToNativeNode, mountSafeCallback(this, onFail), mountSafeCallback(this, onSuccess));
          },
          setNativeProps: function setNativeProps(nativeProps) {
            var maybeInstance = void 0;

            try {
              maybeInstance = findHostInstance(this);
            } catch (error) {}

            if (null != maybeInstance) {
              var viewConfig = maybeInstance.viewConfig;
              nativeProps = diffProperties(null, emptyObject$1, nativeProps, viewConfig.validAttributes);
              null != nativeProps && UIManager.updateView(maybeInstance._nativeTag, viewConfig.uiViewClassName, nativeProps);
            }
          },
          focus: function focus() {
            TextInputState.focusTextInput(findNodeHandle(this));
          },
          blur: function blur() {
            TextInputState.blurTextInput(findNodeHandle(this));
          }
        };
      }(findNodeHandle, findHostInstance$1),
      computeComponentStackForErrorReporting: function computeComponentStackForErrorReporting(reactTag) {
        return (reactTag = getInstanceFromTag(reactTag)) ? getStackAddendumByWorkInProgressFiber(reactTag) : "";
      }
    }
  };
  injectIntoDevTools({
    findFiberByHostInstance: getInstanceFromTag,
    getInspectorDataForViewTag: getInspectorDataForViewTag,
    bundleType: 0,
    version: "16.4.1",
    rendererPackageName: "react-native-renderer"
  });
  var ReactNativeRenderer$2 = {
    default: ReactNativeRenderer
  },
      ReactNativeRenderer$3 = ReactNativeRenderer$2 && ReactNativeRenderer || ReactNativeRenderer$2;
  module.exports = ReactNativeRenderer$3.default ? ReactNativeRenderer$3.default : ReactNativeRenderer$3;
},326,[263,166,231,218,322,1,323,324,226,325,271],"node_modules/react-native/Libraries/Renderer/oss/ReactNativeRenderer-prod.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var Platform = _$$_REQUIRE(_dependencyMap[0], 'Platform');

  var TVNavigationEventEmitter = _$$_REQUIRE(_dependencyMap[1], 'NativeModules').TVNavigationEventEmitter;

  var NativeEventEmitter = _$$_REQUIRE(_dependencyMap[2], 'NativeEventEmitter');

  function TVEventHandler() {
    this.__nativeTVNavigationEventListener = null;
    this.__nativeTVNavigationEventEmitter = null;
  }

  TVEventHandler.prototype.enable = function (component, callback) {
    if (Platform.OS === 'ios' && !TVNavigationEventEmitter) {
      return;
    }

    this.__nativeTVNavigationEventEmitter = new NativeEventEmitter(TVNavigationEventEmitter);
    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;
},327,[176,168,286],"node_modules/react-native/Libraries/Components/AppleTV/TVEventHandler.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  "use strict";

  var TouchEventUtils = {
    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;
    }
  };
  module.exports = TouchEventUtils;
},328,[],"node_modules/react-native/node_modules/fbjs/lib/TouchEventUtils.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  "use strict";

  var nullthrows = function nullthrows(x) {
    if (x != null) {
      return x;
    }

    throw new Error("Got unexpected null or undefined");
  };

  module.exports = nullthrows;
},329,[],"node_modules/react-native/node_modules/fbjs/lib/nullthrows.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _default = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[0], "react")).default;

  var _reactTransformHmrLibIndexJs = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./../../../../react-transform-hmr/lib/index.js")).default;

  var _jsxFileName = "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Components/Touchable/TouchableNativeFeedback.ios.js";

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var _components = {
    DummyTouchableNativeFeedback: {
      displayName: "DummyTouchableNativeFeedback"
    }
  };

  var _reactTransformHmrLibIndexJs2 = _reactTransformHmrLibIndexJs({
    filename: "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Components/Touchable/TouchableNativeFeedback.ios.js",
    components: _components,
    locals: [module],
    imports: [_default]
  });

  function _wrapComponent(id) {
    return function (Component) {
      return _reactTransformHmrLibIndexJs2(Component, id);
    };
  }

  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

  var React = _$$_REQUIRE(_dependencyMap[2], 'React');

  var StyleSheet = _$$_REQUIRE(_dependencyMap[3], 'StyleSheet');

  var Text = _$$_REQUIRE(_dependencyMap[4], 'Text');

  var View = _$$_REQUIRE(_dependencyMap[5], 'View');

  var DummyTouchableNativeFeedback = function (_React$Component) {
    function DummyTouchableNativeFeedback() {
      _classCallCheck(this, DummyTouchableNativeFeedback);

      return _possibleConstructorReturn(this, _getPrototypeOf(DummyTouchableNativeFeedback).apply(this, arguments));
    }

    _createClass(DummyTouchableNativeFeedback, [{
      key: "render",
      value: function render() {
        return React.createElement(View, {
          style: [styles.container, this.props.style],
          __source: {
            fileName: _jsxFileName,
            lineNumber: 25
          }
        }, React.createElement(Text, {
          style: styles.info,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 26
          }
        }, "TouchableNativeFeedback is not supported on this platform!"));
      }
    }]);

    _inherits(DummyTouchableNativeFeedback, _React$Component);

    return DummyTouchableNativeFeedback;
  }(React.Component);

  DummyTouchableNativeFeedback.SelectableBackground = function () {
    return {};
  };

  DummyTouchableNativeFeedback.SelectableBackgroundBorderless = function () {
    return {};
  };

  DummyTouchableNativeFeedback.Ripple = function () {
    return {};
  };

  DummyTouchableNativeFeedback.canUseNativeForeground = function () {
    return false;
  };

  DummyTouchableNativeFeedback = _wrapComponent("DummyTouchableNativeFeedback")(DummyTouchableNativeFeedback);
  var styles = StyleSheet.create({
    container: {
      height: 100,
      width: 300,
      backgroundColor: '#ffbcbc',
      borderWidth: 1,
      borderColor: 'red',
      alignItems: 'center',
      justifyContent: 'center',
      margin: 10
    },
    info: {
      color: '#333333',
      margin: 20
    }
  });
  module.exports = DummyTouchableNativeFeedback;
},330,[1,11,200,201,252,227],"node_modules/react-native/Libraries/Components/Touchable/TouchableNativeFeedback.ios.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _jsxFileName = "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Components/Touchable/TouchableOpacity.js";

  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 Animated = _$$_REQUIRE(_dependencyMap[0], 'Animated');

  var Easing = _$$_REQUIRE(_dependencyMap[1], 'Easing');

  var NativeMethodsMixin = _$$_REQUIRE(_dependencyMap[2], 'NativeMethodsMixin');

  var React = _$$_REQUIRE(_dependencyMap[3], 'React');

  var PropTypes = _$$_REQUIRE(_dependencyMap[4], 'prop-types');

  var TimerMixin = _$$_REQUIRE(_dependencyMap[5], 'react-timer-mixin');

  var Touchable = _$$_REQUIRE(_dependencyMap[6], 'Touchable');

  var TouchableWithoutFeedback = _$$_REQUIRE(_dependencyMap[7], 'TouchableWithoutFeedback');

  var createReactClass = _$$_REQUIRE(_dependencyMap[8], 'create-react-class');

  var ensurePositiveDelayProps = _$$_REQUIRE(_dependencyMap[9], 'ensurePositiveDelayProps');

  var flattenStyle = _$$_REQUIRE(_dependencyMap[10], 'flattenStyle');

  var PRESS_RETENTION_OFFSET = {
    top: 20,
    left: 20,
    right: 20,
    bottom: 30
  };
  var TouchableOpacity = createReactClass({
    displayName: 'TouchableOpacity',
    mixins: [TimerMixin, Touchable.Mixin, NativeMethodsMixin],
    propTypes: _objectSpread({}, TouchableWithoutFeedback.propTypes, {
      activeOpacity: PropTypes.number,
      hasTVPreferredFocus: PropTypes.bool,
      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);
    },
    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 == undefined ? 1 : childStyle.opacity;
    },
    render: function render() {
      return React.createElement(Animated.View, {
        accessible: this.props.accessible !== false,
        accessibilityLabel: this.props.accessibilityLabel,
        accessibilityComponentType: this.props.accessibilityComponentType,
        accessibilityTraits: this.props.accessibilityTraits,
        style: [this.props.style, {
          opacity: this.state.anim
        }],
        nativeID: this.props.nativeID,
        testID: this.props.testID,
        onLayout: this.props.onLayout,
        isTVSelectable: true,
        hasTVPreferredFocus: this.props.hasTVPreferredFocus,
        tvParallaxProperties: this.props.tvParallaxProperties,
        hitSlop: this.props.hitSlop,
        onStartShouldSetResponder: this.touchableHandleStartShouldSetResponder,
        onResponderTerminationRequest: this.touchableHandleResponderTerminationRequest,
        onResponderGrant: this.touchableHandleResponderGrant,
        onResponderMove: this.touchableHandleResponderMove,
        onResponderRelease: this.touchableHandleResponderRelease,
        onResponderTerminate: this.touchableHandleResponderTerminate,
        __source: {
          fileName: _jsxFileName,
          lineNumber: 256
        }
      }, this.props.children, Touchable.renderDebugView({
        color: 'cyan',
        hitSlop: this.props.hitSlop
      }));
    }
  });
  module.exports = TouchableOpacity;
},331,[332,358,364,200,212,382,257,383,365,384,226],"node_modules/react-native/Libraries/Components/Touchable/TouchableOpacity.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

  var AnimatedImplementation = _$$_REQUIRE(_dependencyMap[0], 'AnimatedImplementation');

  var Image = _$$_REQUIRE(_dependencyMap[1], 'Image');

  var ScrollView = _$$_REQUIRE(_dependencyMap[2], 'ScrollView');

  var Text = _$$_REQUIRE(_dependencyMap[3], 'Text');

  var View = _$$_REQUIRE(_dependencyMap[4], 'View');

  var Animated = {
    View: AnimatedImplementation.createAnimatedComponent(View),
    Text: AnimatedImplementation.createAnimatedComponent(Text),
    Image: AnimatedImplementation.createAnimatedComponent(Image),
    ScrollView: AnimatedImplementation.createAnimatedComponent(ScrollView)
  };

  _extends(Animated, AnimatedImplementation);

  module.exports = Animated;
},332,[333,361,367,252,227],"node_modules/react-native/Libraries/Animated/src/Animated.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  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 _require = _$$_REQUIRE(_dependencyMap[0], './AnimatedEvent'),
      AnimatedEvent = _require.AnimatedEvent,
      attachNativeEvent = _require.attachNativeEvent;

  var AnimatedAddition = _$$_REQUIRE(_dependencyMap[1], './nodes/AnimatedAddition');

  var AnimatedDiffClamp = _$$_REQUIRE(_dependencyMap[2], './nodes/AnimatedDiffClamp');

  var AnimatedDivision = _$$_REQUIRE(_dependencyMap[3], './nodes/AnimatedDivision');

  var AnimatedInterpolation = _$$_REQUIRE(_dependencyMap[4], './nodes/AnimatedInterpolation');

  var AnimatedModulo = _$$_REQUIRE(_dependencyMap[5], './nodes/AnimatedModulo');

  var AnimatedMultiplication = _$$_REQUIRE(_dependencyMap[6], './nodes/AnimatedMultiplication');

  var AnimatedNode = _$$_REQUIRE(_dependencyMap[7], './nodes/AnimatedNode');

  var AnimatedProps = _$$_REQUIRE(_dependencyMap[8], './nodes/AnimatedProps');

  var AnimatedSubtraction = _$$_REQUIRE(_dependencyMap[9], './nodes/AnimatedSubtraction');

  var AnimatedTracking = _$$_REQUIRE(_dependencyMap[10], './nodes/AnimatedTracking');

  var AnimatedValue = _$$_REQUIRE(_dependencyMap[11], './nodes/AnimatedValue');

  var AnimatedValueXY = _$$_REQUIRE(_dependencyMap[12], './nodes/AnimatedValueXY');

  var DecayAnimation = _$$_REQUIRE(_dependencyMap[13], './animations/DecayAnimation');

  var SpringAnimation = _$$_REQUIRE(_dependencyMap[14], './animations/SpringAnimation');

  var TimingAnimation = _$$_REQUIRE(_dependencyMap[15], './animations/TimingAnimation');

  var createAnimatedComponent = _$$_REQUIRE(_dependencyMap[16], './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) {
        function start(_x) {
          return _start.apply(this, arguments);
        }

        start.toString = function () {
          return _start.toString();
        };

        return start;
      }(function (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 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, TimingAnimation, singleConfig, callback));
      } else {
        singleValue.animate(new TimingAnimation(singleConfig), callback);
      }
    };

    return maybeVectorAnim(value, config, timing) || {
      start: function (_start2) {
        function start(_x2) {
          return _start2.apply(this, arguments);
        }

        start.toString = function () {
          return _start2.toString();
        };

        return start;
      }(function (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 decay = function decay(value, config) {
    var start = 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 (_start3) {
        function start(_x3) {
          return _start3.apply(this, arguments);
        }

        start.toString = function () {
          return _start3.toString();
        };

        return start;
      }(function (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 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
    });
  };

  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;

    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++;
            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,
    __PropsOnlyForTests: AnimatedProps
  };
},333,[334,342,343,344,336,345,346,337,347,350,351,335,352,353,355,357,360],"node_modules/react-native/Libraries/Animated/src/AnimatedImplementation.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  var AnimatedValue = _$$_REQUIRE(_dependencyMap[0], './nodes/AnimatedValue');

  var NativeAnimatedHelper = _$$_REQUIRE(_dependencyMap[1], './NativeAnimatedHelper');

  var ReactNative = _$$_REQUIRE(_dependencyMap[2], 'ReactNative');

  var invariant = _$$_REQUIRE(_dependencyMap[3], 'fbjs/lib/invariant');

  var _require = _$$_REQUIRE(_dependencyMap[1], './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
  };
},334,[335,338,261,166],"node_modules/react-native/Libraries/Animated/src/AnimatedEvent.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _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); }

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

  function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var AnimatedInterpolation = _$$_REQUIRE(_dependencyMap[0], './AnimatedInterpolation');

  var AnimatedNode = _$$_REQUIRE(_dependencyMap[1], './AnimatedNode');

  var AnimatedWithChildren = _$$_REQUIRE(_dependencyMap[2], './AnimatedWithChildren');

  var InteractionManager = _$$_REQUIRE(_dependencyMap[3], 'InteractionManager');

  var NativeAnimatedHelper = _$$_REQUIRE(_dependencyMap[4], '../NativeAnimatedHelper');

  var NativeAnimatedAPI = NativeAnimatedHelper.API;
  var _uniqueId = 1;

  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) {
    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;
      _this._listeners = {};
      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: "__makeNative",
      value: function __makeNative() {
        _get(_getPrototypeOf(AnimatedValue.prototype), "__makeNative", this).call(this);

        if (Object.keys(this._listeners).length) {
          this._startListeningToNativeValueUpdates();
        }
      }
    }, {
      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: "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 && Object.keys(this._listeners).length === 0) {
          this._stopListeningForNativeValueUpdates();
        }
      }
    }, {
      key: "removeAllListeners",
      value: function removeAllListeners() {
        this._listeners = {};

        if (this.__isNative) {
          this._stopListeningForNativeValueUpdates();
        }
      }
    }, {
      key: "_startListeningToNativeValueUpdates",
      value: function _startListeningToNativeValueUpdates() {
        var _this2 = this;

        if (this.__nativeAnimatedValueListener) {
          return;
        }

        NativeAnimatedAPI.startListeningToAnimatedNodeValue(this.__getNativeTag());
        this.__nativeAnimatedValueListener = NativeAnimatedHelper.nativeEventEmitter.addListener('onAnimatedValueUpdate', function (data) {
          if (data.tag !== _this2.__getNativeTag()) {
            return;
          }

          _this2._updateValue(data.value, false);
        });
      }
    }, {
      key: "_stopListeningForNativeValueUpdates",
      value: function _stopListeningForNativeValueUpdates() {
        if (!this.__nativeAnimatedValueListener) {
          return;
        }

        this.__nativeAnimatedValueListener.remove();

        this.__nativeAnimatedValueListener = null;
        NativeAnimatedAPI.stopListeningToAnimatedNodeValue(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: "interpolate",
      value: function interpolate(config) {
        return new AnimatedInterpolation(this, config);
      }
    }, {
      key: "animate",
      value: function animate(animation, callback) {
        var _this3 = 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) {
          _this3._updateValue(value, true);
        }, function (result) {
          _this3._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);
        }

        for (var _key in this._listeners) {
          this._listeners[_key]({
            value: this.__getValue()
          });
        }
      }
    }, {
      key: "__getNativeConfig",
      value: function __getNativeConfig() {
        return {
          type: 'value',
          value: this._value,
          offset: this._offset
        };
      }
    }]);

    _inherits(AnimatedValue, _AnimatedWithChildren);

    return AnimatedValue;
  }(AnimatedWithChildren);

  module.exports = AnimatedValue;
},335,[336,337,339,340,338],"node_modules/react-native/Libraries/Animated/src/nodes/AnimatedValue.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _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); }

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

  function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  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 AnimatedNode = _$$_REQUIRE(_dependencyMap[0], './AnimatedNode');

  var AnimatedWithChildren = _$$_REQUIRE(_dependencyMap[1], './AnimatedWithChildren');

  var NativeAnimatedHelper = _$$_REQUIRE(_dependencyMap[2], '../NativeAnimatedHelper');

  var invariant = _$$_REQUIRE(_dependencyMap[3], 'fbjs/lib/invariant');

  var normalizeColor = _$$_REQUIRE(_dependencyMap[4], '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 = /[0-9\.-]+/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);
        var rounded = shouldRound && i < 4 ? Math.round(val) : Math.round(val * 1000) / 1000;
        return String(rounded);
      });
    };
  }

  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) {
    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(function (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 parseFloat(value) || 0;
          }
        });
      }
    }, {
      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'
        };
      }
    }]);

    _inherits(AnimatedInterpolation, _AnimatedWithChildren);

    return AnimatedInterpolation;
  }(AnimatedWithChildren);

  AnimatedInterpolation.__createInterpolation = createInterpolation;
  module.exports = AnimatedInterpolation;
},336,[337,339,338,166,208],"node_modules/react-native/Libraries/Animated/src/nodes/AnimatedInterpolation.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  var NativeAnimatedHelper = _$$_REQUIRE(_dependencyMap[0], '../NativeAnimatedHelper');

  var invariant = _$$_REQUIRE(_dependencyMap[1], 'fbjs/lib/invariant');

  var AnimatedNode = function () {
    function AnimatedNode() {
      _classCallCheck(this, AnimatedNode);
    }

    _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 [];
      }
    }, {
      key: "__makeNative",
      value: function __makeNative() {
        if (!this.__isNative) {
          throw new Error('This node cannot be made a "native" animated node');
        }
      }
    }, {
      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();
          NativeAnimatedHelper.API.createAnimatedNode(nativeTag, this.__getNativeConfig());
          this.__nativeTag = nativeTag;
        }

        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;
},337,[338,166],"node_modules/react-native/Libraries/Animated/src/nodes/AnimatedNode.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var NativeAnimatedModule = _$$_REQUIRE(_dependencyMap[0], 'NativeModules').NativeAnimatedModule;

  var NativeEventEmitter = _$$_REQUIRE(_dependencyMap[1], 'NativeEventEmitter');

  var invariant = _$$_REQUIRE(_dependencyMap[2], 'fbjs/lib/invariant');

  var __nativeAnimatedNodeTagCount = 1;
  var __nativeAnimationIdCount = 1;
  var nativeEventEmitter;
  var API = {
    createAnimatedNode: function createAnimatedNode(tag, config) {
      assertNativeAnimatedModule();
      NativeAnimatedModule.createAnimatedNode(tag, config);
    },
    startListeningToAnimatedNodeValue: function startListeningToAnimatedNodeValue(tag) {
      assertNativeAnimatedModule();
      NativeAnimatedModule.startListeningToAnimatedNodeValue(tag);
    },
    stopListeningToAnimatedNodeValue: function stopListeningToAnimatedNodeValue(tag) {
      assertNativeAnimatedModule();
      NativeAnimatedModule.stopListeningToAnimatedNodeValue(tag);
    },
    connectAnimatedNodes: function connectAnimatedNodes(parentTag, childTag) {
      assertNativeAnimatedModule();
      NativeAnimatedModule.connectAnimatedNodes(parentTag, childTag);
    },
    disconnectAnimatedNodes: function disconnectAnimatedNodes(parentTag, childTag) {
      assertNativeAnimatedModule();
      NativeAnimatedModule.disconnectAnimatedNodes(parentTag, childTag);
    },
    startAnimatingNode: function startAnimatingNode(animationId, nodeTag, config, endCallback) {
      assertNativeAnimatedModule();
      NativeAnimatedModule.startAnimatingNode(animationId, nodeTag, config, endCallback);
    },
    stopAnimation: function stopAnimation(animationId) {
      assertNativeAnimatedModule();
      NativeAnimatedModule.stopAnimation(animationId);
    },
    setAnimatedNodeValue: function setAnimatedNodeValue(nodeTag, value) {
      assertNativeAnimatedModule();
      NativeAnimatedModule.setAnimatedNodeValue(nodeTag, value);
    },
    setAnimatedNodeOffset: function setAnimatedNodeOffset(nodeTag, offset) {
      assertNativeAnimatedModule();
      NativeAnimatedModule.setAnimatedNodeOffset(nodeTag, offset);
    },
    flattenAnimatedNodeOffset: function flattenAnimatedNodeOffset(nodeTag) {
      assertNativeAnimatedModule();
      NativeAnimatedModule.flattenAnimatedNodeOffset(nodeTag);
    },
    extractAnimatedNodeOffset: function extractAnimatedNodeOffset(nodeTag) {
      assertNativeAnimatedModule();
      NativeAnimatedModule.extractAnimatedNodeOffset(nodeTag);
    },
    connectAnimatedNodeToView: function connectAnimatedNodeToView(nodeTag, viewTag) {
      assertNativeAnimatedModule();
      NativeAnimatedModule.connectAnimatedNodeToView(nodeTag, viewTag);
    },
    disconnectAnimatedNodeFromView: function disconnectAnimatedNodeFromView(nodeTag, viewTag) {
      assertNativeAnimatedModule();
      NativeAnimatedModule.disconnectAnimatedNodeFromView(nodeTag, viewTag);
    },
    dropAnimatedNode: function dropAnimatedNode(tag) {
      assertNativeAnimatedModule();
      NativeAnimatedModule.dropAnimatedNode(tag);
    },
    addAnimatedEventToView: function addAnimatedEventToView(viewTag, eventName, eventMapping) {
      assertNativeAnimatedModule();
      NativeAnimatedModule.addAnimatedEventToView(viewTag, eventName, eventMapping);
    },
    removeAnimatedEventFromView: function removeAnimatedEventFromView(viewTag, eventName, animatedNodeTag) {
      assertNativeAnimatedModule();
      NativeAnimatedModule.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,
    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,
    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 key in config) {
      if (!SUPPORTED_INTERPOLATION_PARAMS.hasOwnProperty(key)) {
        throw new Error("Interpolation property '" + key + "' is not supported by native animated module");
      }
    }
  }

  function generateNewNodeTag() {
    return __nativeAnimatedNodeTagCount++;
  }

  function generateNewAnimationId() {
    return __nativeAnimationIdCount++;
  }

  function assertNativeAnimatedModule() {
    invariant(NativeAnimatedModule, 'Native animated module is not available');
  }

  var _warnedMissingNativeAnimated = false;

  function shouldUseNativeDriver(config) {
    if (config.useNativeDriver && !NativeAnimatedModule) {
      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;
  }

  module.exports = {
    API: API,
    addWhitelistedStyleProp: addWhitelistedStyleProp,
    addWhitelistedTransformProp: addWhitelistedTransformProp,
    addWhitelistedInterpolationParam: addWhitelistedInterpolationParam,
    validateStyles: validateStyles,
    validateTransform: validateTransform,
    validateInterpolation: validateInterpolation,
    generateNewNodeTag: generateNewNodeTag,
    generateNewAnimationId: generateNewAnimationId,
    assertNativeAnimatedModule: assertNativeAnimatedModule,
    shouldUseNativeDriver: shouldUseNativeDriver,

    get nativeEventEmitter() {
      if (!nativeEventEmitter) {
        nativeEventEmitter = new NativeEventEmitter(NativeAnimatedModule);
      }

      return nativeEventEmitter;
    }

  };
},338,[168,286,166],"node_modules/react-native/Libraries/Animated/src/NativeAnimatedHelper.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var AnimatedNode = _$$_REQUIRE(_dependencyMap[0], './AnimatedNode');

  var NativeAnimatedHelper = _$$_REQUIRE(_dependencyMap[1], '../NativeAnimatedHelper');

  var AnimatedWithChildren = function (_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());
          }
        }
      }
    }, {
      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;
      }
    }]);

    _inherits(AnimatedWithChildren, _AnimatedNode);

    return AnimatedWithChildren;
  }(AnimatedNode);

  module.exports = AnimatedWithChildren;
},339,[337,338],"node_modules/react-native/Libraries/Animated/src/nodes/AnimatedWithChildren.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var BatchedBridge = _$$_REQUIRE(_dependencyMap[0], 'BatchedBridge');

  var EventEmitter = _$$_REQUIRE(_dependencyMap[1], 'EventEmitter');

  var Set = _$$_REQUIRE(_dependencyMap[2], 'Set');

  var TaskQueue = _$$_REQUIRE(_dependencyMap[3], 'TaskQueue');

  var infoLog = _$$_REQUIRE(_dependencyMap[4], 'infoLog');

  var invariant = _$$_REQUIRE(_dependencyMap[5], 'fbjs/lib/invariant');

  var keyMirror = _$$_REQUIRE(_dependencyMap[6], '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('create interaction handle');

      _scheduleUpdate();

      var handle = ++_inc;

      _addInteractionSet.add(handle);

      return handle;
    },
    clearInteractionHandle: function clearInteractionHandle(handle) {
      DEBUG && infoLog('clear interaction handle');
      invariant(!!handle, '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;
},340,[169,195,270,341,309,166,210],"node_modules/react-native/Libraries/Interaction/InteractionManager.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

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

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  var infoLog = _$$_REQUIRE(_dependencyMap[0], 'infoLog');

  var invariant = _$$_REQUIRE(_dependencyMap[1], 'fbjs/lib/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('genPromise for task ' + task.name);

              this._genPromise(task);
            } else if (task.run) {
              DEBUG && infoLog('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('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('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('push new queue: ', {
          stackIdx: stackIdx
        });
        DEBUG && infoLog('exec gen task ' + task.name);
        task.gen().then(function () {
          DEBUG && infoLog('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;
},341,[309,166],"node_modules/react-native/Libraries/Interaction/TaskQueue.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _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); }

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

  function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var AnimatedInterpolation = _$$_REQUIRE(_dependencyMap[0], './AnimatedInterpolation');

  var AnimatedNode = _$$_REQUIRE(_dependencyMap[1], './AnimatedNode');

  var AnimatedValue = _$$_REQUIRE(_dependencyMap[2], './AnimatedValue');

  var AnimatedWithChildren = _$$_REQUIRE(_dependencyMap[3], './AnimatedWithChildren');

  var AnimatedAddition = function (_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()]
        };
      }
    }]);

    _inherits(AnimatedAddition, _AnimatedWithChildren);

    return AnimatedAddition;
  }(AnimatedWithChildren);

  module.exports = AnimatedAddition;
},342,[336,337,335,339],"node_modules/react-native/Libraries/Animated/src/nodes/AnimatedAddition.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _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); }

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

  function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var AnimatedInterpolation = _$$_REQUIRE(_dependencyMap[0], './AnimatedInterpolation');

  var AnimatedNode = _$$_REQUIRE(_dependencyMap[1], './AnimatedNode');

  var AnimatedWithChildren = _$$_REQUIRE(_dependencyMap[2], './AnimatedWithChildren');

  var AnimatedDiffClamp = function (_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
        };
      }
    }]);

    _inherits(AnimatedDiffClamp, _AnimatedWithChildren);

    return AnimatedDiffClamp;
  }(AnimatedWithChildren);

  module.exports = AnimatedDiffClamp;
},343,[336,337,339],"node_modules/react-native/Libraries/Animated/src/nodes/AnimatedDiffClamp.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _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); }

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

  function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var AnimatedInterpolation = _$$_REQUIRE(_dependencyMap[0], './AnimatedInterpolation');

  var AnimatedNode = _$$_REQUIRE(_dependencyMap[1], './AnimatedNode');

  var AnimatedValue = _$$_REQUIRE(_dependencyMap[2], './AnimatedValue');

  var AnimatedWithChildren = _$$_REQUIRE(_dependencyMap[3], './AnimatedWithChildren');

  var AnimatedDivision = function (_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()]
        };
      }
    }]);

    _inherits(AnimatedDivision, _AnimatedWithChildren);

    return AnimatedDivision;
  }(AnimatedWithChildren);

  module.exports = AnimatedDivision;
},344,[336,337,335,339],"node_modules/react-native/Libraries/Animated/src/nodes/AnimatedDivision.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _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); }

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

  function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var AnimatedInterpolation = _$$_REQUIRE(_dependencyMap[0], './AnimatedInterpolation');

  var AnimatedNode = _$$_REQUIRE(_dependencyMap[1], './AnimatedNode');

  var AnimatedWithChildren = _$$_REQUIRE(_dependencyMap[2], './AnimatedWithChildren');

  var AnimatedModulo = function (_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
        };
      }
    }]);

    _inherits(AnimatedModulo, _AnimatedWithChildren);

    return AnimatedModulo;
  }(AnimatedWithChildren);

  module.exports = AnimatedModulo;
},345,[336,337,339],"node_modules/react-native/Libraries/Animated/src/nodes/AnimatedModulo.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _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); }

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

  function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var AnimatedInterpolation = _$$_REQUIRE(_dependencyMap[0], './AnimatedInterpolation');

  var AnimatedNode = _$$_REQUIRE(_dependencyMap[1], './AnimatedNode');

  var AnimatedValue = _$$_REQUIRE(_dependencyMap[2], './AnimatedValue');

  var AnimatedWithChildren = _$$_REQUIRE(_dependencyMap[3], './AnimatedWithChildren');

  var AnimatedMultiplication = function (_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()]
        };
      }
    }]);

    _inherits(AnimatedMultiplication, _AnimatedWithChildren);

    return AnimatedMultiplication;
  }(AnimatedWithChildren);

  module.exports = AnimatedMultiplication;
},346,[336,337,335,339],"node_modules/react-native/Libraries/Animated/src/nodes/AnimatedMultiplication.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

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

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _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); }

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

  function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var _require = _$$_REQUIRE(_dependencyMap[0], '../AnimatedEvent'),
      AnimatedEvent = _require.AnimatedEvent;

  var AnimatedNode = _$$_REQUIRE(_dependencyMap[1], './AnimatedNode');

  var AnimatedStyle = _$$_REQUIRE(_dependencyMap[2], './AnimatedStyle');

  var NativeAnimatedHelper = _$$_REQUIRE(_dependencyMap[3], '../NativeAnimatedHelper');

  var ReactNative = _$$_REQUIRE(_dependencyMap[4], 'ReactNative');

  var invariant = _$$_REQUIRE(_dependencyMap[5], 'fbjs/lib/invariant');

  var AnimatedProps = function (_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) {
            propsConfig[propKey] = value.__getNativeTag();
          }
        }

        return {
          type: 'props',
          props: propsConfig
        };
      }
    }]);

    _inherits(AnimatedProps, _AnimatedNode);

    return AnimatedProps;
  }(AnimatedNode);

  module.exports = AnimatedProps;
},347,[334,337,348,338,261,166],"node_modules/react-native/Libraries/Animated/src/nodes/AnimatedProps.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

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

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _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); }

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

  function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var AnimatedNode = _$$_REQUIRE(_dependencyMap[0], './AnimatedNode');

  var AnimatedTransform = _$$_REQUIRE(_dependencyMap[1], './AnimatedTransform');

  var AnimatedWithChildren = _$$_REQUIRE(_dependencyMap[2], './AnimatedWithChildren');

  var NativeAnimatedHelper = _$$_REQUIRE(_dependencyMap[3], '../NativeAnimatedHelper');

  var flattenStyle = _$$_REQUIRE(_dependencyMap[4], 'flattenStyle');

  var AnimatedStyle = function (_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() {
        _get(_getPrototypeOf(AnimatedStyle.prototype), "__makeNative", this).call(this);

        for (var key in this._style) {
          var value = this._style[key];

          if (value instanceof AnimatedNode) {
            value.__makeNative();
          }
        }
      }
    }, {
      key: "__getNativeConfig",
      value: function __getNativeConfig() {
        var styleConfig = {};

        for (var styleKey in this._style) {
          if (this._style[styleKey] instanceof AnimatedNode) {
            styleConfig[styleKey] = this._style[styleKey].__getNativeTag();
          }
        }

        NativeAnimatedHelper.validateStyles(styleConfig);
        return {
          type: 'style',
          style: styleConfig
        };
      }
    }]);

    _inherits(AnimatedStyle, _AnimatedWithChildren);

    return AnimatedStyle;
  }(AnimatedWithChildren);

  module.exports = AnimatedStyle;
},348,[337,349,339,338,226],"node_modules/react-native/Libraries/Animated/src/nodes/AnimatedStyle.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _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); }

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

  function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var AnimatedNode = _$$_REQUIRE(_dependencyMap[0], './AnimatedNode');

  var AnimatedWithChildren = _$$_REQUIRE(_dependencyMap[1], './AnimatedWithChildren');

  var NativeAnimatedHelper = _$$_REQUIRE(_dependencyMap[2], '../NativeAnimatedHelper');

  var AnimatedTransform = function (_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() {
        _get(_getPrototypeOf(AnimatedTransform.prototype), "__makeNative", this).call(this);

        this._transforms.forEach(function (transform) {
          for (var key in transform) {
            var value = transform[key];

            if (value instanceof AnimatedNode) {
              value.__makeNative();
            }
          }
        });
      }
    }, {
      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: value
              });
            }
          }
        });

        NativeAnimatedHelper.validateTransform(transConfigs);
        return {
          type: 'transform',
          transforms: transConfigs
        };
      }
    }]);

    _inherits(AnimatedTransform, _AnimatedWithChildren);

    return AnimatedTransform;
  }(AnimatedWithChildren);

  module.exports = AnimatedTransform;
},349,[337,339,338],"node_modules/react-native/Libraries/Animated/src/nodes/AnimatedTransform.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _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); }

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

  function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var AnimatedInterpolation = _$$_REQUIRE(_dependencyMap[0], './AnimatedInterpolation');

  var AnimatedNode = _$$_REQUIRE(_dependencyMap[1], './AnimatedNode');

  var AnimatedValue = _$$_REQUIRE(_dependencyMap[2], './AnimatedValue');

  var AnimatedWithChildren = _$$_REQUIRE(_dependencyMap[3], './AnimatedWithChildren');

  var AnimatedSubtraction = function (_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()]
        };
      }
    }]);

    _inherits(AnimatedSubtraction, _AnimatedWithChildren);

    return AnimatedSubtraction;
  }(AnimatedWithChildren);

  module.exports = AnimatedSubtraction;
},350,[336,337,335,339],"node_modules/react-native/Libraries/Animated/src/nodes/AnimatedSubtraction.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

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

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _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); }

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

  function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var AnimatedValue = _$$_REQUIRE(_dependencyMap[0], './AnimatedValue');

  var AnimatedNode = _$$_REQUIRE(_dependencyMap[1], './AnimatedNode');

  var _require = _$$_REQUIRE(_dependencyMap[2], '../NativeAnimatedHelper'),
      generateNewAnimationId = _require.generateNewAnimationId,
      shouldUseNativeDriver = _require.shouldUseNativeDriver;

  var AnimatedTracking = function (_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()
        };
      }
    }]);

    _inherits(AnimatedTracking, _AnimatedNode);

    return AnimatedTracking;
  }(AnimatedNode);

  module.exports = AnimatedTracking;
},351,[335,337,338],"node_modules/react-native/Libraries/Animated/src/nodes/AnimatedTracking.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var AnimatedValue = _$$_REQUIRE(_dependencyMap[0], './AnimatedValue');

  var AnimatedWithChildren = _$$_REQUIRE(_dependencyMap[1], './AnimatedWithChildren');

  var invariant = _$$_REQUIRE(_dependencyMap[2], 'fbjs/lib/invariant');

  var _uniqueId = 1;

  var AnimatedValueXY = function (_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
        }];
      }
    }]);

    _inherits(AnimatedValueXY, _AnimatedWithChildren);

    return AnimatedValueXY;
  }(AnimatedWithChildren);

  module.exports = AnimatedValueXY;
},352,[335,339,166],"node_modules/react-native/Libraries/Animated/src/nodes/AnimatedValueXY.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _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); }

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

  function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var Animation = _$$_REQUIRE(_dependencyMap[0], './Animation');

  var _require = _$$_REQUIRE(_dependencyMap[1], '../NativeAnimatedHelper'),
      shouldUseNativeDriver = _require.shouldUseNativeDriver;

  var DecayAnimation = function (_Animation) {
    function DecayAnimation(config) {
      var _this;

      _classCallCheck(this, DecayAnimation);

      _this = _possibleConstructorReturn(this, _getPrototypeOf(DecayAnimation).call(this));
      _this._deceleration = config.deceleration !== undefined ? config.deceleration : 0.998;
      _this._velocity = config.velocity;
      _this._useNativeDriver = shouldUseNativeDriver(config);
      _this.__isInteraction = config.isInteraction !== undefined ? config.isInteraction : true;
      _this.__iterations = config.iterations !== undefined ? 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
        });
      }
    }]);

    _inherits(DecayAnimation, _Animation);

    return DecayAnimation;
  }(Animation);

  module.exports = DecayAnimation;
},353,[354,338],"node_modules/react-native/Libraries/Animated/src/animations/DecayAnimation.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  var NativeAnimatedHelper = _$$_REQUIRE(_dependencyMap[0], '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) {
        animatedValue.__makeNative();

        this.__nativeId = NativeAnimatedHelper.generateNewAnimationId();
        NativeAnimatedHelper.API.startAnimatingNode(this.__nativeId, animatedValue.__getNativeTag(), this.__getNativeAnimationConfig(), this.__debouncedOnEnd.bind(this));
      }
    }]);

    return Animation;
  }();

  module.exports = Animation;
},354,[338],"node_modules/react-native/Libraries/Animated/src/animations/Animation.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _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); }

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

  function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var AnimatedValue = _$$_REQUIRE(_dependencyMap[0], '../nodes/AnimatedValue');

  var AnimatedValueXY = _$$_REQUIRE(_dependencyMap[1], '../nodes/AnimatedValueXY');

  var Animation = _$$_REQUIRE(_dependencyMap[2], './Animation');

  var SpringConfig = _$$_REQUIRE(_dependencyMap[3], '../SpringConfig');

  var invariant = _$$_REQUIRE(_dependencyMap[4], 'fbjs/lib/invariant');

  var _require = _$$_REQUIRE(_dependencyMap[5], '../NativeAnimatedHelper'),
      shouldUseNativeDriver = _require.shouldUseNativeDriver;

  function withDefault(value, defaultValue) {
    if (value === undefined || value === null) {
      return defaultValue;
    }

    return value;
  }

  var SpringAnimation = function (_Animation) {
    function SpringAnimation(config) {
      var _this;

      _classCallCheck(this, SpringAnimation);

      _this = _possibleConstructorReturn(this, _getPrototypeOf(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);
      _this._useNativeDriver = shouldUseNativeDriver(config);
      _this.__isInteraction = config.isInteraction !== undefined ? config.isInteraction : true;
      _this.__iterations = config.iterations !== undefined ? config.iterations : 1;

      if (config.stiffness !== undefined || config.damping !== undefined || config.mass !== undefined) {
        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 = withDefault(config.stiffness, 100);
        _this._damping = withDefault(config.damping, 10);
        _this._mass = withDefault(config.mass, 1);
      } else if (config.bounciness !== undefined || config.speed !== undefined) {
        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(withDefault(config.bounciness, 8), withDefault(config.speed, 12));
        _this._stiffness = springConfig.stiffness;
        _this._damping = springConfig.damping;
        _this._mass = 1;
      } else {
        var _springConfig = SpringConfig.fromOrigamiTensionAndFriction(withDefault(config.tension, 40), withDefault(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() {
        return {
          type: 'spring',
          overshootClamping: this._overshootClamping,
          restDisplacementThreshold: this._restDisplacementThreshold,
          restSpeedThreshold: this._restSpeedThreshold,
          stiffness: this._stiffness,
          damping: this._damping,
          mass: this._mass,
          initialVelocity: withDefault(this._initialVelocity, 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
        });
      }
    }]);

    _inherits(SpringAnimation, _Animation);

    return SpringAnimation;
  }(Animation);

  module.exports = SpringAnimation;
},355,[335,352,354,356,166,338],"node_modules/react-native/Libraries/Animated/src/animations/SpringAnimation.js");
__d(function (global, _$$_REQUIRE, 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
  };
},356,[],"node_modules/react-native/Libraries/Animated/src/SpringConfig.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _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); }

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

  function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var AnimatedValue = _$$_REQUIRE(_dependencyMap[0], '../nodes/AnimatedValue');

  var AnimatedValueXY = _$$_REQUIRE(_dependencyMap[1], '../nodes/AnimatedValueXY');

  var Animation = _$$_REQUIRE(_dependencyMap[2], './Animation');

  var _require = _$$_REQUIRE(_dependencyMap[3], '../NativeAnimatedHelper'),
      shouldUseNativeDriver = _require.shouldUseNativeDriver;

  var _easeInOut;

  function easeInOut() {
    if (!_easeInOut) {
      var Easing = _$$_REQUIRE(_dependencyMap[4], 'Easing');

      _easeInOut = Easing.inOut(Easing.ease);
    }

    return _easeInOut;
  }

  var TimingAnimation = function (_Animation) {
    function TimingAnimation(config) {
      var _this;

      _classCallCheck(this, TimingAnimation);

      _this = _possibleConstructorReturn(this, _getPrototypeOf(TimingAnimation).call(this));
      _this._toValue = config.toValue;
      _this._easing = config.easing !== undefined ? config.easing : easeInOut();
      _this._duration = config.duration !== undefined ? config.duration : 500;
      _this._delay = config.delay !== undefined ? config.delay : 0;
      _this.__iterations = config.iterations !== undefined ? config.iterations : 1;
      _this.__isInteraction = config.isInteraction !== undefined ? config.isInteraction : true;
      _this._useNativeDriver = shouldUseNativeDriver(config);
      return _this;
    }

    _createClass(TimingAnimation, [{
      key: "__getNativeAnimationConfig",
      value: function __getNativeAnimationConfig() {
        var frameDuration = 1000.0 / 60.0;
        var frames = [];

        for (var dt = 0.0; dt < this._duration; dt += frameDuration) {
          frames.push(this._easing(dt / this._duration));
        }

        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
        });
      }
    }]);

    _inherits(TimingAnimation, _Animation);

    return TimingAnimation;
  }(Animation);

  module.exports = TimingAnimation;
},357,[335,352,354,338,358],"node_modules/react-native/Libraries/Animated/src/animations/TimingAnimation.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  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(s) {
        if (s === undefined) {
          s = 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) {
          t -= 1.5 / 2.75;
          return 7.5625 * t * t + 0.75;
        }

        if (t < 2.5 / 2.75) {
          t -= 2.25 / 2.75;
          return 7.5625 * t * t + 0.9375;
        }

        t -= 2.625 / 2.75;
        return 7.5625 * t * t + 0.984375;
      }
    }, {
      key: "bezier",
      value: function bezier(x1, y1, x2, y2) {
        var _bezier = _$$_REQUIRE(_dependencyMap[0], '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;
},358,[359],"node_modules/react-native/Libraries/Animated/src/Easing.js");
__d(function (global, _$$_REQUIRE, 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;

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

  module.exports = function bezier(mX1, mY1, mX2, mY2) {
    if (!(0 <= mX1 && mX1 <= 1 && 0 <= mX2 && 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);
    };
  };
},359,[],"node_modules/react-native/Libraries/Animated/src/bezier.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _default = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[0], "react")).default;

  var _reactTransformHmrLibIndexJs = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./../../../../react-transform-hmr/lib/index.js")).default;

  var _jsxFileName = "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Animated/src/createAnimatedComponent.js";

  function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

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

  function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }

  var _components = {
    AnimatedComponent: {
      displayName: "AnimatedComponent",
      isInFunction: true
    }
  };

  var _reactTransformHmrLibIndexJs2 = _reactTransformHmrLibIndexJs({
    filename: "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Animated/src/createAnimatedComponent.js",
    components: _components,
    locals: [module],
    imports: [_default]
  });

  function _wrapComponent(id) {
    return function (Component) {
      return _reactTransformHmrLibIndexJs2(Component, id);
    };
  }

  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

  var _require = _$$_REQUIRE(_dependencyMap[2], './AnimatedEvent'),
      AnimatedEvent = _require.AnimatedEvent;

  var AnimatedProps = _$$_REQUIRE(_dependencyMap[3], './nodes/AnimatedProps');

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

  var ViewStylePropTypes = _$$_REQUIRE(_dependencyMap[5], 'ViewStylePropTypes');

  var invariant = _$$_REQUIRE(_dependencyMap[6], 'fbjs/lib/invariant');

  function createAnimatedComponent(Component) {
    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) {
      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 = _this._setComponentRef.bind(_assertThisInitialized(_assertThisInitialized(_this)));
        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 _this2 = this;

          var scrollableNode = 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({}, props, {
            ref: this._setComponentRef,
            collapsable: this._propsAnimated.__isNative ? false : props.collapsable,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 153
            }
          }));
        }
      }, {
        key: "_setComponentRef",
        value: function _setComponentRef(c) {
          this._prevComponent = this._component;
          this._component = c;
        }
      }, {
        key: "getNode",
        value: function getNode() {
          return this._component;
        }
      }]);

      _inherits(AnimatedComponent, _React$Component);

      return AnimatedComponent;
    }(React.Component);

    AnimatedComponent.__skipSetNativeProps_FOR_TESTS_ONLY = false;
    AnimatedComponent = _wrapComponent("AnimatedComponent")(AnimatedComponent);
    var propTypes = Component.propTypes;
    AnimatedComponent.propTypes = {
      style: function style(props, propName, componentName) {
        if (!propTypes) {
          return;
        }

        for (var key in ViewStylePropTypes) {
          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;
},360,[1,11,334,347,200,220,166],"node_modules/react-native/Libraries/Animated/src/createAnimatedComponent.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _jsxFileName = "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Image/Image.ios.js";

  function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

  var ImageProps = _$$_REQUIRE(_dependencyMap[0], 'ImageProps');

  var NativeMethodsMixin = _$$_REQUIRE(_dependencyMap[1], 'NativeMethodsMixin');

  var NativeModules = _$$_REQUIRE(_dependencyMap[2], 'NativeModules');

  var React = _$$_REQUIRE(_dependencyMap[3], 'React');

  var ReactNativeViewAttributes = _$$_REQUIRE(_dependencyMap[4], 'ReactNativeViewAttributes');

  var StyleSheet = _$$_REQUIRE(_dependencyMap[5], 'StyleSheet');

  var createReactClass = _$$_REQUIRE(_dependencyMap[6], 'create-react-class');

  var flattenStyle = _$$_REQUIRE(_dependencyMap[7], 'flattenStyle');

  var requireNativeComponent = _$$_REQUIRE(_dependencyMap[8], 'requireNativeComponent');

  var resolveAssetSource = _$$_REQUIRE(_dependencyMap[9], 'resolveAssetSource');

  var ImageViewManager = NativeModules.ImageViewManager;
  var RCTImageView = requireNativeComponent('RCTImageView');
  var Image = createReactClass({
    displayName: 'Image',
    propTypes: ImageProps,
    statics: {
      getSize: function getSize(uri, success, failure) {
        ImageViewManager.getSize(uri, success, failure || function () {
          console.warn('Failed to get size for image: ' + uri);
        });
      },
      prefetch: function prefetch(url) {
        return ImageViewManager.prefetchImage(url);
      },
      resolveAssetSource: resolveAssetSource
    },
    mixins: [NativeMethodsMixin],
    viewConfig: {
      uiViewClassName: 'UIView',
      validAttributes: ReactNativeViewAttributes.UIView
    },
    render: function render() {
      var source = resolveAssetSource(this.props.source) || {
        uri: undefined,
        width: undefined,
        height: undefined
      };
      var sources;
      var style;

      if (Array.isArray(source)) {
        style = flattenStyle([styles.base, this.props.style]) || {};
        sources = source;
      } else {
        var _width = source.width,
            _height = source.height,
            uri = source.uri;
        style = flattenStyle([{
          width: _width,
          height: _height
        }, styles.base, this.props.style]) || {};
        sources = [source];

        if (uri === '') {
          console.warn('source.uri should not be an empty string');
        }
      }

      var resizeMode = this.props.resizeMode || (style || {}).resizeMode || 'cover';
      var tintColor = (style || {}).tintColor;

      if (this.props.src) {
        console.warn('The <Image> component requires a `source` property rather than `src`.');
      }

      if (this.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.');
      }

      return React.createElement(RCTImageView, _extends({}, this.props, {
        style: style,
        resizeMode: resizeMode,
        tintColor: tintColor,
        source: sources,
        __source: {
          fileName: _jsxFileName,
          lineNumber: 127
        }
      }));
    }
  });
  var styles = StyleSheet.create({
    base: {
      overflow: 'hidden'
    }
  });
  module.exports = Image;
},361,[362,364,168,200,247,201,365,226,229,235],"node_modules/react-native/Libraries/Image/Image.ios.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var EdgeInsetsPropType = _$$_REQUIRE(_dependencyMap[0], 'EdgeInsetsPropType');

  var ImageSourcePropType = _$$_REQUIRE(_dependencyMap[1], 'ImageSourcePropType');

  var ImageStylePropTypes = _$$_REQUIRE(_dependencyMap[2], 'ImageStylePropTypes');

  var PropTypes = _$$_REQUIRE(_dependencyMap[3], 'prop-types');

  var StyleSheetPropType = _$$_REQUIRE(_dependencyMap[4], 'StyleSheetPropType');

  module.exports = {
    style: StyleSheetPropType(ImageStylePropTypes),
    source: ImageSourcePropType,
    defaultSource: PropTypes.oneOfType([PropTypes.shape({
      uri: PropTypes.string,
      width: PropTypes.number,
      height: PropTypes.number,
      scale: PropTypes.number
    }), PropTypes.number]),
    accessible: PropTypes.bool,
    accessibilityLabel: PropTypes.node,
    blurRadius: PropTypes.number,
    capInsets: EdgeInsetsPropType,
    resizeMethod: PropTypes.oneOf(['auto', 'resize', 'scale']),
    resizeMode: PropTypes.oneOf(['cover', 'contain', 'stretch', 'repeat', 'center']),
    testID: PropTypes.string,
    onLayout: PropTypes.func,
    onLoadStart: PropTypes.func,
    onProgress: PropTypes.func,
    onError: PropTypes.func,
    onPartialLoad: PropTypes.func,
    onLoad: PropTypes.func,
    onLoadEnd: PropTypes.func
  };
},362,[254,363,206,212,255],"node_modules/react-native/Libraries/Image/ImageProps.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var PropTypes = _$$_REQUIRE(_dependencyMap[0], 'prop-types');

  var ImageURISourcePropType = PropTypes.shape({
    uri: PropTypes.string,
    bundle: PropTypes.string,
    method: PropTypes.string,
    headers: PropTypes.objectOf(PropTypes.string),
    body: PropTypes.string,
    cache: PropTypes.oneOf(['default', 'reload', 'force-cache', 'only-if-cached']),
    width: PropTypes.number,
    height: PropTypes.number,
    scale: PropTypes.number
  });
  var ImageSourcePropType = PropTypes.oneOfType([ImageURISourcePropType, PropTypes.number, PropTypes.arrayOf(ImageURISourcePropType)]);
  module.exports = ImageSourcePropType;
},363,[212],"node_modules/react-native/Libraries/Image/ImageSourcePropType.js");
__d(function (global, _$$_REQUIRE, 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;
},364,[261],"node_modules/react-native/Libraries/Renderer/shims/NativeMethodsMixin.js");
__d(function (global, _$$_REQUIRE, 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);
},365,[1,366],"node_modules/create-react-class/index.js");
__d(function (global, _$$_REQUIRE, 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;
},366,[3,5,4,8],"node_modules/create-react-class/factory.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _jsxFileName = "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Components/ScrollView/ScrollView.js";

  function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

  function _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 AnimatedImplementation = _$$_REQUIRE(_dependencyMap[0], 'AnimatedImplementation');

  var ColorPropType = _$$_REQUIRE(_dependencyMap[1], 'ColorPropType');

  var EdgeInsetsPropType = _$$_REQUIRE(_dependencyMap[2], 'EdgeInsetsPropType');

  var Platform = _$$_REQUIRE(_dependencyMap[3], 'Platform');

  var PointPropType = _$$_REQUIRE(_dependencyMap[4], 'PointPropType');

  var PropTypes = _$$_REQUIRE(_dependencyMap[5], 'prop-types');

  var React = _$$_REQUIRE(_dependencyMap[6], 'React');

  var ReactNative = _$$_REQUIRE(_dependencyMap[7], 'ReactNative');

  var ScrollResponder = _$$_REQUIRE(_dependencyMap[8], 'ScrollResponder');

  var ScrollViewStickyHeader = _$$_REQUIRE(_dependencyMap[9], 'ScrollViewStickyHeader');

  var StyleSheet = _$$_REQUIRE(_dependencyMap[10], 'StyleSheet');

  var StyleSheetPropType = _$$_REQUIRE(_dependencyMap[11], 'StyleSheetPropType');

  var View = _$$_REQUIRE(_dependencyMap[12], 'View');

  var ViewPropTypes = _$$_REQUIRE(_dependencyMap[13], 'ViewPropTypes');

  var ViewStylePropTypes = _$$_REQUIRE(_dependencyMap[14], 'ViewStylePropTypes');

  var InternalScrollViewType = _$$_REQUIRE(_dependencyMap[15], 'InternalScrollViewType');

  var createReactClass = _$$_REQUIRE(_dependencyMap[16], 'create-react-class');

  var dismissKeyboard = _$$_REQUIRE(_dependencyMap[17], 'dismissKeyboard');

  var flattenStyle = _$$_REQUIRE(_dependencyMap[18], 'flattenStyle');

  var invariant = _$$_REQUIRE(_dependencyMap[19], 'fbjs/lib/invariant');

  var processDecelerationRate = _$$_REQUIRE(_dependencyMap[20], 'processDecelerationRate');

  var requireNativeComponent = _$$_REQUIRE(_dependencyMap[21], 'requireNativeComponent');

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

  var resolveAssetSource = _$$_REQUIRE(_dependencyMap[23], 'resolveAssetSource');

  var AndroidScrollView;
  var AndroidHorizontalScrollContentView;
  var AndroidHorizontalScrollView;
  var RCTScrollView;
  var RCTScrollContentView;

  if (Platform.OS === 'android') {
    AndroidScrollView = requireNativeComponent('RCTScrollView');
    AndroidHorizontalScrollView = requireNativeComponent('AndroidHorizontalScrollView');
    AndroidHorizontalScrollContentView = requireNativeComponent('AndroidHorizontalScrollContentView');
  } else if (Platform.OS === 'ios') {
    RCTScrollView = requireNativeComponent('RCTScrollView');
    RCTScrollContentView = requireNativeComponent('RCTScrollContentView');
  } else {
    RCTScrollView = requireNativeComponent('RCTScrollView');
    RCTScrollContentView = requireNativeComponent('RCTScrollContentView');
  }

  var ScrollView = createReactClass({
    displayName: 'ScrollView',
    propTypes: _objectSpread({}, ViewPropTypes, {
      automaticallyAdjustContentInsets: PropTypes.bool,
      contentInset: EdgeInsetsPropType,
      contentOffset: PointPropType,
      bounces: PropTypes.bool,
      bouncesZoom: PropTypes.bool,
      alwaysBounceHorizontal: PropTypes.bool,
      alwaysBounceVertical: PropTypes.bool,
      centerContent: PropTypes.bool,
      contentContainerStyle: StyleSheetPropType(ViewStylePropTypes),
      decelerationRate: PropTypes.oneOfType([PropTypes.oneOf(['fast', 'normal']), PropTypes.number]),
      horizontal: PropTypes.bool,
      indicatorStyle: PropTypes.oneOf(['default', 'black', 'white']),
      invertStickyHeaders: PropTypes.bool,
      directionalLockEnabled: PropTypes.bool,
      canCancelContentTouches: PropTypes.bool,
      keyboardDismissMode: PropTypes.oneOf(['none', 'on-drag', 'interactive']),
      keyboardShouldPersistTaps: PropTypes.oneOf(['always', 'never', 'handled', false, true]),
      maintainVisibleContentPosition: PropTypes.shape({
        minIndexForVisible: PropTypes.number.isRequired,
        autoscrollToTopThreshold: PropTypes.number
      }),
      maximumZoomScale: PropTypes.number,
      minimumZoomScale: PropTypes.number,
      nestedScrollEnabled: PropTypes.bool,
      onMomentumScrollBegin: PropTypes.func,
      onMomentumScrollEnd: PropTypes.func,
      onScroll: PropTypes.func,
      onScrollBeginDrag: PropTypes.func,
      onScrollEndDrag: PropTypes.func,
      onContentSizeChange: PropTypes.func,
      pagingEnabled: PropTypes.bool,
      pinchGestureEnabled: PropTypes.bool,
      scrollEnabled: PropTypes.bool,
      scrollEventThrottle: PropTypes.number,
      scrollIndicatorInsets: EdgeInsetsPropType,
      scrollsToTop: PropTypes.bool,
      showsHorizontalScrollIndicator: PropTypes.bool,
      showsVerticalScrollIndicator: PropTypes.bool,
      stickyHeaderIndices: PropTypes.arrayOf(PropTypes.number),
      snapToInterval: PropTypes.number,
      snapToAlignment: PropTypes.oneOf(['start', 'center', 'end']),
      removeClippedSubviews: PropTypes.bool,
      zoomScale: PropTypes.number,
      contentInsetAdjustmentBehavior: PropTypes.oneOf(['automatic', 'scrollableAxes', 'never', 'always']),
      refreshControl: PropTypes.element,
      endFillColor: ColorPropType,
      scrollPerfTag: PropTypes.string,
      overScrollMode: PropTypes.oneOf(['auto', 'always', 'never']),
      DEPRECATED_sendUpdatedChildFrames: PropTypes.bool,
      scrollBarThumbImage: PropTypes.oneOfType([PropTypes.shape({
        uri: PropTypes.string
      }), PropTypes.number])
    }),
    mixins: [ScrollResponder.Mixin],
    _scrollAnimatedValue: new AnimatedImplementation.Value(0),
    _scrollAnimatedValueAttachment: null,
    _stickyHeaderRefs: new Map(),
    _headerLayoutYs: new Map(),
    getInitialState: function getInitialState() {
      return _objectSpread({}, this.scrollResponderMixinGetInitialState(), {
        layoutHeight: null
      });
    },
    UNSAFE_componentWillMount: function 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);

      this._stickyHeaderRefs = new Map();
      this._headerLayoutYs = new Map();
    },
    componentDidMount: function componentDidMount() {
      this._updateAnimatedNodeAttachment();
    },
    componentDidUpdate: function componentDidUpdate() {
      this._updateAnimatedNodeAttachment();
    },
    componentWillUnmount: function componentWillUnmount() {
      if (this._scrollAnimatedValueAttachment) {
        this._scrollAnimatedValueAttachment.detach();
      }
    },
    setNativeProps: function setNativeProps(props) {
      this._scrollViewRef && this._scrollViewRef.setNativeProps(props);
    },
    getScrollResponder: function getScrollResponder() {
      return this;
    },
    getScrollableNode: function getScrollableNode() {
      return ReactNative.findNodeHandle(this._scrollViewRef);
    },
    getInnerViewNode: function getInnerViewNode() {
      return ReactNative.findNodeHandle(this._innerViewRef);
    },
    scrollTo: function scrollTo(y, x, animated) {
      if (typeof y === 'number') {
        console.warn('`scrollTo(y, x, animated)` is deprecated. Use `scrollTo({x: 5, y: 5, ' + 'animated: true})` instead.');
      } else {
        var _ref = y || {};

        x = _ref.x;
        y = _ref.y;
        animated = _ref.animated;
      }

      this.getScrollResponder().scrollResponderScrollTo({
        x: x || 0,
        y: y || 0,
        animated: animated !== false
      });
    },
    scrollToEnd: function scrollToEnd(options) {
      var animated = (options && options.animated) !== false;
      this.getScrollResponder().scrollResponderScrollToEnd({
        animated: animated
      });
    },
    scrollWithoutAnimationTo: 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
      });
    },
    flashScrollIndicators: function flashScrollIndicators() {
      this.getScrollResponder().scrollResponderFlashScrollIndicators();
    },
    _getKeyForIndex: function _getKeyForIndex(index, childArray) {
      var child = childArray[index];
      return child && child.key;
    },
    _updateAnimatedNodeAttachment: 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
            }
          }
        }]);
      }
    },
    _setStickyHeaderRef: function _setStickyHeaderRef(key, ref) {
      if (ref) {
        this._stickyHeaderRefs.set(key, ref);
      } else {
        this._stickyHeaderRefs.delete(key);
      }
    },
    _onStickyHeaderLayout: function _onStickyHeaderLayout(index, event, key) {
      if (!this.props.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 = this.props.stickyHeaderIndices.indexOf(index);
      var previousHeaderIndex = this.props.stickyHeaderIndices[indexOfIndex - 1];

      if (previousHeaderIndex != null) {
        var previousHeader = this._stickyHeaderRefs.get(this._getKeyForIndex(previousHeaderIndex, childArray));

        previousHeader && previousHeader.setNextHeaderY(layoutY);
      }
    },
    _handleScroll: function _handleScroll(e) {
      if (__DEV__) {
        if (this.props.onScroll && this.props.scrollEventThrottle == null && Platform.OS === '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 (Platform.OS === 'android') {
        if (this.props.keyboardDismissMode === 'on-drag' && this.state.isTouching) {
          dismissKeyboard();
        }
      }

      this.scrollResponderHandleScroll(e);
    },
    _handleLayout: function _handleLayout(e) {
      if (this.props.invertStickyHeaders) {
        this.setState({
          layoutHeight: e.nativeEvent.layout.height
        });
      }

      if (this.props.onLayout) {
        this.props.onLayout(e);
      }
    },
    _handleContentOnLayout: function _handleContentOnLayout(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);
    },
    _scrollViewRef: null,
    _setScrollViewRef: function _setScrollViewRef(ref) {
      this._scrollViewRef = ref;
    },
    _innerViewRef: null,
    _setInnerViewRef: function _setInnerViewRef(ref) {
      this._innerViewRef = ref;
    },
    render: function render() {
      var _this = this;

      var ScrollViewClass;
      var ScrollContentContainerViewClass;

      if (Platform.OS === 'android') {
        if (this.props.horizontal) {
          ScrollViewClass = AndroidHorizontalScrollView;
          ScrollContentContainerViewClass = AndroidHorizontalScrollContentView;
        } else {
          ScrollViewClass = AndroidScrollView;
          ScrollContentContainerViewClass = View;
        }
      } else {
        ScrollViewClass = RCTScrollView;
        ScrollContentContainerViewClass = RCTScrollContentView;
        warning(!this.props.snapToInterval || !this.props.pagingEnabled, 'snapToInterval is currently ignored when pagingEnabled is true.');
      }

      invariant(ScrollViewClass !== undefined, 'ScrollViewClass must not be undefined');
      invariant(ScrollContentContainerViewClass !== undefined, 'ScrollContentContainerViewClass must not be undefined');
      var contentContainerStyle = [this.props.horizontal && styles.contentContainerHorizontal, this.props.contentContainerStyle];

      if (__DEV__ && this.props.style) {
        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 hasStickyHeaders = stickyHeaderIndices && stickyHeaderIndices.length > 0;
      var childArray = hasStickyHeaders && React.Children.toArray(this.props.children);
      var children = hasStickyHeaders ? childArray.map(function (child, index) {
        var indexOfIndex = child ? stickyHeaderIndices.indexOf(index) : -1;

        if (indexOfIndex > -1) {
          var key = child.key;
          var nextIndex = stickyHeaderIndices[indexOfIndex + 1];
          return React.createElement(ScrollViewStickyHeader, {
            key: key,
            ref: function ref(_ref2) {
              return _this._setStickyHeaderRef(key, _ref2);
            },
            nextHeaderLayoutY: _this._headerLayoutYs.get(_this._getKeyForIndex(nextIndex, childArray)),
            onLayout: function onLayout(event) {
              return _this._onStickyHeaderLayout(index, event, key);
            },
            scrollAnimatedValue: _this._scrollAnimatedValue,
            inverted: _this.props.invertStickyHeaders,
            scrollViewHeight: _this.state.layoutHeight,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 933
            }
          }, child);
        } else {
          return child;
        }
      }) : this.props.children;
      var contentContainer = React.createElement(ScrollContentContainerViewClass, _extends({}, contentSizeChangeProps, {
        ref: this._setInnerViewRef,
        style: contentContainerStyle,
        removeClippedSubviews: Platform.OS === 'android' && hasStickyHeaders ? false : this.props.removeClippedSubviews,
        collapsable: false,
        __source: {
          fileName: _jsxFileName,
          lineNumber: 955
        }
      }), 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 ? 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.scrollResponderHandleMomentumScrollBegin,
        onMomentumScrollEnd: this.scrollResponderHandleMomentumScrollEnd,
        onResponderGrant: this.scrollResponderHandleResponderGrant,
        onResponderReject: this.scrollResponderHandleResponderReject,
        onResponderRelease: this.scrollResponderHandleResponderRelease,
        onResponderTerminate: this.scrollResponderHandleTerminate,
        onResponderTerminationRequest: this.scrollResponderHandleTerminationRequest,
        onScroll: this._handleScroll,
        onScrollBeginDrag: this.scrollResponderHandleScrollBeginDrag,
        onScrollEndDrag: this.scrollResponderHandleScrollEndDrag,
        onScrollShouldSetResponder: this.scrollResponderHandleScrollShouldSetResponder,
        onStartShouldSetResponder: this.scrollResponderHandleStartShouldSetResponder,
        onStartShouldSetResponderCapture: this.scrollResponderHandleStartShouldSetResponderCapture,
        onTouchEnd: this.scrollResponderHandleTouchEnd,
        onTouchMove: this.scrollResponderHandleTouchMove,
        onTouchStart: this.scrollResponderHandleTouchStart,
        onTouchCancel: this.scrollResponderHandleTouchCancel,
        scrollBarThumbImage: resolveAssetSource(this.props.scrollBarThumbImage),
        scrollEventThrottle: hasStickyHeaders ? 1 : this.props.scrollEventThrottle,
        sendMomentumEvents: this.props.onMomentumScrollBegin || this.props.onMomentumScrollEnd ? true : false,
        DEPRECATED_sendUpdatedChildFrames: DEPRECATED_sendUpdatedChildFrames
      });

      var decelerationRate = this.props.decelerationRate;

      if (decelerationRate) {
        props.decelerationRate = processDecelerationRate(decelerationRate);
      }

      var refreshControl = this.props.refreshControl;

      if (refreshControl) {
        if (Platform.OS === 'ios') {
          return React.createElement(ScrollViewClass, _extends({}, props, {
            ref: this._setScrollViewRef,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 1043
            }
          }), Platform.isTV ? null : refreshControl, contentContainer);
        } else if (Platform.OS === 'android') {
          return React.cloneElement(refreshControl, {
            style: props.style
          }, React.createElement(ScrollViewClass, _extends({}, props, {
            style: baseStyle,
            ref: this._setScrollViewRef,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 1058
            }
          }), contentContainer));
        }
      }

      return React.createElement(ScrollViewClass, _extends({}, props, {
        ref: this._setScrollViewRef,
        __source: {
          fileName: _jsxFileName,
          lineNumber: 1070
        }
      }), contentContainer);
    }
  });
  var TypedScrollView = ScrollView;
  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 = TypedScrollView;
},367,[333,207,254,176,368,212,200,261,369,375,201,255,227,376,220,380,365,373,226,166,381,229,183,235],"node_modules/react-native/Libraries/Components/ScrollView/ScrollView.js");
__d(function (global, _$$_REQUIRE, 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;
},368,[212],"node_modules/react-native/Libraries/StyleSheet/PointPropType.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var Dimensions = _$$_REQUIRE(_dependencyMap[0], 'Dimensions');

  var FrameRateLogger = _$$_REQUIRE(_dependencyMap[1], 'FrameRateLogger');

  var Keyboard = _$$_REQUIRE(_dependencyMap[2], 'Keyboard');

  var ReactNative = _$$_REQUIRE(_dependencyMap[3], 'ReactNative');

  var Subscribable = _$$_REQUIRE(_dependencyMap[4], 'Subscribable');

  var TextInputState = _$$_REQUIRE(_dependencyMap[5], 'TextInputState');

  var UIManager = _$$_REQUIRE(_dependencyMap[6], 'UIManager');

  var invariant = _$$_REQUIRE(_dependencyMap[7], 'fbjs/lib/invariant');

  var nullthrows = _$$_REQUIRE(_dependencyMap[8], 'fbjs/lib/nullthrows');

  var performanceNow = _$$_REQUIRE(_dependencyMap[9], 'fbjs/lib/performanceNow');

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

  var _require = _$$_REQUIRE(_dependencyMap[11], 'NativeModules'),
      ScrollViewManager = _require.ScrollViewManager;

  var IS_ANIMATING_TOUCH_START_THRESHOLD_MS = 16;
  var ScrollResponderMixin = {
    mixins: [Subscribable.Mixin],
    scrollResponderMixinGetInitialState: function scrollResponderMixinGetInitialState() {
      return {
        isTouching: false,
        lastMomentumScrollBeginTime: 0,
        lastMomentumScrollEndTime: 0,
        observedScrollSinceBecomingResponder: false,
        becameResponderWhileAnimating: false
      };
    },
    scrollResponderHandleScrollShouldSetResponder: function scrollResponderHandleScrollShouldSetResponder() {
      return this.state.isTouching;
    },
    scrollResponderHandleStartShouldSetResponder: function scrollResponderHandleStartShouldSetResponder(e) {
      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;
      }

      var currentlyFocusedTextInput = TextInputState.currentlyFocusedField();
      var keyboardShouldPersistTaps = this.props.keyboardShouldPersistTaps;
      var keyboardNeverPersistTaps = !keyboardShouldPersistTaps || keyboardShouldPersistTaps === 'never';

      if (keyboardNeverPersistTaps && currentlyFocusedTextInput != null && !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.RCTScrollView.Commands.scrollTo, [x || 0, y || 0, animated !== false]);
    },
    scrollResponderScrollToEnd: function scrollResponderScrollToEnd(options) {
      var animated = (options && options.animated) !== false;
      UIManager.dispatchViewManagerCommand(this.scrollResponderGetScrollableNode(), UIManager.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.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(e) {
      console.error('Error measuring text field: ', e);
    },
    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.addListenerOn(Keyboard, 'keyboardWillShow', this.scrollResponderKeyboardWillShow);
      this.addListenerOn(Keyboard, 'keyboardWillHide', this.scrollResponderKeyboardWillHide);
      this.addListenerOn(Keyboard, 'keyboardDidShow', this.scrollResponderKeyboardDidShow);
      this.addListenerOn(Keyboard, 'keyboardDidHide', this.scrollResponderKeyboardDidHide);
    },
    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;
},369,[203,370,371,261,374,325,218,166,329,177,183,168],"node_modules/react-native/Libraries/Components/ScrollResponder.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var NativeModules = _$$_REQUIRE(_dependencyMap[0], 'NativeModules');

  var invariant = _$$_REQUIRE(_dependencyMap[1], 'fbjs/lib/invariant');

  var FrameRateLogger = {
    setGlobalOptions: function setGlobalOptions(options) {
      if (options.debug !== undefined) {
        invariant(NativeModules.FrameRateLogger, 'Trying to debug FrameRateLogger without the native module!');
      }

      if (NativeModules.FrameRateLogger) {
        var optionsClone = {
          debug: !!options.debug,
          reportStackTraces: !!options.reportStackTraces
        };
        Object.freeze(optionsClone);
        Object.seal(optionsClone);
        NativeModules.FrameRateLogger.setGlobalOptions(optionsClone);
      }
    },
    setContext: function setContext(context) {
      NativeModules.FrameRateLogger && NativeModules.FrameRateLogger.setContext(context);
    },
    beginScroll: function beginScroll() {
      NativeModules.FrameRateLogger && NativeModules.FrameRateLogger.beginScroll();
    },
    endScroll: function endScroll() {
      NativeModules.FrameRateLogger && NativeModules.FrameRateLogger.endScroll();
    }
  };
  module.exports = FrameRateLogger;
},370,[168,166],"node_modules/react-native/Libraries/Interaction/FrameRateLogger.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var LayoutAnimation = _$$_REQUIRE(_dependencyMap[0], 'LayoutAnimation');

  var invariant = _$$_REQUIRE(_dependencyMap[1], 'fbjs/lib/invariant');

  var NativeEventEmitter = _$$_REQUIRE(_dependencyMap[2], 'NativeEventEmitter');

  var KeyboardObserver = _$$_REQUIRE(_dependencyMap[3], 'NativeModules').KeyboardObserver;

  var dismissKeyboard = _$$_REQUIRE(_dependencyMap[4], 'dismissKeyboard');

  var KeyboardEventEmitter = new NativeEventEmitter(KeyboardObserver);
  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) {
      LayoutAnimation.configureNext({
        duration: duration,
        update: {
          duration: duration,
          type: easing && LayoutAnimation.Types[easing] || 'keyboard'
        }
      });
    }
  };

  module.exports = Keyboard;
},371,[372,166,286,168,373],"node_modules/react-native/Libraries/Components/Keyboard/Keyboard.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var PropTypes = _$$_REQUIRE(_dependencyMap[0], 'prop-types');

  var UIManager = _$$_REQUIRE(_dependencyMap[1], 'UIManager');

  var keyMirror = _$$_REQUIRE(_dependencyMap[2], 'fbjs/lib/keyMirror');

  var checkPropTypes = PropTypes.checkPropTypes;
  var TypesEnum = {
    spring: true,
    linear: true,
    easeInEaseOut: true,
    easeIn: true,
    easeOut: true,
    keyboard: true
  };
  var Types = keyMirror(TypesEnum);
  var PropertiesEnum = {
    opacity: true,
    scaleX: true,
    scaleY: true,
    scaleXY: true
  };
  var Properties = keyMirror(PropertiesEnum);
  var animType = PropTypes.shape({
    duration: PropTypes.number,
    delay: PropTypes.number,
    springDamping: PropTypes.number,
    initialVelocity: PropTypes.number,
    type: PropTypes.oneOf(Object.keys(Types)).isRequired,
    property: PropTypes.oneOf(Object.keys(Properties))
  });
  var configType = PropTypes.shape({
    duration: PropTypes.number.isRequired,
    create: animType,
    update: animType,
    delete: animType
  });

  function checkConfig(config, location, name) {
    checkPropTypes({
      config: configType
    }, {
      config: config
    }, location, name);
  }

  function configureNext(config, onAnimationDidEnd) {
    if (__DEV__) {
      checkConfig(config, 'config', 'LayoutAnimation.configureNext');
    }

    UIManager.configureNextLayoutAnimation(config, onAnimationDidEnd || function () {}, function () {});
  }

  function create(duration, type, creationProp) {
    return {
      duration: duration,
      create: {
        type: type,
        property: creationProp
      },
      update: {
        type: type
      },
      delete: {
        type: type,
        property: creationProp
      }
    };
  }

  var Presets = {
    easeInEaseOut: create(300, Types.easeInEaseOut, Properties.opacity),
    linear: create(500, Types.linear, Properties.opacity),
    spring: {
      duration: 700,
      create: {
        type: Types.linear,
        property: Properties.opacity
      },
      update: {
        type: Types.spring,
        springDamping: 0.4
      },
      delete: {
        type: Types.linear,
        property: Properties.opacity
      }
    }
  };
  var LayoutAnimation = {
    configureNext: configureNext,
    create: create,
    Types: Types,
    Properties: Properties,
    checkConfig: checkConfig,
    Presets: Presets,
    easeInEaseOut: configureNext.bind(null, Presets.easeInEaseOut),
    linear: configureNext.bind(null, Presets.linear),
    spring: configureNext.bind(null, Presets.spring)
  };
  module.exports = LayoutAnimation;
},372,[212,218,210],"node_modules/react-native/Libraries/LayoutAnimation/LayoutAnimation.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var TextInputState = _$$_REQUIRE(_dependencyMap[0], 'TextInputState');

  function dismissKeyboard() {
    TextInputState.blurTextInput(TextInputState.currentlyFocusedField());
  }

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

  var Subscribable = {};
  Subscribable.Mixin = {
    UNSAFE_componentWillMount: function UNSAFE_componentWillMount() {
      this._subscribableSubscriptions = [];
    },
    componentWillUnmount: function componentWillUnmount() {
      this._subscribableSubscriptions && this._subscribableSubscriptions.forEach(function (subscription) {
        return subscription.remove();
      });
      this._subscribableSubscriptions = null;
    },
    addListenerOn: function addListenerOn(eventEmitter, eventType, listener, context) {
      this._subscribableSubscriptions.push(eventEmitter.addListener(eventType, listener, context));
    }
  };
  module.exports = Subscribable;
},374,[],"node_modules/react-native/Libraries/Components/Subscribable.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _default = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[0], "react")).default;

  var _reactTransformHmrLibIndexJs = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./../../../../react-transform-hmr/lib/index.js")).default;

  var _jsxFileName = "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Components/ScrollView/ScrollViewStickyHeader.js";

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var _components = {
    ScrollViewStickyHeader: {
      displayName: "ScrollViewStickyHeader"
    }
  };

  var _reactTransformHmrLibIndexJs2 = _reactTransformHmrLibIndexJs({
    filename: "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Components/ScrollView/ScrollViewStickyHeader.js",
    components: _components,
    locals: [module],
    imports: [_default]
  });

  function _wrapComponent(id) {
    return function (Component) {
      return _reactTransformHmrLibIndexJs2(Component, id);
    };
  }

  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

  var AnimatedImplementation = _$$_REQUIRE(_dependencyMap[2], 'AnimatedImplementation');

  var React = _$$_REQUIRE(_dependencyMap[3], 'React');

  var StyleSheet = _$$_REQUIRE(_dependencyMap[4], 'StyleSheet');

  var View = _$$_REQUIRE(_dependencyMap[5], 'View');

  var AnimatedView = AnimatedImplementation.createAnimatedComponent(View);

  var ScrollViewStickyHeader = function (_React$Component) {
    function ScrollViewStickyHeader() {
      var _getPrototypeOf2;

      var _temp, _this;

      _classCallCheck(this, ScrollViewStickyHeader);

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

      return _possibleConstructorReturn(_this, (_temp = _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);
        }
      }, _temp));
    }

    _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
        }));
      }
    }]);

    _inherits(ScrollViewStickyHeader, _React$Component);

    return ScrollViewStickyHeader;
  }(React.Component);

  ScrollViewStickyHeader = _wrapComponent("ScrollViewStickyHeader")(ScrollViewStickyHeader);
  var styles = StyleSheet.create({
    header: {
      zIndex: 10
    },
    fill: {
      flex: 1
    }
  });
  module.exports = ScrollViewStickyHeader;
},375,[1,11,333,200,201,227],"node_modules/react-native/Libraries/Components/ScrollView/ScrollViewStickyHeader.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  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 React = _$$_REQUIRE(_dependencyMap[0], 'React');

  var EdgeInsetsPropType = _$$_REQUIRE(_dependencyMap[1], 'EdgeInsetsPropType');

  var PlatformViewPropTypes = _$$_REQUIRE(_dependencyMap[2], 'PlatformViewPropTypes');

  var PropTypes = _$$_REQUIRE(_dependencyMap[3], 'prop-types');

  var StyleSheetPropType = _$$_REQUIRE(_dependencyMap[4], 'StyleSheetPropType');

  var ViewStylePropTypes = _$$_REQUIRE(_dependencyMap[5], 'ViewStylePropTypes');

  var _require = _$$_REQUIRE(_dependencyMap[6], 'ViewAccessibility'),
      AccessibilityComponentTypes = _require.AccessibilityComponentTypes,
      AccessibilityTraits = _require.AccessibilityTraits;

  var stylePropType = StyleSheetPropType(ViewStylePropTypes);
  module.exports = _objectSpread({
    accessible: PropTypes.bool,
    accessibilityLabel: PropTypes.node,
    accessibilityActions: PropTypes.arrayOf(PropTypes.string),
    accessibilityComponentType: PropTypes.oneOf(AccessibilityComponentTypes),
    accessibilityLiveRegion: PropTypes.oneOf(['none', 'polite', 'assertive']),
    importantForAccessibility: PropTypes.oneOf(['auto', 'yes', 'no', 'no-hide-descendants']),
    accessibilityTraits: PropTypes.oneOfType([PropTypes.oneOf(AccessibilityTraits), PropTypes.arrayOf(PropTypes.oneOf(AccessibilityTraits))]),
    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: EdgeInsetsPropType,
    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);
},376,[200,254,377,212,255,220,379],"node_modules/react-native/Libraries/Components/View/ViewPropTypes.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  var Platform = _$$_REQUIRE(_dependencyMap[0], 'Platform');

  var TVViewPropTypes = {};

  if (Platform.isTV || Platform.OS === 'android') {
    TVViewPropTypes = _$$_REQUIRE(_dependencyMap[1], 'TVViewPropTypes');
  }

  module.exports = TVViewPropTypes;
},377,[176,378],"node_modules/react-native/Libraries/Components/View/PlatformViewPropTypes.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var PropTypes = _$$_REQUIRE(_dependencyMap[0], 'prop-types');

  var TVViewPropTypes = {
    isTVSelectable: PropTypes.bool,
    hasTVPreferredFocus: PropTypes.bool,
    tvParallaxProperties: PropTypes.object,
    tvParallaxShiftDistanceX: PropTypes.number,
    tvParallaxShiftDistanceY: PropTypes.number,
    tvParallaxTiltAngle: PropTypes.number,
    tvParallaxMagnification: PropTypes.number
  };
  module.exports = TVViewPropTypes;
},378,[212],"node_modules/react-native/Libraries/Components/AppleTV/TVViewPropTypes.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  module.exports = {
    AccessibilityTraits: ['none', 'button', 'link', 'header', 'search', 'image', 'selected', 'plays', 'key', 'text', 'summary', 'disabled', 'frequentUpdates', 'startsMedia', 'adjustable', 'allowsDirectInteraction', 'pageTurn'],
    AccessibilityComponentTypes: ['none', 'button', 'radiobutton_checked', 'radiobutton_unchecked']
  };
},379,[],"node_modules/react-native/Libraries/Components/View/ViewAccessibility.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var ReactNative = _$$_REQUIRE(_dependencyMap[0], 'ReactNative');

  var InternalScrollViewType = function (_ReactNative$NativeCo) {
    "use strict";

    function InternalScrollViewType() {
      _classCallCheck(this, InternalScrollViewType);

      return _possibleConstructorReturn(this, _getPrototypeOf(InternalScrollViewType).apply(this, arguments));
    }

    _createClass(InternalScrollViewType, [{
      key: "scrollTo",
      value: function scrollTo(y, x, animated) {}
    }, {
      key: "flashScrollIndicators",
      value: function flashScrollIndicators() {}
    }, {
      key: "scrollToEnd",
      value: function scrollToEnd(options) {}
    }, {
      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;
      }
    }, {
      key: "getScrollResponder",
      value: function getScrollResponder() {}
    }, {
      key: "getScrollableNode",
      value: function getScrollableNode() {}
    }, {
      key: "getInnerViewNode",
      value: function getInnerViewNode() {}
    }, {
      key: "scrollResponderScrollNativeHandleToKeyboard",
      value: function scrollResponderScrollNativeHandleToKeyboard(nodeHandle, additionalOffset, preventNegativeScrollOffset) {}
    }, {
      key: "scrollResponderScrollTo",
      value: function scrollResponderScrollTo(x, y, animated) {}
    }]);

    _inherits(InternalScrollViewType, _ReactNative$NativeCo);

    return InternalScrollViewType;
  }(ReactNative.NativeComponent);

  module.exports = InternalScrollViewType;
},380,[261],"node_modules/react-native/Libraries/Components/ScrollView/InternalScrollViewType.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function processDecelerationRate(decelerationRate) {
    if (decelerationRate === 'normal') {
      decelerationRate = 0.998;
    } else if (decelerationRate === 'fast') {
      decelerationRate = 0.99;
    }

    return decelerationRate;
  }

  module.exports = processDecelerationRate;
},381,[],"node_modules/react-native/Libraries/Components/ScrollView/processDecelerationRate.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var GLOBAL = typeof window === 'undefined' ? global : window;

  var setter = function setter(_setter, _clearer, array) {
    return function (callback, delta) {
      var id = _setter(function () {
        _clearer.call(this, id);

        callback.apply(this, arguments);
      }.bind(this), delta);

      if (!this[array]) {
        this[array] = [id];
      } else {
        this[array].push(id);
      }

      return id;
    };
  };

  var clearer = function clearer(_clearer, array) {
    return function (id) {
      if (this[array]) {
        var index = this[array].indexOf(id);

        if (index !== -1) {
          this[array].splice(index, 1);
        }
      }

      _clearer(id);
    };
  };

  var _timeouts = 'TimerMixin_timeouts';

  var _clearTimeout = clearer(GLOBAL.clearTimeout, _timeouts);

  var _setTimeout = setter(GLOBAL.setTimeout, _clearTimeout, _timeouts);

  var _intervals = 'TimerMixin_intervals';

  var _clearInterval = clearer(GLOBAL.clearInterval, _intervals);

  var _setInterval = setter(GLOBAL.setInterval, function () {}, _intervals);

  var _immediates = 'TimerMixin_immediates';

  var _clearImmediate = clearer(GLOBAL.clearImmediate, _immediates);

  var _setImmediate = setter(GLOBAL.setImmediate, _clearImmediate, _immediates);

  var _rafs = 'TimerMixin_rafs';

  var _cancelAnimationFrame = clearer(GLOBAL.cancelAnimationFrame, _rafs);

  var _requestAnimationFrame = setter(GLOBAL.requestAnimationFrame, _cancelAnimationFrame, _rafs);

  var TimerMixin = {
    componentWillUnmount: function componentWillUnmount() {
      this[_timeouts] && this[_timeouts].forEach(function (id) {
        GLOBAL.clearTimeout(id);
      });
      this[_timeouts] = null;
      this[_intervals] && this[_intervals].forEach(function (id) {
        GLOBAL.clearInterval(id);
      });
      this[_intervals] = null;
      this[_immediates] && this[_immediates].forEach(function (id) {
        GLOBAL.clearImmediate(id);
      });
      this[_immediates] = null;
      this[_rafs] && this[_rafs].forEach(function (id) {
        GLOBAL.cancelAnimationFrame(id);
      });
      this[_rafs] = null;
    },
    setTimeout: _setTimeout,
    clearTimeout: _clearTimeout,
    setInterval: _setInterval,
    clearInterval: _clearInterval,
    setImmediate: _setImmediate,
    clearImmediate: _clearImmediate,
    requestAnimationFrame: _requestAnimationFrame,
    cancelAnimationFrame: _cancelAnimationFrame
  };
  module.exports = TimerMixin;
},382,[],"node_modules/react-timer-mixin/TimerMixin.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var EdgeInsetsPropType = _$$_REQUIRE(_dependencyMap[0], 'EdgeInsetsPropType');

  var React = _$$_REQUIRE(_dependencyMap[1], 'React');

  var PropTypes = _$$_REQUIRE(_dependencyMap[2], 'prop-types');

  var TimerMixin = _$$_REQUIRE(_dependencyMap[3], 'react-timer-mixin');

  var Touchable = _$$_REQUIRE(_dependencyMap[4], 'Touchable');

  var createReactClass = _$$_REQUIRE(_dependencyMap[5], 'create-react-class');

  var ensurePositiveDelayProps = _$$_REQUIRE(_dependencyMap[6], 'ensurePositiveDelayProps');

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

  var _require = _$$_REQUIRE(_dependencyMap[8], 'ViewAccessibility'),
      AccessibilityComponentTypes = _require.AccessibilityComponentTypes,
      AccessibilityTraits = _require.AccessibilityTraits;

  var PRESS_RETENTION_OFFSET = {
    top: 20,
    left: 20,
    right: 20,
    bottom: 30
  };
  var TouchableWithoutFeedback = createReactClass({
    displayName: 'TouchableWithoutFeedback',
    mixins: [TimerMixin, Touchable.Mixin],
    propTypes: {
      accessible: PropTypes.bool,
      accessibilityLabel: PropTypes.node,
      accessibilityComponentType: PropTypes.oneOf(AccessibilityComponentTypes),
      accessibilityTraits: PropTypes.oneOfType([PropTypes.oneOf(AccessibilityTraits), PropTypes.arrayOf(PropTypes.oneOf(AccessibilityTraits))]),
      disabled: PropTypes.bool,
      onPress: PropTypes.func,
      onPressIn: PropTypes.func,
      onPressOut: PropTypes.func,
      onLayout: PropTypes.func,
      onLongPress: PropTypes.func,
      nativeID: PropTypes.string,
      testID: PropTypes.string,
      delayPressIn: PropTypes.number,
      delayPressOut: PropTypes.number,
      delayLongPress: PropTypes.number,
      pressRetentionOffset: EdgeInsetsPropType,
      hitSlop: EdgeInsetsPropType
    },
    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;
      warning(!child.type || child.type.displayName !== 'Text', 'TouchableWithoutFeedback does not work well with Text children. Wrap children in a View instead. See ' + (child._owner && child._owner.getName && child._owner.getName() || '<unknown>'));

      if (Touchable.TOUCH_TARGET_DEBUG && child.type && child.type.displayName === 'View') {
        children = React.Children.toArray(children);
        children.push(Touchable.renderDebugView({
          color: 'red',
          hitSlop: this.props.hitSlop
        }));
      }

      var style = Touchable.TOUCH_TARGET_DEBUG && child.type && child.type.displayName === 'Text' ? [child.props.style, {
        color: 'red'
      }] : child.props.style;
      return React.cloneElement(child, {
        accessible: this.props.accessible !== false,
        accessibilityLabel: this.props.accessibilityLabel,
        accessibilityComponentType: this.props.accessibilityComponentType,
        accessibilityTraits: this.props.accessibilityTraits,
        nativeID: this.props.nativeID,
        testID: this.props.testID,
        onLayout: this.props.onLayout,
        hitSlop: this.props.hitSlop,
        onStartShouldSetResponder: this.touchableHandleStartShouldSetResponder,
        onResponderTerminationRequest: this.touchableHandleResponderTerminationRequest,
        onResponderGrant: this.touchableHandleResponderGrant,
        onResponderMove: this.touchableHandleResponderMove,
        onResponderRelease: this.touchableHandleResponderRelease,
        onResponderTerminate: this.touchableHandleResponderTerminate,
        style: style,
        children: children
      });
    }
  });
  module.exports = TouchableWithoutFeedback;
},383,[254,200,212,382,257,365,384,183,379],"node_modules/react-native/Libraries/Components/Touchable/TouchableWithoutFeedback.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var invariant = _$$_REQUIRE(_dependencyMap[0], 'fbjs/lib/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;
},384,[166],"node_modules/react-native/Libraries/Components/Touchable/ensurePositiveDelayProps.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  module.exports = _$$_REQUIRE(_dependencyMap[0], 'UnimplementedView');
},385,[240],"node_modules/react-native/Libraries/Components/CheckBox/CheckBox.ios.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _default = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[0], "react")).default;

  var _reactTransformHmrLibIndexJs = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./../../../../react-transform-hmr/lib/index.js")).default;

  var _jsxFileName = "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Components/DatePicker/DatePickerIOS.ios.js";

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var _components = {
    DatePickerIOS: {
      displayName: "DatePickerIOS"
    }
  };

  var _reactTransformHmrLibIndexJs2 = _reactTransformHmrLibIndexJs({
    filename: "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Components/DatePicker/DatePickerIOS.ios.js",
    components: _components,
    locals: [module],
    imports: [_default]
  });

  function _wrapComponent(id) {
    return function (Component) {
      return _reactTransformHmrLibIndexJs2(Component, id);
    };
  }

  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

  var React = _$$_REQUIRE(_dependencyMap[2], 'React');

  var invariant = _$$_REQUIRE(_dependencyMap[3], 'fbjs/lib/invariant');

  var StyleSheet = _$$_REQUIRE(_dependencyMap[4], 'StyleSheet');

  var View = _$$_REQUIRE(_dependencyMap[5], 'View');

  var requireNativeComponent = _$$_REQUIRE(_dependencyMap[6], 'requireNativeComponent');

  var RCTDatePickerIOS = requireNativeComponent('RCTDatePicker');

  var DatePickerIOS = function (_React$Component) {
    function DatePickerIOS() {
      var _getPrototypeOf2;

      var _temp, _this;

      _classCallCheck(this, DatePickerIOS);

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

      return _possibleConstructorReturn(_this, (_temp = _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(DatePickerIOS)).call.apply(_getPrototypeOf2, [this].concat(args))), _this._picker = null, _this._onChange = function (event) {
        var nativeTimeStamp = event.nativeEvent.timestamp;
        _this.props.onDateChange && _this.props.onDateChange(new Date(nativeTimeStamp));
        _this.props.onChange && _this.props.onChange(event);
      }, _temp));
    }

    _createClass(DatePickerIOS, [{
      key: "componentDidUpdate",
      value: function componentDidUpdate() {
        if (this.props.date) {
          var propsTimeStamp = this.props.date.getTime();

          if (this._picker) {
            this._picker.setNativeProps({
              date: propsTimeStamp
            });
          }
        }
      }
    }, {
      key: "render",
      value: function render() {
        var _this2 = this;

        var props = this.props;
        invariant(props.date || props.initialDate, 'A selected date or initial date should be specified.');
        return React.createElement(View, {
          style: props.style,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 144
          }
        }, React.createElement(RCTDatePickerIOS, {
          ref: function ref(picker) {
            _this2._picker = picker;
          },
          style: styles.datePickerIOS,
          date: props.date ? props.date.getTime() : props.initialDate ? props.initialDate.getTime() : undefined,
          locale: props.locale ? props.locale : undefined,
          maximumDate: props.maximumDate ? props.maximumDate.getTime() : undefined,
          minimumDate: props.minimumDate ? props.minimumDate.getTime() : undefined,
          mode: props.mode,
          minuteInterval: props.minuteInterval,
          timeZoneOffsetInMinutes: props.timeZoneOffsetInMinutes,
          onChange: this._onChange,
          onStartShouldSetResponder: function onStartShouldSetResponder() {
            return true;
          },
          onResponderTerminationRequest: function onResponderTerminationRequest() {
            return false;
          },
          __source: {
            fileName: _jsxFileName,
            lineNumber: 145
          }
        }));
      }
    }]);

    _inherits(DatePickerIOS, _React$Component);

    return DatePickerIOS;
  }(React.Component);

  DatePickerIOS.DefaultProps = {
    mode: 'datetime'
  };
  DatePickerIOS = _wrapComponent("DatePickerIOS")(DatePickerIOS);
  var styles = StyleSheet.create({
    datePickerIOS: {
      height: 216
    }
  });
  module.exports = DatePickerIOS;
},386,[1,11,200,166,201,227,229],"node_modules/react-native/Libraries/Components/DatePicker/DatePickerIOS.ios.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  module.exports = _$$_REQUIRE(_dependencyMap[0], 'UnimplementedView');
},387,[240],"node_modules/react-native/Libraries/Components/DrawerAndroid/DrawerLayoutAndroid.ios.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _default = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[0], "react")).default;

  var _reactTransformHmrLibIndexJs = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./../../../react-transform-hmr/lib/index.js")).default;

  var _jsxFileName = "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Lists/FlatList.js";

  function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

  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 _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

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

  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 _components = {
    FlatList: {
      displayName: "FlatList"
    }
  };

  var _reactTransformHmrLibIndexJs2 = _reactTransformHmrLibIndexJs({
    filename: "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Lists/FlatList.js",
    components: _components,
    locals: [module],
    imports: [_default]
  });

  function _wrapComponent(id) {
    return function (Component) {
      return _reactTransformHmrLibIndexJs2(Component, id);
    };
  }

  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

  var MetroListView = _$$_REQUIRE(_dependencyMap[2], 'MetroListView');

  var React = _$$_REQUIRE(_dependencyMap[3], 'React');

  var View = _$$_REQUIRE(_dependencyMap[4], 'View');

  var VirtualizedList = _$$_REQUIRE(_dependencyMap[5], 'VirtualizedList');

  var ListView = _$$_REQUIRE(_dependencyMap[6], 'ListView');

  var StyleSheet = _$$_REQUIRE(_dependencyMap[7], 'StyleSheet');

  var invariant = _$$_REQUIRE(_dependencyMap[8], 'fbjs/lib/invariant');

  var defaultProps = _objectSpread({}, VirtualizedList.defaultProps, {
    numColumns: 1
  });

  var FlatList = function (_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._hasWarnedLegacy = false;
      _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._renderItem = function (info) {
        var _this$props2 = _this.props,
            renderItem = _this$props2.renderItem,
            numColumns = _this$props2.numColumns,
            columnWrapperStyle = _this$props2.columnWrapperStyle;

        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: 617
            }
          }, _item2.map(function (it, kk) {
            var element = renderItem({
              item: it,
              index: _index * numColumns + kk,
              separators: info.separators
            });
            return element && React.cloneElement(element, {
              key: kk
            });
          }));
        } else {
          return renderItem(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(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,
            legacyImplementation = props.legacyImplementation,
            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');
        }

        if (legacyImplementation) {
          invariant(numColumns === 1, 'Legacy list does not support multiple columns.');

          if (!this._hasWarnedLegacy) {
            console.warn('FlatList: Using legacyImplementation - some features not supported and performance ' + 'may suffer');
            this._hasWarnedLegacy = true;
          }
        }

        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() {
        if (this.props.legacyImplementation) {
          return React.createElement(MetroListView, _extends({}, this.props, {
            items: this.props.data,
            ref: this._captureRef,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 643
            }
          }));
        } else {
          return React.createElement(VirtualizedList, _extends({}, this.props, {
            renderItem: this._renderItem,
            getItem: this._getItem,
            getItemCount: this._getItemCount,
            keyExtractor: this._keyExtractor,
            ref: this._captureRef,
            viewabilityConfigCallbackPairs: this._virtualizedListPairs,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 654
            }
          }));
        }
      }
    }]);

    _inherits(FlatList, _React$PureComponent);

    return FlatList;
  }(React.PureComponent);

  FlatList.defaultProps = defaultProps;
  FlatList = _wrapComponent("FlatList")(FlatList);
  var styles = StyleSheet.create({
    row: {
      flexDirection: 'row'
    }
  });
  module.exports = FlatList;
},388,[1,11,389,200,227,397,390,201,166],"node_modules/react-native/Libraries/Lists/FlatList.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _default = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[0], "react")).default;

  var _reactTransformHmrLibIndexJs = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./../../../react-transform-hmr/lib/index.js")).default;

  var _jsxFileName = "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Lists/MetroListView.js";

  function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var _components = {
    MetroListView: {
      displayName: "MetroListView"
    }
  };

  var _reactTransformHmrLibIndexJs2 = _reactTransformHmrLibIndexJs({
    filename: "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Lists/MetroListView.js",
    components: _components,
    locals: [module],
    imports: [_default]
  });

  function _wrapComponent(id) {
    return function (Component) {
      return _reactTransformHmrLibIndexJs2(Component, id);
    };
  }

  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

  var ListView = _$$_REQUIRE(_dependencyMap[2], 'ListView');

  var React = _$$_REQUIRE(_dependencyMap[3], 'React');

  var RefreshControl = _$$_REQUIRE(_dependencyMap[4], 'RefreshControl');

  var ScrollView = _$$_REQUIRE(_dependencyMap[5], 'ScrollView');

  var invariant = _$$_REQUIRE(_dependencyMap[6], 'fbjs/lib/invariant');

  var MetroListView = function (_React$Component) {
    function MetroListView() {
      var _getPrototypeOf2,
          _this2 = this;

      var _temp, _this;

      _classCallCheck(this, MetroListView);

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

      return _possibleConstructorReturn(_this, (_temp = _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(MetroListView)).call.apply(_getPrototypeOf2, [this].concat(args))), _this.state = _this._computeState(_this.props, {
        ds: new ListView.DataSource({
          rowHasChanged: function rowHasChanged(itemA, itemB) {
            return true;
          },
          sectionHeaderHasChanged: function sectionHeaderHasChanged() {
            return true;
          },
          getSectionHeaderData: function getSectionHeaderData(dataBlob, sectionID) {
            return _this.state.sectionHeaderData[sectionID];
          }
        }),
        sectionHeaderData: {}
      }), _this._captureRef = function (ref) {
        _this._listRef = ref;
      }, _this._renderFooter = function () {
        return React.createElement(_this2.props.FooterComponent, {
          key: "$footer",
          __source: {
            fileName: _jsxFileName,
            lineNumber: 183
          }
        });
      }, _this._renderRow = function (item, sectionID, rowID, highlightRow) {
        return _this.props.renderItem({
          item: item,
          index: rowID
        });
      }, _this._renderSectionHeader = function (section, sectionID) {
        var renderSectionHeader = _this.props.renderSectionHeader;
        invariant(renderSectionHeader, 'Must provide renderSectionHeader with sections prop');
        return renderSectionHeader({
          section: section
        });
      }, _this._renderSeparator = function (sID, rID) {
        return React.createElement(_this2.props.SeparatorComponent, {
          key: sID + rID,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 199
          }
        });
      }, _temp));
    }

    _createClass(MetroListView, [{
      key: "scrollToEnd",
      value: function scrollToEnd(params) {
        throw new Error('scrollToEnd not supported in legacy ListView.');
      }
    }, {
      key: "scrollToIndex",
      value: function scrollToIndex(params) {
        throw new Error('scrollToIndex not supported in legacy ListView.');
      }
    }, {
      key: "scrollToItem",
      value: function scrollToItem(params) {
        throw new Error('scrollToItem not supported in legacy ListView.');
      }
    }, {
      key: "scrollToLocation",
      value: function scrollToLocation(params) {
        throw new Error('scrollToLocation not supported in legacy ListView.');
      }
    }, {
      key: "scrollToOffset",
      value: function scrollToOffset(params) {
        var animated = params.animated,
            offset = params.offset;

        this._listRef.scrollTo(this.props.horizontal ? {
          x: offset,
          animated: animated
        } : {
          y: offset,
          animated: animated
        });
      }
    }, {
      key: "getListRef",
      value: function getListRef() {
        return this._listRef;
      }
    }, {
      key: "setNativeProps",
      value: function setNativeProps(props) {
        if (this._listRef) {
          this._listRef.setNativeProps(props);
        }
      }
    }, {
      key: "UNSAFE_componentWillReceiveProps",
      value: function UNSAFE_componentWillReceiveProps(newProps) {
        var _this3 = this;

        this.setState(function (state) {
          return _this3._computeState(newProps, state);
        });
      }
    }, {
      key: "render",
      value: function render() {
        return React.createElement(ListView, _extends({}, this.props, {
          dataSource: this.state.ds,
          ref: this._captureRef,
          renderRow: this._renderRow,
          renderFooter: this.props.FooterComponent && this._renderFooter,
          renderSectionHeader: this.props.sections && this._renderSectionHeader,
          renderSeparator: this.props.SeparatorComponent && this._renderSeparator,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 142
          }
        }));
      }
    }, {
      key: "_computeState",
      value: function _computeState(props, state) {
        var sectionHeaderData = {};

        if (props.sections) {
          invariant(!props.items, 'Cannot have both sections and items props.');
          var _sections = {};
          props.sections.forEach(function (sectionIn, ii) {
            var sectionID = 's' + ii;
            _sections[sectionID] = sectionIn.data;
            sectionHeaderData[sectionID] = sectionIn;
          });
          return {
            ds: state.ds.cloneWithRowsAndSections(_sections),
            sectionHeaderData: sectionHeaderData
          };
        } else {
          invariant(!props.sections, 'Cannot have both sections and items props.');
          return {
            ds: state.ds.cloneWithRows(props.items),
            sectionHeaderData: sectionHeaderData
          };
        }
      }
    }]);

    _inherits(MetroListView, _React$Component);

    return MetroListView;
  }(React.Component);

  MetroListView.defaultProps = {
    keyExtractor: function keyExtractor(item, index) {
      return item.key || String(index);
    },
    renderScrollComponent: function renderScrollComponent(props) {
      if (props.onRefresh) {
        return React.createElement(ScrollView, _extends({}, props, {
          refreshControl: React.createElement(RefreshControl, {
            refreshing: props.refreshing,
            onRefresh: props.onRefresh,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 114
            }
          }),
          __source: {
            fileName: _jsxFileName,
            lineNumber: 107
          }
        }));
      } else {
        return React.createElement(ScrollView, _extends({}, props, {
          __source: {
            fileName: _jsxFileName,
            lineNumber: 123
          }
        }));
      }
    }
  };
  MetroListView = _wrapComponent("MetroListView")(MetroListView);
  module.exports = MetroListView;
},389,[1,11,390,200,396,367,166],"node_modules/react-native/Libraries/Lists/MetroListView.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _jsxFileName = "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Lists/ListView/ListView.js";

  function _objectWithoutProperties(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]; } 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; }

  function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

  function _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 InternalListViewType = _$$_REQUIRE(_dependencyMap[0], 'InternalListViewType');

  var ListViewDataSource = _$$_REQUIRE(_dependencyMap[1], 'ListViewDataSource');

  var Platform = _$$_REQUIRE(_dependencyMap[2], 'Platform');

  var React = _$$_REQUIRE(_dependencyMap[3], 'React');

  var PropTypes = _$$_REQUIRE(_dependencyMap[4], 'prop-types');

  var ReactNative = _$$_REQUIRE(_dependencyMap[5], 'ReactNative');

  var RCTScrollViewManager = _$$_REQUIRE(_dependencyMap[6], 'NativeModules').ScrollViewManager;

  var ScrollView = _$$_REQUIRE(_dependencyMap[7], 'ScrollView');

  var ScrollResponder = _$$_REQUIRE(_dependencyMap[8], 'ScrollResponder');

  var StaticRenderer = _$$_REQUIRE(_dependencyMap[9], 'StaticRenderer');

  var TimerMixin = _$$_REQUIRE(_dependencyMap[10], 'react-timer-mixin');

  var View = _$$_REQUIRE(_dependencyMap[11], 'View');

  var cloneReferencedElement = _$$_REQUIRE(_dependencyMap[12], 'react-clone-referenced-element');

  var createReactClass = _$$_REQUIRE(_dependencyMap[13], 'create-react-class');

  var isEmpty = _$$_REQUIRE(_dependencyMap[14], 'isEmpty');

  var merge = _$$_REQUIRE(_dependencyMap[15], 'merge');

  var DEFAULT_PAGE_SIZE = 1;
  var DEFAULT_INITIAL_ROWS = 10;
  var DEFAULT_SCROLL_RENDER_AHEAD = 1000;
  var DEFAULT_END_REACHED_THRESHOLD = 1000;
  var DEFAULT_SCROLL_CALLBACK_THROTTLE = 50;
  var ListView = createReactClass({
    displayName: 'ListView',
    _childFrames: [],
    _sentEndForContentLength: null,
    _scrollComponent: null,
    _prevRenderedRowsCount: 0,
    _visibleRows: {},
    scrollProperties: {},
    mixins: [ScrollResponder.Mixin, TimerMixin],
    statics: {
      DataSource: ListViewDataSource
    },
    propTypes: _objectSpread({}, ScrollView.propTypes, {
      dataSource: PropTypes.instanceOf(ListViewDataSource).isRequired,
      renderSeparator: PropTypes.func,
      renderRow: PropTypes.func.isRequired,
      initialListSize: PropTypes.number.isRequired,
      onEndReached: PropTypes.func,
      onEndReachedThreshold: PropTypes.number.isRequired,
      pageSize: PropTypes.number.isRequired,
      renderFooter: PropTypes.func,
      renderHeader: PropTypes.func,
      renderSectionHeader: PropTypes.func,
      renderScrollComponent: PropTypes.func.isRequired,
      scrollRenderAheadDistance: PropTypes.number.isRequired,
      onChangeVisibleRows: PropTypes.func,
      removeClippedSubviews: PropTypes.bool,
      stickySectionHeadersEnabled: PropTypes.bool,
      stickyHeaderIndices: PropTypes.arrayOf(PropTypes.number).isRequired,
      enableEmptySections: PropTypes.bool
    }),
    getMetrics: function getMetrics() {
      return {
        contentLength: this.scrollProperties.contentLength,
        totalRows: this.props.enableEmptySections ? this.props.dataSource.getRowAndSectionCount() : this.props.dataSource.getRowCount(),
        renderedRows: this.state.curRenderedRowsCount,
        visibleRows: Object.keys(this._visibleRows).length
      };
    },
    getScrollResponder: function getScrollResponder() {
      if (this._scrollComponent && this._scrollComponent.getScrollResponder) {
        return this._scrollComponent.getScrollResponder();
      }
    },
    getScrollableNode: function getScrollableNode() {
      if (this._scrollComponent && this._scrollComponent.getScrollableNode) {
        return this._scrollComponent.getScrollableNode();
      } else {
        return ReactNative.findNodeHandle(this._scrollComponent);
      }
    },
    scrollTo: function scrollTo() {
      if (this._scrollComponent && this._scrollComponent.scrollTo) {
        var _this$_scrollComponen;

        (_this$_scrollComponen = this._scrollComponent).scrollTo.apply(_this$_scrollComponen, arguments);
      }
    },
    scrollToEnd: function scrollToEnd(options) {
      if (this._scrollComponent) {
        if (this._scrollComponent.scrollToEnd) {
          this._scrollComponent.scrollToEnd(options);
        } else {
          console.warn('The scroll component used by the ListView does not support ' + 'scrollToEnd. Check the renderScrollComponent prop of your ListView.');
        }
      }
    },
    flashScrollIndicators: function flashScrollIndicators() {
      if (this._scrollComponent && this._scrollComponent.flashScrollIndicators) {
        this._scrollComponent.flashScrollIndicators();
      }
    },
    setNativeProps: function setNativeProps(props) {
      if (this._scrollComponent) {
        this._scrollComponent.setNativeProps(props);
      }
    },
    getDefaultProps: function getDefaultProps() {
      return {
        initialListSize: DEFAULT_INITIAL_ROWS,
        pageSize: DEFAULT_PAGE_SIZE,
        renderScrollComponent: function renderScrollComponent(props) {
          return React.createElement(ScrollView, _extends({}, props, {
            __source: {
              fileName: _jsxFileName,
              lineNumber: 353
            }
          }));
        },
        scrollRenderAheadDistance: DEFAULT_SCROLL_RENDER_AHEAD,
        onEndReachedThreshold: DEFAULT_END_REACHED_THRESHOLD,
        stickySectionHeadersEnabled: Platform.OS === 'ios',
        stickyHeaderIndices: []
      };
    },
    getInitialState: function getInitialState() {
      return {
        curRenderedRowsCount: this.props.initialListSize,
        highlightedRow: {}
      };
    },
    getInnerViewNode: function getInnerViewNode() {
      return this._scrollComponent.getInnerViewNode();
    },
    UNSAFE_componentWillMount: function UNSAFE_componentWillMount() {
      this.scrollProperties = {
        visibleLength: null,
        contentLength: null,
        offset: 0
      };
      this._childFrames = [];
      this._visibleRows = {};
      this._prevRenderedRowsCount = 0;
      this._sentEndForContentLength = null;
    },
    componentDidMount: function componentDidMount() {
      var _this = this;

      this.requestAnimationFrame(function () {
        _this._measureAndUpdateScrollProps();
      });
    },
    UNSAFE_componentWillReceiveProps: function UNSAFE_componentWillReceiveProps(nextProps) {
      var _this2 = this;

      if (this.props.dataSource !== nextProps.dataSource || this.props.initialListSize !== nextProps.initialListSize) {
        this.setState(function (state, props) {
          _this2._prevRenderedRowsCount = 0;
          return {
            curRenderedRowsCount: Math.min(Math.max(state.curRenderedRowsCount, props.initialListSize), props.enableEmptySections ? props.dataSource.getRowAndSectionCount() : props.dataSource.getRowCount())
          };
        }, function () {
          return _this2._renderMoreRowsIfNeeded();
        });
      }
    },
    componentDidUpdate: function componentDidUpdate() {
      var _this3 = this;

      this.requestAnimationFrame(function () {
        _this3._measureAndUpdateScrollProps();
      });
    },
    _onRowHighlighted: function _onRowHighlighted(sectionID, rowID) {
      this.setState({
        highlightedRow: {
          sectionID: sectionID,
          rowID: rowID
        }
      });
    },
    render: function render() {
      var bodyComponents = [];
      var dataSource = this.props.dataSource;
      var allRowIDs = dataSource.rowIdentities;
      var rowCount = 0;
      var stickySectionHeaderIndices = [];
      var renderSectionHeader = this.props.renderSectionHeader;
      var header = this.props.renderHeader && this.props.renderHeader();
      var footer = this.props.renderFooter && this.props.renderFooter();
      var totalIndex = header ? 1 : 0;

      for (var sectionIdx = 0; sectionIdx < allRowIDs.length; sectionIdx++) {
        var sectionID = dataSource.sectionIdentities[sectionIdx];
        var rowIDs = allRowIDs[sectionIdx];

        if (rowIDs.length === 0) {
          if (this.props.enableEmptySections === undefined) {
            var warning = _$$_REQUIRE(_dependencyMap[16], 'fbjs/lib/warning');

            warning(false, 'In next release empty section headers will be rendered.' + " In this release you can use 'enableEmptySections' flag to render empty section headers.");
            continue;
          } else {
            var invariant = _$$_REQUIRE(_dependencyMap[17], 'fbjs/lib/invariant');

            invariant(this.props.enableEmptySections, "In next release 'enableEmptySections' flag will be deprecated, empty section headers will always be rendered." + ' If empty section headers are not desirable their indices should be excluded from sectionIDs object.' + " In this release 'enableEmptySections' may only have value 'true' to allow empty section headers rendering.");
          }
        }

        if (renderSectionHeader) {
          var element = renderSectionHeader(dataSource.getSectionHeaderData(sectionIdx), sectionID);

          if (element) {
            bodyComponents.push(React.cloneElement(element, {
              key: 's_' + sectionID
            }));

            if (this.props.stickySectionHeadersEnabled) {
              stickySectionHeaderIndices.push(totalIndex);
            }

            totalIndex++;
          }
        }

        for (var rowIdx = 0; rowIdx < rowIDs.length; rowIdx++) {
          var rowID = rowIDs[rowIdx];
          var comboID = sectionID + '_' + rowID;
          var shouldUpdateRow = rowCount >= this._prevRenderedRowsCount && dataSource.rowShouldUpdate(sectionIdx, rowIdx);
          var row = React.createElement(StaticRenderer, {
            key: 'r_' + comboID,
            shouldUpdate: !!shouldUpdateRow,
            render: this.props.renderRow.bind(null, dataSource.getRowData(sectionIdx, rowIdx), sectionID, rowID, this._onRowHighlighted),
            __source: {
              fileName: _jsxFileName,
              lineNumber: 485
            }
          });
          bodyComponents.push(row);
          totalIndex++;

          if (this.props.renderSeparator && (rowIdx !== rowIDs.length - 1 || sectionIdx === allRowIDs.length - 1)) {
            var adjacentRowHighlighted = this.state.highlightedRow.sectionID === sectionID && (this.state.highlightedRow.rowID === rowID || this.state.highlightedRow.rowID === rowIDs[rowIdx + 1]);
            var separator = this.props.renderSeparator(sectionID, rowID, adjacentRowHighlighted);

            if (separator) {
              bodyComponents.push(React.createElement(View, {
                key: 's_' + comboID,
                __source: {
                  fileName: _jsxFileName,
                  lineNumber: 514
                }
              }, separator));
              totalIndex++;
            }
          }

          if (++rowCount === this.state.curRenderedRowsCount) {
            break;
          }
        }

        if (rowCount >= this.state.curRenderedRowsCount) {
          break;
        }
      }

      var _this$props = this.props,
          renderScrollComponent = _this$props.renderScrollComponent,
          props = _objectWithoutProperties(_this$props, ["renderScrollComponent"]);

      if (!props.scrollEventThrottle) {
        props.scrollEventThrottle = DEFAULT_SCROLL_CALLBACK_THROTTLE;
      }

      if (props.removeClippedSubviews === undefined) {
        props.removeClippedSubviews = true;
      }

      _extends(props, {
        onScroll: this._onScroll,
        stickyHeaderIndices: this.props.stickyHeaderIndices.concat(stickySectionHeaderIndices),
        onKeyboardWillShow: undefined,
        onKeyboardWillHide: undefined,
        onKeyboardDidShow: undefined,
        onKeyboardDidHide: undefined
      });

      return cloneReferencedElement(renderScrollComponent(props), {
        ref: this._setScrollComponentRef,
        onContentSizeChange: this._onContentSizeChange,
        onLayout: this._onLayout,
        DEPRECATED_sendUpdatedChildFrames: typeof props.onChangeVisibleRows !== undefined
      }, header, bodyComponents, footer);
    },
    _measureAndUpdateScrollProps: function _measureAndUpdateScrollProps() {
      var scrollComponent = this.getScrollResponder();

      if (!scrollComponent || !scrollComponent.getInnerViewNode) {
        return;
      }

      RCTScrollViewManager && RCTScrollViewManager.calculateChildFrames && RCTScrollViewManager.calculateChildFrames(ReactNative.findNodeHandle(scrollComponent), this._updateVisibleRows);
    },
    _setScrollComponentRef: function _setScrollComponentRef(scrollComponent) {
      this._scrollComponent = scrollComponent;
    },
    _onContentSizeChange: function _onContentSizeChange(width, height) {
      var contentLength = !this.props.horizontal ? height : width;

      if (contentLength !== this.scrollProperties.contentLength) {
        this.scrollProperties.contentLength = contentLength;

        this._updateVisibleRows();

        this._renderMoreRowsIfNeeded();
      }

      this.props.onContentSizeChange && this.props.onContentSizeChange(width, height);
    },
    _onLayout: function _onLayout(event) {
      var _event$nativeEvent$la = event.nativeEvent.layout,
          width = _event$nativeEvent$la.width,
          height = _event$nativeEvent$la.height;
      var visibleLength = !this.props.horizontal ? height : width;

      if (visibleLength !== this.scrollProperties.visibleLength) {
        this.scrollProperties.visibleLength = visibleLength;

        this._updateVisibleRows();

        this._renderMoreRowsIfNeeded();
      }

      this.props.onLayout && this.props.onLayout(event);
    },
    _maybeCallOnEndReached: function _maybeCallOnEndReached(event) {
      if (this.props.onEndReached && this.scrollProperties.contentLength !== this._sentEndForContentLength && this._getDistanceFromEnd(this.scrollProperties) < this.props.onEndReachedThreshold && this.state.curRenderedRowsCount === (this.props.enableEmptySections ? this.props.dataSource.getRowAndSectionCount() : this.props.dataSource.getRowCount())) {
        this._sentEndForContentLength = this.scrollProperties.contentLength;
        this.props.onEndReached(event);
        return true;
      }

      return false;
    },
    _renderMoreRowsIfNeeded: function _renderMoreRowsIfNeeded() {
      if (this.scrollProperties.contentLength === null || this.scrollProperties.visibleLength === null || this.state.curRenderedRowsCount === (this.props.enableEmptySections ? this.props.dataSource.getRowAndSectionCount() : this.props.dataSource.getRowCount())) {
        this._maybeCallOnEndReached();

        return;
      }

      var distanceFromEnd = this._getDistanceFromEnd(this.scrollProperties);

      if (distanceFromEnd < this.props.scrollRenderAheadDistance) {
        this._pageInNewRows();
      }
    },
    _pageInNewRows: function _pageInNewRows() {
      var _this4 = this;

      this.setState(function (state, props) {
        var rowsToRender = Math.min(state.curRenderedRowsCount + props.pageSize, props.enableEmptySections ? props.dataSource.getRowAndSectionCount() : props.dataSource.getRowCount());
        _this4._prevRenderedRowsCount = state.curRenderedRowsCount;
        return {
          curRenderedRowsCount: rowsToRender
        };
      }, function () {
        _this4._measureAndUpdateScrollProps();

        _this4._prevRenderedRowsCount = _this4.state.curRenderedRowsCount;
      });
    },
    _getDistanceFromEnd: function _getDistanceFromEnd(scrollProperties) {
      return scrollProperties.contentLength - scrollProperties.visibleLength - scrollProperties.offset;
    },
    _updateVisibleRows: function _updateVisibleRows(updatedFrames) {
      var _this5 = this;

      if (!this.props.onChangeVisibleRows) {
        return;
      }

      if (updatedFrames) {
        updatedFrames.forEach(function (newFrame) {
          _this5._childFrames[newFrame.index] = merge(newFrame);
        });
      }

      var isVertical = !this.props.horizontal;
      var dataSource = this.props.dataSource;
      var visibleMin = this.scrollProperties.offset;
      var visibleMax = visibleMin + this.scrollProperties.visibleLength;
      var allRowIDs = dataSource.rowIdentities;
      var header = this.props.renderHeader && this.props.renderHeader();
      var totalIndex = header ? 1 : 0;
      var visibilityChanged = false;
      var changedRows = {};

      for (var sectionIdx = 0; sectionIdx < allRowIDs.length; sectionIdx++) {
        var rowIDs = allRowIDs[sectionIdx];

        if (rowIDs.length === 0) {
          continue;
        }

        var sectionID = dataSource.sectionIdentities[sectionIdx];

        if (this.props.renderSectionHeader) {
          totalIndex++;
        }

        var visibleSection = this._visibleRows[sectionID];

        if (!visibleSection) {
          visibleSection = {};
        }

        for (var rowIdx = 0; rowIdx < rowIDs.length; rowIdx++) {
          var rowID = rowIDs[rowIdx];
          var frame = this._childFrames[totalIndex];
          totalIndex++;

          if (this.props.renderSeparator && (rowIdx !== rowIDs.length - 1 || sectionIdx === allRowIDs.length - 1)) {
            totalIndex++;
          }

          if (!frame) {
            break;
          }

          var rowVisible = visibleSection[rowID];
          var min = isVertical ? frame.y : frame.x;
          var max = min + (isVertical ? frame.height : frame.width);

          if (!min && !max || min === max) {
            break;
          }

          if (min > visibleMax || max < visibleMin) {
            if (rowVisible) {
              visibilityChanged = true;
              delete visibleSection[rowID];

              if (!changedRows[sectionID]) {
                changedRows[sectionID] = {};
              }

              changedRows[sectionID][rowID] = false;
            }
          } else if (!rowVisible) {
            visibilityChanged = true;
            visibleSection[rowID] = true;

            if (!changedRows[sectionID]) {
              changedRows[sectionID] = {};
            }

            changedRows[sectionID][rowID] = true;
          }
        }

        if (!isEmpty(visibleSection)) {
          this._visibleRows[sectionID] = visibleSection;
        } else if (this._visibleRows[sectionID]) {
          delete this._visibleRows[sectionID];
        }
      }

      visibilityChanged && this.props.onChangeVisibleRows(this._visibleRows, changedRows);
    },
    _onScroll: function _onScroll(e) {
      var isVertical = !this.props.horizontal;
      this.scrollProperties.visibleLength = e.nativeEvent.layoutMeasurement[isVertical ? 'height' : 'width'];
      this.scrollProperties.contentLength = e.nativeEvent.contentSize[isVertical ? 'height' : 'width'];
      this.scrollProperties.offset = e.nativeEvent.contentOffset[isVertical ? 'y' : 'x'];

      this._updateVisibleRows(e.nativeEvent.updatedChildFrames);

      if (!this._maybeCallOnEndReached(e)) {
        this._renderMoreRowsIfNeeded();
      }

      if (this.props.onEndReached && this._getDistanceFromEnd(this.scrollProperties) > this.props.onEndReachedThreshold) {
        this._sentEndForContentLength = null;
      }

      this.props.onScroll && this.props.onScroll(e);
    }
  });
  module.exports = ListView;
},390,[391,392,176,200,212,261,168,367,369,394,382,227,395,365,393,248,183,166],"node_modules/react-native/Libraries/Lists/ListView/ListView.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var React = _$$_REQUIRE(_dependencyMap[0], 'React');

  var ListViewDataSource = _$$_REQUIRE(_dependencyMap[1], 'ListViewDataSource');

  var InternalListViewType = function (_React$Component) {
    "use strict";

    function InternalListViewType() {
      _classCallCheck(this, InternalListViewType);

      return _possibleConstructorReturn(this, _getPrototypeOf(InternalListViewType).apply(this, arguments));
    }

    _createClass(InternalListViewType, [{
      key: "setNativeProps",
      value: function setNativeProps(props) {}
    }, {
      key: "flashScrollIndicators",
      value: function flashScrollIndicators() {}
    }, {
      key: "getScrollResponder",
      value: function getScrollResponder() {}
    }, {
      key: "getScrollableNode",
      value: function getScrollableNode() {}
    }, {
      key: "getMetrics",
      value: function getMetrics() {}
    }, {
      key: "scrollTo",
      value: function scrollTo() {}
    }, {
      key: "scrollToEnd",
      value: function scrollToEnd(options) {}
    }]);

    _inherits(InternalListViewType, _React$Component);

    return InternalListViewType;
  }(React.Component);

  InternalListViewType.DataSource = ListViewDataSource;
  module.exports = InternalListViewType;
},391,[200,392],"node_modules/react-native/Libraries/Lists/ListView/InternalListViewType.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }

  function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); }

  function _iterableToArray(iter) { if ((typeof Symbol === "function" ? Symbol.iterator : "@@iterator") in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); }

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

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

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

  var isEmpty = _$$_REQUIRE(_dependencyMap[1], 'isEmpty');

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

  function defaultGetRowData(dataBlob, sectionID, rowID) {
    return dataBlob[sectionID][rowID];
  }

  function defaultGetSectionHeaderData(dataBlob, sectionID) {
    return dataBlob[sectionID];
  }

  var ListViewDataSource = function () {
    function ListViewDataSource(params) {
      _classCallCheck(this, ListViewDataSource);

      invariant(params && typeof params.rowHasChanged === 'function', 'Must provide a rowHasChanged function.');
      this._rowHasChanged = params.rowHasChanged;
      this._getRowData = params.getRowData || defaultGetRowData;
      this._sectionHeaderHasChanged = params.sectionHeaderHasChanged;
      this._getSectionHeaderData = params.getSectionHeaderData || defaultGetSectionHeaderData;
      this._dataBlob = null;
      this._dirtyRows = [];
      this._dirtySections = [];
      this._cachedRowCount = 0;
      this.rowIdentities = [];
      this.sectionIdentities = [];
    }

    _createClass(ListViewDataSource, [{
      key: "cloneWithRows",
      value: function cloneWithRows(dataBlob, rowIdentities) {
        var rowIds = rowIdentities ? [_toConsumableArray(rowIdentities)] : null;

        if (!this._sectionHeaderHasChanged) {
          this._sectionHeaderHasChanged = function () {
            return false;
          };
        }

        return this.cloneWithRowsAndSections({
          s1: dataBlob
        }, ['s1'], rowIds);
      }
    }, {
      key: "cloneWithRowsAndSections",
      value: function cloneWithRowsAndSections(dataBlob, sectionIdentities, rowIdentities) {
        invariant(typeof this._sectionHeaderHasChanged === 'function', 'Must provide a sectionHeaderHasChanged function with section data.');
        invariant(!sectionIdentities || !rowIdentities || sectionIdentities.length === rowIdentities.length, 'row and section ids lengths must be the same');
        var newSource = new ListViewDataSource({
          getRowData: this._getRowData,
          getSectionHeaderData: this._getSectionHeaderData,
          rowHasChanged: this._rowHasChanged,
          sectionHeaderHasChanged: this._sectionHeaderHasChanged
        });
        newSource._dataBlob = dataBlob;

        if (sectionIdentities) {
          newSource.sectionIdentities = sectionIdentities;
        } else {
          newSource.sectionIdentities = Object.keys(dataBlob);
        }

        if (rowIdentities) {
          newSource.rowIdentities = rowIdentities;
        } else {
          newSource.rowIdentities = [];
          newSource.sectionIdentities.forEach(function (sectionID) {
            newSource.rowIdentities.push(Object.keys(dataBlob[sectionID]));
          });
        }

        newSource._cachedRowCount = countRows(newSource.rowIdentities);

        newSource._calculateDirtyArrays(this._dataBlob, this.sectionIdentities, this.rowIdentities);

        return newSource;
      }
    }, {
      key: "getRowCount",
      value: function getRowCount() {
        return this._cachedRowCount;
      }
    }, {
      key: "getRowAndSectionCount",
      value: function getRowAndSectionCount() {
        return this._cachedRowCount + this.sectionIdentities.length;
      }
    }, {
      key: "rowShouldUpdate",
      value: function rowShouldUpdate(sectionIndex, rowIndex) {
        var needsUpdate = this._dirtyRows[sectionIndex][rowIndex];
        warning(needsUpdate !== undefined, 'missing dirtyBit for section, row: ' + sectionIndex + ', ' + rowIndex);
        return needsUpdate;
      }
    }, {
      key: "getRowData",
      value: function getRowData(sectionIndex, rowIndex) {
        var sectionID = this.sectionIdentities[sectionIndex];
        var rowID = this.rowIdentities[sectionIndex][rowIndex];
        warning(sectionID !== undefined && rowID !== undefined, 'rendering invalid section, row: ' + sectionIndex + ', ' + rowIndex);
        return this._getRowData(this._dataBlob, sectionID, rowID);
      }
    }, {
      key: "getRowIDForFlatIndex",
      value: function getRowIDForFlatIndex(index) {
        var accessIndex = index;

        for (var ii = 0; ii < this.sectionIdentities.length; ii++) {
          if (accessIndex >= this.rowIdentities[ii].length) {
            accessIndex -= this.rowIdentities[ii].length;
          } else {
            return this.rowIdentities[ii][accessIndex];
          }
        }

        return null;
      }
    }, {
      key: "getSectionIDForFlatIndex",
      value: function getSectionIDForFlatIndex(index) {
        var accessIndex = index;

        for (var ii = 0; ii < this.sectionIdentities.length; ii++) {
          if (accessIndex >= this.rowIdentities[ii].length) {
            accessIndex -= this.rowIdentities[ii].length;
          } else {
            return this.sectionIdentities[ii];
          }
        }

        return null;
      }
    }, {
      key: "getSectionLengths",
      value: function getSectionLengths() {
        var results = [];

        for (var ii = 0; ii < this.sectionIdentities.length; ii++) {
          results.push(this.rowIdentities[ii].length);
        }

        return results;
      }
    }, {
      key: "sectionHeaderShouldUpdate",
      value: function sectionHeaderShouldUpdate(sectionIndex) {
        var needsUpdate = this._dirtySections[sectionIndex];
        warning(needsUpdate !== undefined, 'missing dirtyBit for section: ' + sectionIndex);
        return needsUpdate;
      }
    }, {
      key: "getSectionHeaderData",
      value: function getSectionHeaderData(sectionIndex) {
        if (!this._getSectionHeaderData) {
          return null;
        }

        var sectionID = this.sectionIdentities[sectionIndex];
        warning(sectionID !== undefined, 'renderSection called on invalid section: ' + sectionIndex);
        return this._getSectionHeaderData(this._dataBlob, sectionID);
      }
    }, {
      key: "_calculateDirtyArrays",
      value: function _calculateDirtyArrays(prevDataBlob, prevSectionIDs, prevRowIDs) {
        var prevSectionsHash = keyedDictionaryFromArray(prevSectionIDs);
        var prevRowsHash = {};

        for (var ii = 0; ii < prevRowIDs.length; ii++) {
          var sectionID = prevSectionIDs[ii];
          warning(!prevRowsHash[sectionID], 'SectionID appears more than once: ' + sectionID);
          prevRowsHash[sectionID] = keyedDictionaryFromArray(prevRowIDs[ii]);
        }

        this._dirtySections = [];
        this._dirtyRows = [];
        var dirty;

        for (var sIndex = 0; sIndex < this.sectionIdentities.length; sIndex++) {
          var sectionID = this.sectionIdentities[sIndex];
          dirty = !prevSectionsHash[sectionID];
          var _sectionHeaderHasChanged = this._sectionHeaderHasChanged;

          if (!dirty && _sectionHeaderHasChanged) {
            dirty = _sectionHeaderHasChanged(this._getSectionHeaderData(prevDataBlob, sectionID), this._getSectionHeaderData(this._dataBlob, sectionID));
          }

          this._dirtySections.push(!!dirty);

          this._dirtyRows[sIndex] = [];

          for (var rIndex = 0; rIndex < this.rowIdentities[sIndex].length; rIndex++) {
            var rowID = this.rowIdentities[sIndex][rIndex];
            dirty = !prevSectionsHash[sectionID] || !prevRowsHash[sectionID][rowID] || this._rowHasChanged(this._getRowData(prevDataBlob, sectionID, rowID), this._getRowData(this._dataBlob, sectionID, rowID));

            this._dirtyRows[sIndex].push(!!dirty);
          }
        }
      }
    }]);

    return ListViewDataSource;
  }();

  function countRows(allRowIDs) {
    var totalRows = 0;

    for (var sectionIdx = 0; sectionIdx < allRowIDs.length; sectionIdx++) {
      var rowIDs = allRowIDs[sectionIdx];
      totalRows += rowIDs.length;
    }

    return totalRows;
  }

  function keyedDictionaryFromArray(arr) {
    if (isEmpty(arr)) {
      return {};
    }

    var result = {};

    for (var ii = 0; ii < arr.length; ii++) {
      var _key = arr[ii];
      warning(!result[_key], 'Value appears more than once in array: ' + _key);
      result[_key] = true;
    }

    return result;
  }

  module.exports = ListViewDataSource;
},392,[166,393,183],"node_modules/react-native/Libraries/Lists/ListView/ListViewDataSource.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function isEmpty(obj) {
    if (Array.isArray(obj)) {
      return obj.length === 0;
    } else if (typeof obj === 'object') {
      for (var i in obj) {
        return false;
      }

      return true;
    } else {
      return !obj;
    }
  }

  module.exports = isEmpty;
},393,[],"node_modules/react-native/Libraries/vendor/core/isEmpty.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _default = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[0], "react")).default;

  var _reactTransformHmrLibIndexJs = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./../../../react-transform-hmr/lib/index.js")).default;

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var _components = {
    StaticRenderer: {
      displayName: "StaticRenderer"
    }
  };

  var _reactTransformHmrLibIndexJs2 = _reactTransformHmrLibIndexJs({
    filename: "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Components/StaticRenderer.js",
    components: _components,
    locals: [module],
    imports: [_default]
  });

  function _wrapComponent(id) {
    return function (Component) {
      return _reactTransformHmrLibIndexJs2(Component, id);
    };
  }

  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

  var React = _$$_REQUIRE(_dependencyMap[2], 'React');

  var PropTypes = _$$_REQUIRE(_dependencyMap[3], 'prop-types');

  var StaticRenderer = function (_React$Component) {
    function StaticRenderer() {
      _classCallCheck(this, StaticRenderer);

      return _possibleConstructorReturn(this, _getPrototypeOf(StaticRenderer).apply(this, arguments));
    }

    _createClass(StaticRenderer, [{
      key: "shouldComponentUpdate",
      value: function shouldComponentUpdate(nextProps) {
        return nextProps.shouldUpdate;
      }
    }, {
      key: "render",
      value: function render() {
        return this.props.render();
      }
    }]);

    _inherits(StaticRenderer, _React$Component);

    return StaticRenderer;
  }(React.Component);

  StaticRenderer.propTypes = {
    shouldUpdate: PropTypes.bool.isRequired,
    render: PropTypes.func.isRequired
  };
  StaticRenderer = _wrapComponent("StaticRenderer")(StaticRenderer);
  module.exports = StaticRenderer;
},394,[1,11,200,212],"node_modules/react-native/Libraries/Components/StaticRenderer.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  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 React = _$$_REQUIRE(_dependencyMap[0], 'react');

  function cloneReferencedElement(element, config) {
    var cloneRef = config.ref;
    var originalRef = element.ref;

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

    if (originalRef == null || cloneRef == null) {
      return React.cloneElement.apply(React, [element, config].concat(children));
    }

    if (typeof originalRef !== 'function') {
      if (__DEV__) {
        console.warn('Cloning an element with a ref that will be overwritten because it ' + 'is not a function. Use a composable callback-style ref instead. ' + 'Ignoring ref: ' + originalRef);
      }

      return React.cloneElement.apply(React, [element, config].concat(children));
    }

    return React.cloneElement.apply(React, [element, _objectSpread({}, config, {
      ref: function ref(component) {
        cloneRef(component);
        originalRef(component);
      }
    })].concat(children));
  }

  module.exports = cloneReferencedElement;
},395,[1],"node_modules/react-clone-referenced-element/cloneReferencedElement.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _default = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[0], "react")).default;

  var _reactTransformHmrLibIndexJs = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./../../../../react-transform-hmr/lib/index.js")).default;

  var _jsxFileName = "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Components/RefreshControl/RefreshControl.js";

  function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var _components = {
    RefreshControl: {
      displayName: "RefreshControl"
    }
  };

  var _reactTransformHmrLibIndexJs2 = _reactTransformHmrLibIndexJs({
    filename: "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Components/RefreshControl/RefreshControl.js",
    components: _components,
    locals: [module],
    imports: [_default]
  });

  function _wrapComponent(id) {
    return function (Component) {
      return _reactTransformHmrLibIndexJs2(Component, id);
    };
  }

  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

  var Platform = _$$_REQUIRE(_dependencyMap[2], 'Platform');

  var React = _$$_REQUIRE(_dependencyMap[3], 'React');

  var _require = _$$_REQUIRE(_dependencyMap[4], 'ReactNative'),
      NativeComponent = _require.NativeComponent;

  var requireNativeComponent = _$$_REQUIRE(_dependencyMap[5], 'requireNativeComponent');

  var nullthrows = _$$_REQUIRE(_dependencyMap[6], 'fbjs/lib/nullthrows');

  if (Platform.OS === 'android') {
    var AndroidSwipeRefreshLayout = _$$_REQUIRE(_dependencyMap[7], 'UIManager').AndroidSwipeRefreshLayout;

    var RefreshLayoutConsts = AndroidSwipeRefreshLayout ? AndroidSwipeRefreshLayout.Constants : {
      SIZE: {}
    };
  } else {
    var RefreshLayoutConsts = {
      SIZE: {}
    };
  }

  var NativeRefreshControl = Platform.OS === 'ios' ? requireNativeComponent('RCTRefreshControl') : requireNativeComponent('AndroidSwipeRefreshLayout');

  var RefreshControl = function (_React$Component) {
    function RefreshControl() {
      var _getPrototypeOf2;

      var _temp, _this;

      _classCallCheck(this, RefreshControl);

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

      return _possibleConstructorReturn(_this, (_temp = _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(RefreshControl)).call.apply(_getPrototypeOf2, [this].concat(args))), _this._nativeRef = null, _this._lastNativeRefreshing = false, _this._onRefresh = function () {
        _this._lastNativeRefreshing = true;
        _this.props.onRefresh && _this.props.onRefresh();

        _this.forceUpdate();
      }, _temp));
    }

    _createClass(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) {
          nullthrows(this._nativeRef).setNativeProps({
            refreshing: this.props.refreshing
          });
          this._lastNativeRefreshing = this.props.refreshing;
        }
      }
    }, {
      key: "render",
      value: function render() {
        var _this2 = this;

        return React.createElement(NativeRefreshControl, _extends({}, this.props, {
          ref: function ref(_ref) {
            _this2._nativeRef = _ref;
          },
          onRefresh: this._onRefresh,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 167
          }
        }));
      }
    }]);

    _inherits(RefreshControl, _React$Component);

    return RefreshControl;
  }(React.Component);

  RefreshControl.SIZE = RefreshLayoutConsts.SIZE;
  RefreshControl = _wrapComponent("RefreshControl")(RefreshControl);
  module.exports = RefreshControl;
},396,[1,11,176,200,261,229,329,218],"node_modules/react-native/Libraries/Components/RefreshControl/RefreshControl.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _default = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[0], "react")).default;

  var _reactTransformHmrLibIndexJs = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./../../../react-transform-hmr/lib/index.js")).default;

  var _jsxFileName = "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Lists/VirtualizedList.js";

  function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

  function _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; }

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

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

  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }

  var _components = {
    VirtualizedList: {
      displayName: "VirtualizedList"
    },
    CellRenderer: {
      displayName: "CellRenderer"
    },
    VirtualizedCellWrapper: {
      displayName: "VirtualizedCellWrapper"
    }
  };

  var _reactTransformHmrLibIndexJs2 = _reactTransformHmrLibIndexJs({
    filename: "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Lists/VirtualizedList.js",
    components: _components,
    locals: [module],
    imports: [_default]
  });

  function _wrapComponent(id) {
    return function (Component) {
      return _reactTransformHmrLibIndexJs2(Component, id);
    };
  }

  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

  var Batchinator = _$$_REQUIRE(_dependencyMap[2], 'Batchinator');

  var FillRateHelper = _$$_REQUIRE(_dependencyMap[3], 'FillRateHelper');

  var PropTypes = _$$_REQUIRE(_dependencyMap[4], 'prop-types');

  var React = _$$_REQUIRE(_dependencyMap[5], 'React');

  var ReactNative = _$$_REQUIRE(_dependencyMap[6], 'ReactNative');

  var RefreshControl = _$$_REQUIRE(_dependencyMap[7], 'RefreshControl');

  var ScrollView = _$$_REQUIRE(_dependencyMap[8], 'ScrollView');

  var StyleSheet = _$$_REQUIRE(_dependencyMap[9], 'StyleSheet');

  var UIManager = _$$_REQUIRE(_dependencyMap[10], 'UIManager');

  var View = _$$_REQUIRE(_dependencyMap[11], 'View');

  var ViewabilityHelper = _$$_REQUIRE(_dependencyMap[12], 'ViewabilityHelper');

  var flattenStyle = _$$_REQUIRE(_dependencyMap[13], 'flattenStyle');

  var infoLog = _$$_REQUIRE(_dependencyMap[14], 'infoLog');

  var invariant = _$$_REQUIRE(_dependencyMap[15], 'fbjs/lib/invariant');

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

  var _require = _$$_REQUIRE(_dependencyMap[17], 'VirtualizeUtils'),
      computeWindowedRenderLimits = _require.computeWindowedRenderLimits;

  var _usedIndexForKey = false;
  var _keylessItemComponentName = '';

  var VirtualizedList = function (_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: " + index + " vs " + (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: "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(_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);

        invariant(!(existingChildData && existingChildData.ref !== null), '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._hasInteracted = false;
      _this._hasMore = false;
      _this._hasWarned = {};
      _this._highestMeasuredFrameIndex = 0;
      _this._headerLength = 0;
      _this._indicesToKeys = new Map();
      _this._hasDoneInitialScroll = false;
      _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: 1018
            }
          }));
        } 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: 1032
              }
            }) : props.refreshControl,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 1028
            }
          }));
        } else {
          return React.createElement(ScrollView, _extends({}, props, {
            __source: {
              fileName: _jsxFileName,
              lineNumber: 1045
            }
          }));
        }
      };

      _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 (_ref2) {
              function ref(_x) {
                return _ref2.apply(this, arguments);
              }

              ref.toString = function () {
                return _ref2.toString();
              };

              return ref;
            }(function (ref) {
              _this2._cellRefs[key] = ref;
            }),
            __source: {
              fileName: _jsxFileName,
              lineNumber: 679
            }
          }));
          prevCellKey = key;
        };

        for (var ii = first; ii <= last; ii++) {
          _loop(ii);
        }
      }
    }, {
      key: "_isVirtualizationDisabled",
      value: function _isVirtualizationDisabled() {
        return this.props.disableVirtualization;
      }
    }, {
      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: 753
            }
          });
          cells.push(React.createElement(VirtualizedCellWrapper, {
            cellKey: this._getCellKey() + '-header',
            key: "$header",
            __source: {
              fileName: _jsxFileName,
              lineNumber: 756
            }
          }, React.createElement(View, {
            onLayout: this._onLayoutHeader,
            style: inversionStyle,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 759
            }
          }, 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 + initBlock.length);
                  cells.push(React.createElement(View, {
                    key: "$sticky_lead",
                    style: _defineProperty({}, spacerKey, leadSpace),
                    __source: {
                      fileName: _jsxFileName,
                      lineNumber: 798
                    }
                  }));

                  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: 812
                    }
                  }));
                  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: 825
                }
              }));
            }
          }

          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 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: 859
              }
            }));
          }
        } else if (ListEmptyComponent) {
          var _element = React.isValidElement(ListEmptyComponent) ? ListEmptyComponent : React.createElement(ListEmptyComponent, {
            __source: {
              fileName: _jsxFileName,
              lineNumber: 869
            }
          });

          cells.push(React.cloneElement(_element, {
            key: '$empty',
            onLayout: function onLayout(event) {
              _this3._onLayoutEmpty(event);

              if (_element.props.onLayout) {
                _element.props.onLayout(event);
              }
            },
            style: [_element.props.style, inversionStyle]
          }));
        }

        if (ListFooterComponent) {
          var _element2 = React.isValidElement(ListFooterComponent) ? ListFooterComponent : React.createElement(ListFooterComponent, {
            __source: {
              fileName: _jsxFileName,
              lineNumber: 889
            }
          });

          cells.push(React.createElement(VirtualizedCellWrapper, {
            cellKey: this._getCellKey() + '-footer',
            key: "$footer",
            __source: {
              fileName: _jsxFileName,
              lineNumber: 892
            }
          }, React.createElement(View, {
            onLayout: this._onLayoutFooter,
            style: inversionStyle,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 895
            }
          }, _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 ret = React.cloneElement((this.props.renderScrollComponent || this._defaultRenderScrollComponent)(scrollProps), {
          ref: this._captureScrollRef
        }, cells);

        if (this.props.debug) {
          return React.createElement(View, {
            style: {
              flex: 1
            },
            __source: {
              fileName: _jsxFileName,
              lineNumber: 941
            }
          }, 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();
          });
        }

        this._scheduleCellsToRenderUpdate();
      }
    }, {
      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 childList = this._nestedChildLists.get(_childKey2);

            childList && childList.ref && childList.ref.measureLayoutRelativeToContainingList();
          }
        }

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

        UIManager.measureLayout(ReactNative.findNodeHandle(this), ReactNative.findNodeHandle(this.context.virtualizedList.getOutermostParentListRef()), function (error) {
          console.warn("VirtualizedList: Encountered an error while measuring a list's" + ' offset from its containing VirtualizedList.');
        }, 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;
        });
      }
    }, {
      key: "_renderDebugOverlay",
      value: function _renderDebugOverlay() {
        var normalize = this._scrollMetrics.visibleLength / this._scrollMetrics.contentLength;
        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;
        var baseStyle = {
          position: 'absolute',
          top: 0,
          right: 0
        };
        return React.createElement(View, {
          style: _objectSpread({}, baseStyle, {
            bottom: 0,
            width: 20,
            borderColor: 'blue',
            borderWidth: 1
          }),
          __source: {
            fileName: _jsxFileName,
            lineNumber: 1171
          }
        }, framesInLayout.map(function (f, ii) {
          return React.createElement(View, {
            key: 'f' + ii,
            style: _objectSpread({}, baseStyle, {
              left: 0,
              top: f.offset * normalize,
              height: f.length * normalize,
              backgroundColor: 'orange'
            }),
            __source: {
              fileName: _jsxFileName,
              lineNumber: 1180
            }
          });
        }), React.createElement(View, {
          style: _objectSpread({}, baseStyle, {
            left: 0,
            top: windowTop * normalize,
            height: windowLen * normalize,
            borderColor: 'green',
            borderWidth: 2
          }),
          __source: {
            fileName: _jsxFileName,
            lineNumber: 1191
          }
        }), React.createElement(View, {
          style: _objectSpread({}, baseStyle, {
            left: 0,
            top: visTop * normalize,
            height: visLen * normalize,
            borderColor: 'red',
            borderWidth: 2
          }),
          __source: {
            fileName: _jsxFileName,
            lineNumber: 1201
          }
        }));
      }
    }, {
      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) - this._headerLength;
      }
    }, {
      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._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,
            extraData = newProps.extraData,
            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))
        };
      }
    }]);

    _inherits(VirtualizedList, _React$PureComponent);

    return VirtualizedList;
  }(React.PureComponent);

  VirtualizedList.defaultProps = {
    disableVirtualization: false,
    horizontal: false,
    initialNumToRender: 10,
    keyExtractor: function keyExtractor(item, index) {
      if (item.key != null) {
        return item.key;
      }

      _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
    })
  };
  VirtualizedList = _wrapComponent("VirtualizedList")(VirtualizedList);

  var CellRenderer = function (_React$Component) {
    function CellRenderer() {
      var _getPrototypeOf2;

      var _temp, _this6;

      _classCallCheck(this, CellRenderer);

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

      return _possibleConstructorReturn(_this6, (_temp = _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);
        }
      }, _temp));
    }

    _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: "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;
        invariant(renderItem, 'no renderItem!');
        var element = renderItem({
          item: item,
          index: index,
          separators: this._separators
        });
        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: 1703
          }
        }));
        var cellStyle = inversionStyle ? horizontal ? [{
          flexDirection: 'row-reverse'
        }, inversionStyle] : [{
          flexDirection: 'column-reverse'
        }, inversionStyle] : horizontal ? [{
          flexDirection: 'row'
        }, inversionStyle] : inversionStyle;

        if (!CellRendererComponent) {
          return React.createElement(View, {
            style: cellStyle,
            onLayout: onLayout,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 1714
            }
          }, element, itemSeparator);
        }

        return React.createElement(CellRendererComponent, _extends({}, this.props, {
          style: cellStyle,
          onLayout: onLayout,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 1721
          }
        }), element, itemSeparator);
      }
    }]);

    _inherits(CellRenderer, _React$Component);

    return CellRenderer;
  }(React.Component);

  CellRenderer.childContextTypes = {
    virtualizedCell: PropTypes.shape({
      cellKey: PropTypes.string
    })
  };
  CellRenderer = _wrapComponent("CellRenderer")(CellRenderer);

  var VirtualizedCellWrapper = function (_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;
      }
    }]);

    _inherits(VirtualizedCellWrapper, _React$Component2);

    return VirtualizedCellWrapper;
  }(React.Component);

  VirtualizedCellWrapper.childContextTypes = {
    virtualizedCell: PropTypes.shape({
      cellKey: PropTypes.string
    })
  };
  VirtualizedCellWrapper = _wrapComponent("VirtualizedCellWrapper")(VirtualizedCellWrapper);
  var styles = StyleSheet.create({
    verticallyInverted: {
      transform: [{
        scaleY: -1
      }]
    },
    horizontallyInverted: {
      transform: [{
        scaleX: -1
      }]
    }
  });
  module.exports = VirtualizedList;
},397,[1,11,398,399,212,200,261,396,367,201,218,227,400,226,309,166,183,401],"node_modules/react-native/Libraries/Lists/VirtualizedList.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  var InteractionManager = _$$_REQUIRE(_dependencyMap[0], '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;
},398,[340],"node_modules/react-native/Libraries/Interaction/Batchinator.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

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

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

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  var warning = _$$_REQUIRE(_dependencyMap[1], '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;
},399,[177,183],"node_modules/react-native/Libraries/Lists/FillRateHelper.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

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

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

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  var invariant = _$$_REQUIRE(_dependencyMap[0], 'fbjs/lib/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;

        invariant(last < itemCount, 'Invalid render range ' + JSON.stringify({
          renderRange: renderRange,
          itemCount: itemCount
        }));

        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), _i2 = 0, _iterator = _isArray ? _iterator : _iterator[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"]();;) {
          var _ref4;

          if (_isArray) {
            if (_i2 >= _iterator.length) break;
            _ref4 = _iterator[_i2++];
          } else {
            _i2 = _iterator.next();
            if (_i2.done) break;
            _ref4 = _i2.value;
          }

          var _ref8 = _ref4;

          var _ref3 = _slicedToArray(_ref8, 2);

          var _key3 = _ref3[0];
          var _viewable2 = _ref3[1];

          if (!prevItems.has(_key3)) {
            changed.push(_viewable2);
          }
        }

        for (var _iterator2 = prevItems, _isArray2 = Array.isArray(_iterator2), _i3 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"]();;) {
          var _ref7;

          if (_isArray2) {
            if (_i3 >= _iterator2.length) break;
            _ref7 = _iterator2[_i3++];
          } else {
            _i3 = _iterator2.next();
            if (_i3.done) break;
            _ref7 = _i3.value;
          }

          var _ref9 = _ref7;

          var _ref6 = _slicedToArray(_ref9, 2);

          var _key4 = _ref6[0];
          var _viewable3 = _ref6[1];

          if (!nextItems.has(_key4)) {
            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;
},400,[166],"node_modules/react-native/Libraries/Lists/ViewabilityHelper.js");
__d(function (global, _$$_REQUIRE, 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 invariant = _$$_REQUIRE(_dependencyMap[0], 'fbjs/lib/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;
},401,[166],"node_modules/react-native/Libraries/Lists/VirtualizeUtils.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _default = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[0], "react")).default;

  var _reactTransformHmrLibIndexJs = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./../../../react-transform-hmr/lib/index.js")).default;

  var _jsxFileName = "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Image/ImageBackground.js";

  function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

  function _objectWithoutProperties(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]; } 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; }

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var _components = {
    ImageBackground: {
      displayName: "ImageBackground"
    }
  };

  var _reactTransformHmrLibIndexJs2 = _reactTransformHmrLibIndexJs({
    filename: "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Image/ImageBackground.js",
    components: _components,
    locals: [module],
    imports: [_default]
  });

  function _wrapComponent(id) {
    return function (Component) {
      return _reactTransformHmrLibIndexJs2(Component, id);
    };
  }

  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

  var Image = _$$_REQUIRE(_dependencyMap[2], 'Image');

  var React = _$$_REQUIRE(_dependencyMap[3], 'React');

  var StyleSheet = _$$_REQUIRE(_dependencyMap[4], 'StyleSheet');

  var View = _$$_REQUIRE(_dependencyMap[5], 'View');

  var ensureComponentIsNative = _$$_REQUIRE(_dependencyMap[6], 'ensureComponentIsNative');

  var ImageBackground = function (_React$Component) {
    function ImageBackground() {
      var _getPrototypeOf2;

      var _temp, _this;

      _classCallCheck(this, ImageBackground);

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

      return _possibleConstructorReturn(_this, (_temp = _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(ImageBackground)).call.apply(_getPrototypeOf2, [this].concat(args))), _this._viewRef = null, _this._captureRef = function (ref) {
        _this._viewRef = ref;
      }, _temp));
    }

    _createClass(ImageBackground, [{
      key: "setNativeProps",
      value: function setNativeProps(props) {
        var viewRef = this._viewRef;

        if (viewRef) {
          ensureComponentIsNative(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, {
          style: style,
          ref: this._captureRef,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 63
          }
        }, React.createElement(Image, _extends({}, props, {
          style: [StyleSheet.absoluteFill, {
            width: style.width,
            height: style.height
          }, imageStyle],
          ref: imageRef,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 64
          }
        })), children);
      }
    }]);

    _inherits(ImageBackground, _React$Component);

    return ImageBackground;
  }(React.Component);

  ImageBackground = _wrapComponent("ImageBackground")(ImageBackground);
  module.exports = ImageBackground;
},402,[1,11,361,200,201,227,403],"node_modules/react-native/Libraries/Image/ImageBackground.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

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

  var ensureComponentIsNative = function ensureComponentIsNative(component) {
    invariant(component && typeof component.setNativeProps === 'function', 'Touchable child must either be native or forward setNativeProps to a ' + 'native component');
  };

  module.exports = ensureComponentIsNative;
},403,[166],"node_modules/react-native/Libraries/Components/Touchable/ensureComponentIsNative.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  var RCTImageEditingManager = _$$_REQUIRE(_dependencyMap[0], 'NativeModules').ImageEditingManager;

  var ImageEditor = function () {
    function ImageEditor() {
      _classCallCheck(this, ImageEditor);
    }

    _createClass(ImageEditor, null, [{
      key: "cropImage",
      value: function cropImage(uri, cropData, success, failure) {
        RCTImageEditingManager.cropImage(uri, cropData, success, failure);
      }
    }]);

    return ImageEditor;
  }();

  module.exports = ImageEditor;
},404,[168],"node_modules/react-native/Libraries/Image/ImageEditor.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  var RCTImageStoreManager = _$$_REQUIRE(_dependencyMap[0], 'NativeModules').ImageStoreManager;

  var ImageStore = function () {
    function ImageStore() {
      _classCallCheck(this, ImageStore);
    }

    _createClass(ImageStore, null, [{
      key: "hasImageForTag",
      value: function hasImageForTag(uri, callback) {
        if (RCTImageStoreManager.hasImageForTag) {
          RCTImageStoreManager.hasImageForTag(uri, callback);
        } else {
          console.warn('hasImageForTag() not implemented');
        }
      }
    }, {
      key: "removeImageForTag",
      value: function removeImageForTag(uri) {
        if (RCTImageStoreManager.removeImageForTag) {
          RCTImageStoreManager.removeImageForTag(uri);
        } else {
          console.warn('removeImageForTag() not implemented');
        }
      }
    }, {
      key: "addImageFromBase64",
      value: function addImageFromBase64(base64ImageData, success, failure) {
        RCTImageStoreManager.addImageFromBase64(base64ImageData, success, failure);
      }
    }, {
      key: "getBase64ForTag",
      value: function getBase64ForTag(uri, success, failure) {
        RCTImageStoreManager.getBase64ForTag(uri, success, failure);
      }
    }]);

    return ImageStore;
  }();

  module.exports = ImageStore;
},405,[168],"node_modules/react-native/Libraries/Image/ImageStore.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _default = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[0], "react")).default;

  var _reactTransformHmrLibIndexJs = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./../../../../react-transform-hmr/lib/index.js")).default;

  var _jsxFileName = "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Components/TextInput/InputAccessoryView.js";

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var _components = {
    InputAccessoryView: {
      displayName: "InputAccessoryView"
    }
  };

  var _reactTransformHmrLibIndexJs2 = _reactTransformHmrLibIndexJs({
    filename: "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Components/TextInput/InputAccessoryView.js",
    components: _components,
    locals: [module],
    imports: [_default]
  });

  function _wrapComponent(id) {
    return function (Component) {
      return _reactTransformHmrLibIndexJs2(Component, id);
    };
  }

  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

  var ColorPropType = _$$_REQUIRE(_dependencyMap[2], 'ColorPropType');

  var React = _$$_REQUIRE(_dependencyMap[3], 'React');

  var StyleSheet = _$$_REQUIRE(_dependencyMap[4], 'StyleSheet');

  var ViewPropTypes = _$$_REQUIRE(_dependencyMap[5], 'ViewPropTypes');

  var requireNativeComponent = _$$_REQUIRE(_dependencyMap[6], 'requireNativeComponent');

  var RCTInputAccessoryView = requireNativeComponent('RCTInputAccessoryView');

  var InputAccessoryView = function (_React$Component) {
    function InputAccessoryView() {
      _classCallCheck(this, InputAccessoryView);

      return _possibleConstructorReturn(this, _getPrototypeOf(InputAccessoryView).apply(this, arguments));
    }

    _createClass(InputAccessoryView, [{
      key: "render",
      value: function render() {
        console.warn('<InputAccessoryView> is not supported on Android yet.');

        if (React.Children.count(this.props.children) === 0) {
          return null;
        }

        return React.createElement(RCTInputAccessoryView, {
          style: [this.props.style, styles.container],
          nativeID: this.props.nativeID,
          backgroundColor: this.props.backgroundColor,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 99
          }
        }, this.props.children);
      }
    }]);

    _inherits(InputAccessoryView, _React$Component);

    return InputAccessoryView;
  }(React.Component);

  InputAccessoryView = _wrapComponent("InputAccessoryView")(InputAccessoryView);
  var styles = StyleSheet.create({
    container: {
      position: 'absolute'
    }
  });
  module.exports = InputAccessoryView;
},406,[1,11,207,200,201,376,229],"node_modules/react-native/Libraries/Components/TextInput/InputAccessoryView.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _default = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[0], "react")).default;

  var _reactTransformHmrLibIndexJs = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./../../../../react-transform-hmr/lib/index.js")).default;

  var _jsxFileName = "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Components/Keyboard/KeyboardAvoidingView.js";

  function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

  function _objectWithoutProperties(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]; } 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; }

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var _components = {
    KeyboardAvoidingView: {
      displayName: "KeyboardAvoidingView"
    }
  };

  var _reactTransformHmrLibIndexJs2 = _reactTransformHmrLibIndexJs({
    filename: "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Components/Keyboard/KeyboardAvoidingView.js",
    components: _components,
    locals: [module],
    imports: [_default]
  });

  function _wrapComponent(id) {
    return function (Component) {
      return _reactTransformHmrLibIndexJs2(Component, id);
    };
  }

  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

  var Keyboard = _$$_REQUIRE(_dependencyMap[2], 'Keyboard');

  var LayoutAnimation = _$$_REQUIRE(_dependencyMap[3], 'LayoutAnimation');

  var Platform = _$$_REQUIRE(_dependencyMap[4], 'Platform');

  var React = _$$_REQUIRE(_dependencyMap[5], 'React');

  var StyleSheet = _$$_REQUIRE(_dependencyMap[6], 'StyleSheet');

  var View = _$$_REQUIRE(_dependencyMap[7], 'View');

  var viewRef = 'VIEW';

  var KeyboardAvoidingView = function (_React$Component) {
    function KeyboardAvoidingView() {
      var _getPrototypeOf2;

      var _temp, _this;

      _classCallCheck(this, KeyboardAvoidingView);

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

      return _possibleConstructorReturn(_this, (_temp = _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(KeyboardAvoidingView)).call.apply(_getPrototypeOf2, [this].concat(args))), _this._frame = null, _this._subscriptions = [], _this.state = {
        bottom: 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,
            update: {
              duration: duration,
              type: LayoutAnimation.Types[easing] || 'keyboard'
            }
          });
        }

        _this.setState({
          bottom: height
        });
      }, _this._onLayout = function (event) {
        _this._frame = event.nativeEvent.layout;
      }, _temp));
    }

    _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: "UNSAFE_componentWillUpdate",
      value: function UNSAFE_componentWillUpdate(nextProps, nextState) {
        if (nextState.bottom === this.state.bottom && this.props.behavior === 'height' && nextProps.behavior === 'height') {
          nextState.bottom = 0;
        }
      }
    }, {
      key: "componentDidMount",
      value: function componentDidMount() {
        if (Platform.OS === '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) {
              heightStyle = {
                height: this._frame.height - bottomHeight,
                flex: 0
              };
            }

            return React.createElement(View, _extends({
              ref: viewRef,
              style: StyleSheet.compose(style, heightStyle),
              onLayout: this._onLayout
            }, props, {
              __source: {
                fileName: _jsxFileName,
                lineNumber: 172
              }
            }), children);

          case 'position':
            return React.createElement(View, _extends({
              ref: viewRef,
              style: style,
              onLayout: this._onLayout
            }, props, {
              __source: {
                fileName: _jsxFileName,
                lineNumber: 186
              }
            }), React.createElement(View, {
              style: StyleSheet.compose(contentContainerStyle, {
                bottom: bottomHeight
              }),
              __source: {
                fileName: _jsxFileName,
                lineNumber: 191
              }
            }, children));

          case 'padding':
            return React.createElement(View, _extends({
              ref: viewRef,
              style: StyleSheet.compose(style, {
                paddingBottom: bottomHeight
              }),
              onLayout: this._onLayout
            }, props, {
              __source: {
                fileName: _jsxFileName,
                lineNumber: 205
              }
            }), children);

          default:
            return React.createElement(View, _extends({
              ref: viewRef,
              onLayout: this._onLayout,
              style: style
            }, props, {
              __source: {
                fileName: _jsxFileName,
                lineNumber: 219
              }
            }), children);
        }
      }
    }]);

    _inherits(KeyboardAvoidingView, _React$Component);

    return KeyboardAvoidingView;
  }(React.Component);

  KeyboardAvoidingView.defaultProps = {
    enabled: true,
    keyboardVerticalOffset: 0
  };
  KeyboardAvoidingView = _wrapComponent("KeyboardAvoidingView")(KeyboardAvoidingView);
  module.exports = KeyboardAvoidingView;
},407,[1,11,371,372,176,200,201,227],"node_modules/react-native/Libraries/Components/Keyboard/KeyboardAvoidingView.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  var _default = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[0], "react")).default;

  var _reactTransformHmrLibIndexJs = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./../../../../react-transform-hmr/lib/index.js")).default;

  var _jsxFileName = "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Components/MaskedView/MaskedViewIOS.ios.js";

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

  function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

  function _objectWithoutProperties(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]; } 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; }

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var _components = {
    MaskedViewIOS: {
      displayName: "MaskedViewIOS"
    }
  };

  var _reactTransformHmrLibIndexJs2 = _reactTransformHmrLibIndexJs({
    filename: "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Components/MaskedView/MaskedViewIOS.ios.js",
    components: _components,
    locals: [module],
    imports: [_default]
  });

  function _wrapComponent(id) {
    return function (Component) {
      return _reactTransformHmrLibIndexJs2(Component, id);
    };
  }

  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

  var PropTypes = _$$_REQUIRE(_dependencyMap[2], 'prop-types');

  var React = _$$_REQUIRE(_dependencyMap[3], 'React');

  var StyleSheet = _$$_REQUIRE(_dependencyMap[4], 'StyleSheet');

  var View = _$$_REQUIRE(_dependencyMap[5], 'View');

  var ViewPropTypes = _$$_REQUIRE(_dependencyMap[6], 'ViewPropTypes');

  var requireNativeComponent = _$$_REQUIRE(_dependencyMap[7], 'requireNativeComponent');

  var RCTMaskedView = requireNativeComponent('RCTMaskedView');

  var MaskedViewIOS = function (_React$Component) {
    "use strict";

    function MaskedViewIOS() {
      var _getPrototypeOf2;

      var _temp, _this;

      _classCallCheck(this, MaskedViewIOS);

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

      return _possibleConstructorReturn(_this, (_temp = _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(MaskedViewIOS)).call.apply(_getPrototypeOf2, [this].concat(args))), _this._hasWarnedInvalidRenderMask = false, _temp));
    }

    _createClass(MaskedViewIOS, [{
      key: "render",
      value: function render() {
        var _this$props = this.props,
            maskElement = _this$props.maskElement,
            children = _this$props.children,
            otherViewProps = _objectWithoutProperties(_this$props, ["maskElement", "children"]);

        if (!React.isValidElement(maskElement)) {
          if (!this._hasWarnedInvalidRenderMask) {
            console.warn('MaskedView: Invalid `maskElement` prop was passed to MaskedView. ' + 'Expected a React Element. No mask will render.');
            this._hasWarnedInvalidRenderMask = true;
          }

          return React.createElement(View, _extends({}, otherViewProps, {
            __source: {
              fileName: _jsxFileName,
              lineNumber: 88
            }
          }), children);
        }

        return React.createElement(RCTMaskedView, _extends({}, otherViewProps, {
          __source: {
            fileName: _jsxFileName,
            lineNumber: 92
          }
        }), React.createElement(View, {
          pointerEvents: "none",
          style: StyleSheet.absoluteFill,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 93
          }
        }, maskElement), children);
      }
    }]);

    _inherits(MaskedViewIOS, _React$Component);

    return MaskedViewIOS;
  }(React.Component);

  MaskedViewIOS.propTypes = _objectSpread({}, ViewPropTypes, {
    maskElement: PropTypes.element.isRequired
  });
  MaskedViewIOS = _wrapComponent("MaskedViewIOS")(MaskedViewIOS);
  module.exports = MaskedViewIOS;
},408,[1,11,212,200,201,227,376,229],"node_modules/react-native/Libraries/Components/MaskedView/MaskedViewIOS.ios.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _default = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[0], "react")).default;

  var _reactTransformHmrLibIndexJs = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./../../../react-transform-hmr/lib/index.js")).default;

  var _jsxFileName = "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Modal/Modal.js",
      _container;

  function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var _components = {
    Modal: {
      displayName: "Modal"
    }
  };

  var _reactTransformHmrLibIndexJs2 = _reactTransformHmrLibIndexJs({
    filename: "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Modal/Modal.js",
    components: _components,
    locals: [module],
    imports: [_default]
  });

  function _wrapComponent(id) {
    return function (Component) {
      return _reactTransformHmrLibIndexJs2(Component, id);
    };
  }

  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

  var AppContainer = _$$_REQUIRE(_dependencyMap[2], 'AppContainer');

  var I18nManager = _$$_REQUIRE(_dependencyMap[3], 'I18nManager');

  var NativeEventEmitter = _$$_REQUIRE(_dependencyMap[4], 'NativeEventEmitter');

  var NativeModules = _$$_REQUIRE(_dependencyMap[5], 'NativeModules');

  var Platform = _$$_REQUIRE(_dependencyMap[6], 'Platform');

  var React = _$$_REQUIRE(_dependencyMap[7], 'React');

  var PropTypes = _$$_REQUIRE(_dependencyMap[8], 'prop-types');

  var StyleSheet = _$$_REQUIRE(_dependencyMap[9], 'StyleSheet');

  var View = _$$_REQUIRE(_dependencyMap[10], 'View');

  var deprecatedPropType = _$$_REQUIRE(_dependencyMap[11], 'deprecatedPropType');

  var requireNativeComponent = _$$_REQUIRE(_dependencyMap[12], 'requireNativeComponent');

  var RCTModalHostView = requireNativeComponent('RCTModalHostView');
  var ModalEventEmitter = Platform.OS === 'ios' && NativeModules.ModalManager ? new NativeEventEmitter(NativeModules.ModalManager) : null;
  var uniqueModalIdentifier = 0;

  var Modal = function (_React$Component) {
    function Modal(props) {
      var _this;

      _classCallCheck(this, Modal);

      _this = _possibleConstructorReturn(this, _getPrototypeOf(Modal).call(this, props));

      Modal._confirmProps(props);

      _this._identifier = uniqueModalIdentifier++;
      return _this;
    }

    _createClass(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 === false) {
          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: 230
          }
        }, this.props.children) : this.props.children;
        return React.createElement(RCTModalHostView, {
          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: 238
          }
        }, React.createElement(View, {
          style: [styles.container, containerStyles],
          __source: {
            fileName: _jsxFileName,
            lineNumber: 250
          }
        }, 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.");
        }
      }
    }]);

    _inherits(Modal, _React$Component);

    return Modal;
  }(React.Component);

  Modal.propTypes = {
    animationType: PropTypes.oneOf(['none', 'slide', 'fade']),
    presentationStyle: PropTypes.oneOf(['fullScreen', 'pageSheet', 'formSheet', 'overFullScreen']),
    transparent: PropTypes.bool,
    hardwareAccelerated: PropTypes.bool,
    visible: PropTypes.bool,
    onRequestClose: Platform.isTV || Platform.OS === 'android' ? PropTypes.func.isRequired : PropTypes.func,
    onShow: PropTypes.func,
    onDismiss: PropTypes.func,
    animated: deprecatedPropType(PropTypes.bool, 'Use the `animationType` prop instead.'),
    supportedOrientations: PropTypes.arrayOf(PropTypes.oneOf(['portrait', 'portrait-upside-down', 'landscape', 'landscape-left', 'landscape-right'])),
    onOrientationChange: PropTypes.func
  };
  Modal.defaultProps = {
    visible: true,
    hardwareAccelerated: false
  };
  Modal.contextTypes = {
    rootTag: PropTypes.number
  };
  Modal.childContextTypes = {
    virtualizedList: PropTypes.object
  };
  Modal = _wrapComponent("Modal")(Modal);
  var side = I18nManager.isRTL ? 'right' : 'left';
  var styles = StyleSheet.create({
    modal: {
      position: 'absolute'
    },
    container: (_container = {
      position: 'absolute'
    }, _defineProperty(_container, side, 0), _defineProperty(_container, "top", 0), _container)
  });
  module.exports = Modal;
},409,[1,11,410,445,286,168,176,200,212,201,227,217,229],"node_modules/react-native/Libraries/Modal/Modal.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _default = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[0], "react")).default;

  var _reactTransformHmrLibIndexJs = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./../../../react-transform-hmr/lib/index.js")).default;

  var _jsxFileName = "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/ReactNative/AppContainer.js";

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var _components = {
    AppContainer: {
      displayName: "AppContainer"
    }
  };

  var _reactTransformHmrLibIndexJs2 = _reactTransformHmrLibIndexJs({
    filename: "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/ReactNative/AppContainer.js",
    components: _components,
    locals: [module],
    imports: [_default]
  });

  function _wrapComponent(id) {
    return function (Component) {
      return _reactTransformHmrLibIndexJs2(Component, id);
    };
  }

  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

  var EmitterSubscription = _$$_REQUIRE(_dependencyMap[2], 'EmitterSubscription');

  var PropTypes = _$$_REQUIRE(_dependencyMap[3], 'prop-types');

  var RCTDeviceEventEmitter = _$$_REQUIRE(_dependencyMap[4], 'RCTDeviceEventEmitter');

  var React = _$$_REQUIRE(_dependencyMap[5], 'React');

  var ReactNative = _$$_REQUIRE(_dependencyMap[6], 'ReactNative');

  var StyleSheet = _$$_REQUIRE(_dependencyMap[7], 'StyleSheet');

  var View = _$$_REQUIRE(_dependencyMap[8], 'View');

  var AppContainer = function (_React$Component) {
    function AppContainer() {
      var _getPrototypeOf2;

      var _temp, _this;

      _classCallCheck(this, AppContainer);

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

      return _possibleConstructorReturn(_this, (_temp = _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(AppContainer)).call.apply(_getPrototypeOf2, [this].concat(args))), _this.state = {
        inspector: null,
        mainKey: 1
      }, _this._subscription = null, _temp));
    }

    _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[9], '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: 62
                }
              });

              _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[10], 'YellowBox');

            yellowBox = React.createElement(YellowBox, {
              __source: {
                fileName: _jsxFileName,
                lineNumber: 93
              }
            });
          }
        }

        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: 98
          }
        }, this.props.children);
        var Wrapper = this.props.WrapperComponent;

        if (Wrapper != null) {
          innerView = React.createElement(Wrapper, {
            __source: {
              fileName: _jsxFileName,
              lineNumber: 112
            }
          }, innerView);
        }

        return React.createElement(View, {
          style: styles.appContainer,
          pointerEvents: "box-none",
          __source: {
            fileName: _jsxFileName,
            lineNumber: 115
          }
        }, innerView, yellowBox, this.state.inspector);
      }
    }]);

    _inherits(AppContainer, _React$Component);

    return AppContainer;
  }(React.Component);

  AppContainer.childContextTypes = {
    rootTag: PropTypes.number
  };
  AppContainer = _wrapComponent("AppContainer")(AppContainer);
  var styles = StyleSheet.create({
    appContainer: {
      flex: 1
    }
  });

  if (__DEV__) {
    if (!global.__RCTProfileIsProfiling) {
      var YellowBox = _$$_REQUIRE(_dependencyMap[10], 'YellowBox');

      YellowBox.install();
    }
  }

  module.exports = AppContainer;
},410,[1,11,196,212,194,200,261,201,227,411,427],"node_modules/react-native/Libraries/ReactNative/AppContainer.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _default = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[0], "react")).default;

  var _reactTransformHmrLibIndexJs = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./../../../react-transform-hmr/lib/index.js")).default;

  var _jsxFileName = "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Inspector/Inspector.js";

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var _components = {
    Inspector: {
      displayName: "Inspector"
    }
  };

  var _reactTransformHmrLibIndexJs2 = _reactTransformHmrLibIndexJs({
    filename: "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Inspector/Inspector.js",
    components: _components,
    locals: [module],
    imports: [_default]
  });

  function _wrapComponent(id) {
    return function (Component) {
      return _reactTransformHmrLibIndexJs2(Component, id);
    };
  }

  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

  var Dimensions = _$$_REQUIRE(_dependencyMap[2], 'Dimensions');

  var InspectorOverlay = _$$_REQUIRE(_dependencyMap[3], 'InspectorOverlay');

  var InspectorPanel = _$$_REQUIRE(_dependencyMap[4], 'InspectorPanel');

  var Platform = _$$_REQUIRE(_dependencyMap[5], 'Platform');

  var React = _$$_REQUIRE(_dependencyMap[6], 'React');

  var ReactNative = _$$_REQUIRE(_dependencyMap[7], 'ReactNative');

  var StyleSheet = _$$_REQUIRE(_dependencyMap[8], 'StyleSheet');

  var Touchable = _$$_REQUIRE(_dependencyMap[9], 'Touchable');

  var UIManager = _$$_REQUIRE(_dependencyMap[10], 'UIManager');

  var View = _$$_REQUIRE(_dependencyMap[11], 'View');

  var emptyObject = _$$_REQUIRE(_dependencyMap[12], 'fbjs/lib/emptyObject');

  var invariant = _$$_REQUIRE(_dependencyMap[13], 'fbjs/lib/invariant');

  var hook = window.__REACT_DEVTOOLS_GLOBAL_HOOK__;
  var renderers = findRenderers();
  hook.resolveRNStyle = _$$_REQUIRE(_dependencyMap[14], '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];
      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) {
    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 : emptyObject
              }
            });
          });
        });
        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: Platform.OS === 'ios' ? 20 : 0
        };
        return React.createElement(View, {
          style: styles.container,
          pointerEvents: "box-none",
          __source: {
            fileName: _jsxFileName,
            lineNumber: 249
          }
        }, this.state.inspecting && React.createElement(InspectorOverlay, {
          inspected: this.state.inspected,
          inspectedViewTag: this.state.inspectedViewTag,
          onTouchViewTag: this.onTouchViewTag.bind(this),
          __source: {
            fileName: _jsxFileName,
            lineNumber: 251
          }
        }), React.createElement(View, {
          style: [styles.panelContainer, panelContainerStyle],
          __source: {
            fileName: _jsxFileName,
            lineNumber: 257
          }
        }, 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: 258
          }
        })));
      }
    }]);

    _inherits(Inspector, _React$Component);

    return Inspector;
  }(React.Component);

  Inspector = _wrapComponent("Inspector")(Inspector);
  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;
},411,[1,11,203,412,416,176,200,261,201,257,218,227,323,166,226],"node_modules/react-native/Libraries/Inspector/Inspector.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _default = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[0], "react")).default;

  var _reactTransformHmrLibIndexJs = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./../../../react-transform-hmr/lib/index.js")).default;

  var _jsxFileName = "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Inspector/InspectorOverlay.js";

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var _components = {
    InspectorOverlay: {
      displayName: "InspectorOverlay"
    }
  };

  var _reactTransformHmrLibIndexJs2 = _reactTransformHmrLibIndexJs({
    filename: "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Inspector/InspectorOverlay.js",
    components: _components,
    locals: [module],
    imports: [_default]
  });

  function _wrapComponent(id) {
    return function (Component) {
      return _reactTransformHmrLibIndexJs2(Component, id);
    };
  }

  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

  var Dimensions = _$$_REQUIRE(_dependencyMap[2], 'Dimensions');

  var ElementBox = _$$_REQUIRE(_dependencyMap[3], 'ElementBox');

  var PropTypes = _$$_REQUIRE(_dependencyMap[4], 'prop-types');

  var React = _$$_REQUIRE(_dependencyMap[5], 'React');

  var StyleSheet = _$$_REQUIRE(_dependencyMap[6], 'StyleSheet');

  var UIManager = _$$_REQUIRE(_dependencyMap[7], 'UIManager');

  var View = _$$_REQUIRE(_dependencyMap[8], 'View');

  var InspectorOverlay = function (_React$Component) {
    function InspectorOverlay() {
      var _getPrototypeOf2;

      var _temp, _this;

      _classCallCheck(this, InspectorOverlay);

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

      return _possibleConstructorReturn(_this, (_temp = _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;
      }, _temp));
    }

    _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: 66
            }
          });
        }

        return React.createElement(View, {
          onStartShouldSetResponder: this.shouldSetResponser,
          onResponderMove: this.findViewForTouchEvent,
          style: [styles.inspector, {
            height: Dimensions.get('window').height
          }],
          __source: {
            fileName: _jsxFileName,
            lineNumber: 74
          }
        }, content);
      }
    }]);

    _inherits(InspectorOverlay, _React$Component);

    return InspectorOverlay;
  }(React.Component);

  InspectorOverlay.propTypes = {
    inspected: PropTypes.shape({
      frame: PropTypes.object,
      style: PropTypes.any
    }),
    inspectedViewTag: PropTypes.number,
    onTouchViewTag: PropTypes.func.isRequired
  };
  InspectorOverlay = _wrapComponent("InspectorOverlay")(InspectorOverlay);
  var styles = StyleSheet.create({
    inspector: {
      backgroundColor: 'transparent',
      position: 'absolute',
      left: 0,
      top: 0,
      right: 0
    }
  });
  module.exports = InspectorOverlay;
},412,[1,11,203,413,212,200,201,218,227],"node_modules/react-native/Libraries/Inspector/InspectorOverlay.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _default = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[0], "react")).default;

  var _reactTransformHmrLibIndexJs = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./../../../react-transform-hmr/lib/index.js")).default;

  var _jsxFileName = "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Inspector/ElementBox.js";

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var _components = {
    ElementBox: {
      displayName: "ElementBox"
    }
  };

  var _reactTransformHmrLibIndexJs2 = _reactTransformHmrLibIndexJs({
    filename: "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Inspector/ElementBox.js",
    components: _components,
    locals: [module],
    imports: [_default]
  });

  function _wrapComponent(id) {
    return function (Component) {
      return _reactTransformHmrLibIndexJs2(Component, id);
    };
  }

  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

  var React = _$$_REQUIRE(_dependencyMap[2], 'React');

  var View = _$$_REQUIRE(_dependencyMap[3], 'View');

  var StyleSheet = _$$_REQUIRE(_dependencyMap[4], 'StyleSheet');

  var BorderBox = _$$_REQUIRE(_dependencyMap[5], 'BorderBox');

  var resolveBoxStyle = _$$_REQUIRE(_dependencyMap[6], 'resolveBoxStyle');

  var flattenStyle = _$$_REQUIRE(_dependencyMap[7], 'flattenStyle');

  var ElementBox = function (_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 = this.props.frame;

        if (margin) {
          frameStyle = {
            top: frameStyle.top - margin.top,
            left: frameStyle.left - margin.left,
            height: frameStyle.height + margin.top + margin.bottom,
            width: frameStyle.width + margin.left + margin.right
          };
        }

        var contentStyle = {
          width: this.props.frame.width,
          height: this.props.frame.height
        };

        if (padding) {
          contentStyle = {
            width: contentStyle.width - padding.left - padding.right,
            height: contentStyle.height - padding.top - padding.bottom
          };
        }

        return React.createElement(View, {
          style: [styles.frame, frameStyle],
          pointerEvents: "none",
          __source: {
            fileName: _jsxFileName,
            lineNumber: 46
          }
        }, React.createElement(BorderBox, {
          box: margin,
          style: styles.margin,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 47
          }
        }, React.createElement(BorderBox, {
          box: padding,
          style: styles.padding,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 48
          }
        }, React.createElement(View, {
          style: [styles.content, contentStyle],
          __source: {
            fileName: _jsxFileName,
            lineNumber: 49
          }
        }))));
      }
    }]);

    _inherits(ElementBox, _React$Component);

    return ElementBox;
  }(React.Component);

  ElementBox = _wrapComponent("ElementBox")(ElementBox);
  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)'
    }
  });
  module.exports = ElementBox;
},413,[1,11,200,227,201,414,415,226],"node_modules/react-native/Libraries/Inspector/ElementBox.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _default = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[0], "react")).default;

  var _reactTransformHmrLibIndexJs = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./../../../react-transform-hmr/lib/index.js")).default;

  var _jsxFileName = "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Inspector/BorderBox.js";

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var _components = {
    BorderBox: {
      displayName: "BorderBox"
    }
  };

  var _reactTransformHmrLibIndexJs2 = _reactTransformHmrLibIndexJs({
    filename: "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Inspector/BorderBox.js",
    components: _components,
    locals: [module],
    imports: [_default]
  });

  function _wrapComponent(id) {
    return function (Component) {
      return _reactTransformHmrLibIndexJs2(Component, id);
    };
  }

  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

  var React = _$$_REQUIRE(_dependencyMap[2], 'React');

  var View = _$$_REQUIRE(_dependencyMap[3], 'View');

  var BorderBox = function (_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);
      }
    }]);

    _inherits(BorderBox, _React$Component);

    return BorderBox;
  }(React.Component);

  BorderBox = _wrapComponent("BorderBox")(BorderBox);
  module.exports = BorderBox;
},414,[1,11,200,227],"node_modules/react-native/Libraries/Inspector/BorderBox.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function resolveBoxStyle(prefix, style) {
    var res = {};
    var subs = ['top', 'left', 'bottom', 'right'];
    var set = false;
    subs.forEach(function (sub) {
      res[sub] = style[prefix] || 0;
    });

    if (style[prefix]) {
      set = true;
    }

    if (style[prefix + 'Vertical']) {
      res.top = res.bottom = style[prefix + 'Vertical'];
      set = true;
    }

    if (style[prefix + 'Horizontal']) {
      res.left = res.right = style[prefix + 'Horizontal'];
      set = true;
    }

    subs.forEach(function (sub) {
      var val = style[prefix + capFirst(sub)];

      if (val) {
        res[sub] = val;
        set = true;
      }
    });

    if (!set) {
      return;
    }

    return res;
  }

  function capFirst(text) {
    return text[0].toUpperCase() + text.slice(1);
  }

  module.exports = resolveBoxStyle;
},415,[],"node_modules/react-native/Libraries/Inspector/resolveBoxStyle.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _default = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[0], "react")).default;

  var _reactTransformHmrLibIndexJs = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./../../../react-transform-hmr/lib/index.js")).default;

  var _jsxFileName = "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Inspector/InspectorPanel.js";

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var _components = {
    InspectorPanel: {
      displayName: "InspectorPanel"
    },
    Button: {
      displayName: "Button"
    }
  };

  var _reactTransformHmrLibIndexJs2 = _reactTransformHmrLibIndexJs({
    filename: "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Inspector/InspectorPanel.js",
    components: _components,
    locals: [module],
    imports: [_default]
  });

  function _wrapComponent(id) {
    return function (Component) {
      return _reactTransformHmrLibIndexJs2(Component, id);
    };
  }

  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

  var ElementProperties = _$$_REQUIRE(_dependencyMap[2], 'ElementProperties');

  var NetworkOverlay = _$$_REQUIRE(_dependencyMap[3], 'NetworkOverlay');

  var PerformanceOverlay = _$$_REQUIRE(_dependencyMap[4], 'PerformanceOverlay');

  var React = _$$_REQUIRE(_dependencyMap[5], 'React');

  var PropTypes = _$$_REQUIRE(_dependencyMap[6], 'prop-types');

  var ScrollView = _$$_REQUIRE(_dependencyMap[7], 'ScrollView');

  var StyleSheet = _$$_REQUIRE(_dependencyMap[8], 'StyleSheet');

  var Text = _$$_REQUIRE(_dependencyMap[9], 'Text');

  var TouchableHighlight = _$$_REQUIRE(_dependencyMap[10], 'TouchableHighlight');

  var View = _$$_REQUIRE(_dependencyMap[11], 'View');

  var InspectorPanel = function (_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: 28
            }
          }, "Tap something to inspect it");
        }

        return React.createElement(Text, {
          style: styles.waitingText,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 31
          }
        }, "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: 38
            }
          }, 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: 39
            }
          }));
        } else if (this.props.perfing) {
          contents = React.createElement(PerformanceOverlay, {
            __source: {
              fileName: _jsxFileName,
              lineNumber: 50
            }
          });
        } else if (this.props.networking) {
          contents = React.createElement(NetworkOverlay, {
            __source: {
              fileName: _jsxFileName,
              lineNumber: 52
            }
          });
        } else {
          contents = React.createElement(View, {
            style: styles.waiting,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 54
            }
          }, this.renderWaiting());
        }

        return React.createElement(View, {
          style: styles.container,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 57
          }
        }, !this.props.devtoolsIsOpen && contents, React.createElement(View, {
          style: styles.buttonRow,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 59
          }
        }, React.createElement(Button, {
          title: 'Inspect',
          pressed: this.props.inspecting,
          onClick: this.props.setInspecting,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 60
          }
        }), React.createElement(Button, {
          title: 'Perf',
          pressed: this.props.perfing,
          onClick: this.props.setPerfing,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 65
          }
        }), React.createElement(Button, {
          title: 'Network',
          pressed: this.props.networking,
          onClick: this.props.setNetworking,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 70
          }
        }), React.createElement(Button, {
          title: 'Touchables',
          pressed: this.props.touchTargeting,
          onClick: this.props.setTouchTargeting,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 75
          }
        })));
      }
    }]);

    _inherits(InspectorPanel, _React$Component);

    return InspectorPanel;
  }(React.Component);

  InspectorPanel = _wrapComponent("InspectorPanel")(InspectorPanel);
  InspectorPanel.propTypes = {
    devtoolsIsOpen: PropTypes.bool,
    inspecting: PropTypes.bool,
    setInspecting: PropTypes.func,
    inspected: PropTypes.object,
    perfing: PropTypes.bool,
    setPerfing: PropTypes.func,
    touchTargeting: PropTypes.bool,
    setTouchTargeting: PropTypes.func,
    networking: PropTypes.bool,
    setNetworking: PropTypes.func
  };

  var Button = function (_React$Component2) {
    function Button() {
      _classCallCheck(this, Button);

      return _possibleConstructorReturn(this, _getPrototypeOf(Button).apply(this, arguments));
    }

    _createClass(Button, [{
      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: 102
          }
        }, React.createElement(Text, {
          style: styles.buttonText,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 105
          }
        }, this.props.title));
      }
    }]);

    _inherits(Button, _React$Component2);

    return Button;
  }(React.Component);

  Button = _wrapComponent("Button")(Button);
  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;
},416,[1,11,417,423,426,200,212,367,201,252,420,227],"node_modules/react-native/Libraries/Inspector/InspectorPanel.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _default = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[0], "react")).default;

  var _reactTransformHmrLibIndexJs = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./../../../react-transform-hmr/lib/index.js")).default;

  var _jsxFileName = "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Inspector/ElementProperties.js";

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var _components = {
    ElementProperties: {
      displayName: "ElementProperties"
    }
  };

  var _reactTransformHmrLibIndexJs2 = _reactTransformHmrLibIndexJs({
    filename: "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Inspector/ElementProperties.js",
    components: _components,
    locals: [module],
    imports: [_default]
  });

  function _wrapComponent(id) {
    return function (Component) {
      return _reactTransformHmrLibIndexJs2(Component, id);
    };
  }

  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

  var BoxInspector = _$$_REQUIRE(_dependencyMap[2], 'BoxInspector');

  var PropTypes = _$$_REQUIRE(_dependencyMap[3], 'prop-types');

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

  var StyleInspector = _$$_REQUIRE(_dependencyMap[5], 'StyleInspector');

  var StyleSheet = _$$_REQUIRE(_dependencyMap[6], 'StyleSheet');

  var Text = _$$_REQUIRE(_dependencyMap[7], 'Text');

  var TouchableHighlight = _$$_REQUIRE(_dependencyMap[8], 'TouchableHighlight');

  var TouchableWithoutFeedback = _$$_REQUIRE(_dependencyMap[9], 'TouchableWithoutFeedback');

  var View = _$$_REQUIRE(_dependencyMap[10], 'View');

  var flattenStyle = _$$_REQUIRE(_dependencyMap[11], 'flattenStyle');

  var mapWithSeparator = _$$_REQUIRE(_dependencyMap[12], 'mapWithSeparator');

  var openFileInEditor = _$$_REQUIRE(_dependencyMap[13], 'openFileInEditor');

  var ElementProperties = function (_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: 61
            }
          }, React.createElement(Text, {
            style: styles.openButtonTitle,
            numberOfLines: 1,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 64
            }
          }, fileNameShort, ":", lineNumber));
        }

        return React.createElement(TouchableWithoutFeedback, {
          __source: {
            fileName: _jsxFileName,
            lineNumber: 73
          }
        }, React.createElement(View, {
          style: styles.info,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 74
          }
        }, React.createElement(View, {
          style: styles.breadcrumb,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 75
          }
        }, 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: 79
            }
          }, React.createElement(Text, {
            style: styles.breadItemText,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 84
            }
          }, hierarchyItem.name));
        }, function (i) {
          return React.createElement(Text, {
            key: 'sep-' + i,
            style: styles.breadSep,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 88
            }
          }, "\u25B8");
        })), React.createElement(View, {
          style: styles.row,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 94
          }
        }, React.createElement(View, {
          style: styles.col,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 95
          }
        }, React.createElement(StyleInspector, {
          style: style,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 96
          }
        }), openFileButton), React.createElement(BoxInspector, {
          style: style,
          frame: this.props.frame,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 101
          }
        }))));
      }
    }]);

    _inherits(ElementProperties, _React$Component);

    return ElementProperties;
  }(React.Component);

  ElementProperties.propTypes = {
    hierarchy: PropTypes.array.isRequired,
    style: PropTypes.oneOfType([PropTypes.object, PropTypes.array, PropTypes.number]),
    source: PropTypes.shape({
      fileName: PropTypes.string,
      lineNumber: PropTypes.number
    })
  };
  ElementProperties = _wrapComponent("ElementProperties")(ElementProperties);
  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;
},417,[1,11,418,212,200,419,201,252,420,383,227,226,421,422],"node_modules/react-native/Libraries/Inspector/ElementProperties.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _default = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[0], "react")).default;

  var _reactTransformHmrLibIndexJs = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./../../../react-transform-hmr/lib/index.js")).default;

  var _jsxFileName = "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Inspector/BoxInspector.js";

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var _components = {
    BoxInspector: {
      displayName: "BoxInspector"
    },
    BoxContainer: {
      displayName: "BoxContainer"
    }
  };

  var _reactTransformHmrLibIndexJs2 = _reactTransformHmrLibIndexJs({
    filename: "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Inspector/BoxInspector.js",
    components: _components,
    locals: [module],
    imports: [_default]
  });

  function _wrapComponent(id) {
    return function (Component) {
      return _reactTransformHmrLibIndexJs2(Component, id);
    };
  }

  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

  var React = _$$_REQUIRE(_dependencyMap[2], 'React');

  var StyleSheet = _$$_REQUIRE(_dependencyMap[3], 'StyleSheet');

  var Text = _$$_REQUIRE(_dependencyMap[4], 'Text');

  var View = _$$_REQUIRE(_dependencyMap[5], 'View');

  var resolveBoxStyle = _$$_REQUIRE(_dependencyMap[6], 'resolveBoxStyle');

  var blank = {
    top: 0,
    left: 0,
    right: 0,
    bottom: 0
  };

  var BoxInspector = function (_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: 33
          }
        }, React.createElement(BoxContainer, {
          title: "padding",
          box: padding,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 34
          }
        }, React.createElement(View, {
          __source: {
            fileName: _jsxFileName,
            lineNumber: 35
          }
        }, React.createElement(Text, {
          style: styles.innerText,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 36
          }
        }, "(", (frame.left || 0).toFixed(1), ", ", (frame.top || 0).toFixed(1), ")"), React.createElement(Text, {
          style: styles.innerText,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 39
          }
        }, (frame.width || 0).toFixed(1), " \xD7", ' ', (frame.height || 0).toFixed(1)))));
      }
    }]);

    _inherits(BoxInspector, _React$Component);

    return BoxInspector;
  }(React.Component);

  BoxInspector = _wrapComponent("BoxInspector")(BoxInspector);

  var BoxContainer = function (_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: 54
          }
        }, React.createElement(View, {
          style: styles.row,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 55
          }
        }, React.createElement(Text, {
          style: [this.props.titleStyle, styles.label],
          __source: {
            fileName: _jsxFileName,
            lineNumber: 57
          }
        }, this.props.title), React.createElement(Text, {
          style: styles.boxText,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 60
          }
        }, box.top)), React.createElement(View, {
          style: styles.row,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 62
          }
        }, React.createElement(Text, {
          style: styles.boxText,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 63
          }
        }, box.left), this.props.children, React.createElement(Text, {
          style: styles.boxText,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 65
          }
        }, box.right)), React.createElement(Text, {
          style: styles.boxText,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 67
          }
        }, box.bottom));
      }
    }]);

    _inherits(BoxContainer, _React$Component2);

    return BoxContainer;
  }(React.Component);

  BoxContainer = _wrapComponent("BoxContainer")(BoxContainer);
  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
    },
    buffer: {
      fontSize: 10,
      color: 'yellow',
      flex: 1,
      textAlign: 'center'
    },
    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;
},418,[1,11,200,201,252,227,415],"node_modules/react-native/Libraries/Inspector/BoxInspector.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _default = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[0], "react")).default;

  var _reactTransformHmrLibIndexJs = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./../../../react-transform-hmr/lib/index.js")).default;

  var _jsxFileName = "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Inspector/StyleInspector.js";

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var _components = {
    StyleInspector: {
      displayName: "StyleInspector"
    }
  };

  var _reactTransformHmrLibIndexJs2 = _reactTransformHmrLibIndexJs({
    filename: "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Inspector/StyleInspector.js",
    components: _components,
    locals: [module],
    imports: [_default]
  });

  function _wrapComponent(id) {
    return function (Component) {
      return _reactTransformHmrLibIndexJs2(Component, id);
    };
  }

  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

  var React = _$$_REQUIRE(_dependencyMap[2], 'React');

  var StyleSheet = _$$_REQUIRE(_dependencyMap[3], 'StyleSheet');

  var Text = _$$_REQUIRE(_dependencyMap[4], 'Text');

  var View = _$$_REQUIRE(_dependencyMap[5], 'View');

  var StyleInspector = function (_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);
        })));
      }
    }]);

    _inherits(StyleInspector, _React$Component);

    return StyleInspector;
  }(React.Component);

  StyleInspector = _wrapComponent("StyleInspector")(StyleInspector);
  var styles = StyleSheet.create({
    container: {
      flexDirection: 'row'
    },
    row: {
      flexDirection: 'row',
      alignItems: 'center',
      justifyContent: 'space-around'
    },
    attr: {
      fontSize: 10,
      color: '#ccc'
    },
    value: {
      fontSize: 10,
      color: 'white',
      marginLeft: 10
    },
    noStyle: {
      color: 'white',
      fontSize: 10
    }
  });
  module.exports = StyleInspector;
},419,[1,11,200,201,252,227],"node_modules/react-native/Libraries/Inspector/StyleInspector.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _jsxFileName = "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Components/Touchable/TouchableHighlight.js";

  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 ColorPropType = _$$_REQUIRE(_dependencyMap[0], 'ColorPropType');

  var NativeMethodsMixin = _$$_REQUIRE(_dependencyMap[1], 'NativeMethodsMixin');

  var PropTypes = _$$_REQUIRE(_dependencyMap[2], 'prop-types');

  var Platform = _$$_REQUIRE(_dependencyMap[3], 'Platform');

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

  var ReactNativeViewAttributes = _$$_REQUIRE(_dependencyMap[5], 'ReactNativeViewAttributes');

  var StyleSheet = _$$_REQUIRE(_dependencyMap[6], 'StyleSheet');

  var Touchable = _$$_REQUIRE(_dependencyMap[7], 'Touchable');

  var TouchableWithoutFeedback = _$$_REQUIRE(_dependencyMap[8], 'TouchableWithoutFeedback');

  var View = _$$_REQUIRE(_dependencyMap[9], 'View');

  var ViewPropTypes = _$$_REQUIRE(_dependencyMap[10], 'ViewPropTypes');

  var createReactClass = _$$_REQUIRE(_dependencyMap[11], 'create-react-class');

  var ensurePositiveDelayProps = _$$_REQUIRE(_dependencyMap[12], '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: ColorPropType,
      style: ViewPropTypes.style,
      onShowUnderlay: PropTypes.func,
      onHideUnderlay: PropTypes.func,
      hasTVPreferredFocus: PropTypes.bool,
      tvParallaxProperties: PropTypes.object,
      testOnly_pressed: PropTypes.bool
    }),
    mixins: [NativeMethodsMixin, Touchable.Mixin],
    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);
    },
    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,
        accessibilityComponentType: this.props.accessibilityComponentType,
        accessibilityTraits: this.props.accessibilityTraits,
        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,
        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: 348
        }
      }, React.cloneElement(child, {
        style: StyleSheet.compose(child.props.style, this.state.extraChildStyle)
      }), Touchable.renderDebugView({
        color: 'green',
        hitSlop: this.props.hitSlop
      }));
    }
  });
  module.exports = TouchableHighlight;
},420,[207,364,212,176,200,247,201,257,383,227,376,365,384],"node_modules/react-native/Libraries/Components/Touchable/TouchableHighlight.js");
__d(function (global, _$$_REQUIRE, 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;
},421,[],"node_modules/react-native/Libraries/Utilities/mapWithSeparator.js");
__d(function (global, _$$_REQUIRE, 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;
},422,[273],"node_modules/react-native/Libraries/Core/Devtools/openFileInEditor.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _default = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[0], "react")).default;

  var _reactTransformHmrLibIndexJs = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./../../../react-transform-hmr/lib/index.js")).default;

  var _jsxFileName = "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Inspector/NetworkOverlay.js";

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

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

  function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }

  var _components = {
    NetworkOverlay: {
      displayName: "NetworkOverlay"
    }
  };

  var _reactTransformHmrLibIndexJs2 = _reactTransformHmrLibIndexJs({
    filename: "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Inspector/NetworkOverlay.js",
    components: _components,
    locals: [module],
    imports: [_default]
  });

  function _wrapComponent(id) {
    return function (Component) {
      return _reactTransformHmrLibIndexJs2(Component, id);
    };
  }

  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

  var ListView = _$$_REQUIRE(_dependencyMap[2], 'ListView');

  var React = _$$_REQUIRE(_dependencyMap[3], 'React');

  var ScrollView = _$$_REQUIRE(_dependencyMap[4], 'ScrollView');

  var StyleSheet = _$$_REQUIRE(_dependencyMap[5], 'StyleSheet');

  var Text = _$$_REQUIRE(_dependencyMap[6], 'Text');

  var TouchableHighlight = _$$_REQUIRE(_dependencyMap[7], 'TouchableHighlight');

  var View = _$$_REQUIRE(_dependencyMap[8], 'View');

  var WebSocketInterceptor = _$$_REQUIRE(_dependencyMap[9], 'WebSocketInterceptor');

  var XHRInterceptor = _$$_REQUIRE(_dependencyMap[10], 'XHRInterceptor');

  var LISTVIEW_CELL_HEIGHT = 15;
  var SEPARATOR_THICKNESS = 2;
  var nextXHRId = 0;

  var NetworkOverlay = function (_React$Component) {
    function NetworkOverlay(props) {
      var _this;

      _classCallCheck(this, NetworkOverlay);

      _this = _possibleConstructorReturn(this, _getPrototypeOf(NetworkOverlay).call(this, props));
      _this._requests = [];
      _this._detailViewItems = [];
      _this._listViewDataSource = new ListView.DataSource({
        rowHasChanged: function rowHasChanged(r1, r2) {
          return r1 !== r2;
        }
      });
      _this.state = {
        dataSource: _this._listViewDataSource.cloneWithRows([]),
        newDetailInfo: false,
        detailRowID: null
      };
      _this._listViewHighlighted = false;
      _this._listViewHeight = 0;
      _this._captureRequestListView = _this._captureRequestListView.bind(_assertThisInitialized(_assertThisInitialized(_this)));
      _this._captureDetailScrollView = _this._captureDetailScrollView.bind(_assertThisInitialized(_assertThisInitialized(_this)));
      _this._listViewOnLayout = _this._listViewOnLayout.bind(_assertThisInitialized(_assertThisInitialized(_this)));
      _this._renderRow = _this._renderRow.bind(_assertThisInitialized(_assertThisInitialized(_this)));
      _this._closeButtonClicked = _this._closeButtonClicked.bind(_assertThisInitialized(_assertThisInitialized(_this)));
      _this._socketIdMap = {};
      _this._xhrIdMap = {};
      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._requests.length;
          _this2._xhrIdMap[xhr._index] = xhrIndex;
          var _xhr = {
            type: 'XMLHttpRequest',
            method: method,
            url: url
          };

          _this2._requests.push(_xhr);

          _this2._detailViewItems.push([]);

          _this2._genDetailViewItem(xhrIndex);

          _this2.setState({
            dataSource: _this2._listViewDataSource.cloneWithRows(_this2._requests)
          }, _this2._scrollToBottom());
        });
        XHRInterceptor.setRequestHeaderCallback(function (header, value, xhr) {
          var xhrIndex = _this2._getRequestIndexByXHRID(xhr._index);

          if (xhrIndex === -1) {
            return;
          }

          var networkInfo = _this2._requests[xhrIndex];

          if (!networkInfo.requestHeaders) {
            networkInfo.requestHeaders = {};
          }

          networkInfo.requestHeaders[header] = value;

          _this2._genDetailViewItem(xhrIndex);
        });
        XHRInterceptor.setSendCallback(function (data, xhr) {
          var xhrIndex = _this2._getRequestIndexByXHRID(xhr._index);

          if (xhrIndex === -1) {
            return;
          }

          _this2._requests[xhrIndex].dataSent = data;

          _this2._genDetailViewItem(xhrIndex);
        });
        XHRInterceptor.setHeaderReceivedCallback(function (type, size, responseHeaders, xhr) {
          var xhrIndex = _this2._getRequestIndexByXHRID(xhr._index);

          if (xhrIndex === -1) {
            return;
          }

          var networkInfo = _this2._requests[xhrIndex];
          networkInfo.responseContentType = type;
          networkInfo.responseSize = size;
          networkInfo.responseHeaders = responseHeaders;

          _this2._genDetailViewItem(xhrIndex);
        });
        XHRInterceptor.setResponseCallback(function (status, timeout, response, responseURL, responseType, xhr) {
          var xhrIndex = _this2._getRequestIndexByXHRID(xhr._index);

          if (xhrIndex === -1) {
            return;
          }

          var networkInfo = _this2._requests[xhrIndex];
          networkInfo.status = status;
          networkInfo.timeout = timeout;
          networkInfo.response = response;
          networkInfo.responseURL = responseURL;
          networkInfo.responseType = responseType;

          _this2._genDetailViewItem(xhrIndex);
        });
        XHRInterceptor.enableInterception();
      }
    }, {
      key: "_enableWebSocketInterception",
      value: function _enableWebSocketInterception() {
        var _this3 = this;

        if (WebSocketInterceptor.isInterceptorEnabled()) {
          return;
        }

        WebSocketInterceptor.setConnectCallback(function (url, protocols, options, socketId) {
          var socketIndex = _this3._requests.length;
          _this3._socketIdMap[socketId] = socketIndex;
          var _webSocket = {
            type: 'WebSocket',
            url: url,
            protocols: protocols
          };

          _this3._requests.push(_webSocket);

          _this3._detailViewItems.push([]);

          _this3._genDetailViewItem(socketIndex);

          _this3.setState({
            dataSource: _this3._listViewDataSource.cloneWithRows(_this3._requests)
          }, _this3._scrollToBottom());
        });
        WebSocketInterceptor.setCloseCallback(function (statusCode, closeReason, socketId) {
          var socketIndex = _this3._socketIdMap[socketId];

          if (socketIndex === undefined) {
            return;
          }

          if (statusCode !== null && closeReason !== null) {
            _this3._requests[socketIndex].status = statusCode;
            _this3._requests[socketIndex].closeReason = closeReason;
          }

          _this3._genDetailViewItem(socketIndex);
        });
        WebSocketInterceptor.setSendCallback(function (data, socketId) {
          var socketIndex = _this3._socketIdMap[socketId];

          if (socketIndex === undefined) {
            return;
          }

          if (!_this3._requests[socketIndex].messages) {
            _this3._requests[socketIndex].messages = '';
          }

          _this3._requests[socketIndex].messages += 'Sent: ' + JSON.stringify(data) + '\n';

          _this3._genDetailViewItem(socketIndex);
        });
        WebSocketInterceptor.setOnMessageCallback(function (socketId, message) {
          var socketIndex = _this3._socketIdMap[socketId];

          if (socketIndex === undefined) {
            return;
          }

          if (!_this3._requests[socketIndex].messages) {
            _this3._requests[socketIndex].messages = '';
          }

          _this3._requests[socketIndex].messages += 'Received: ' + JSON.stringify(message) + '\n';

          _this3._genDetailViewItem(socketIndex);
        });
        WebSocketInterceptor.setOnCloseCallback(function (socketId, message) {
          var socketIndex = _this3._socketIdMap[socketId];

          if (socketIndex === undefined) {
            return;
          }

          _this3._requests[socketIndex].serverClose = message;

          _this3._genDetailViewItem(socketIndex);
        });
        WebSocketInterceptor.setOnErrorCallback(function (socketId, message) {
          var socketIndex = _this3._socketIdMap[socketId];

          if (socketIndex === undefined) {
            return;
          }

          _this3._requests[socketIndex].serverError = message;

          _this3._genDetailViewItem(socketIndex);
        });
        WebSocketInterceptor.enableInterception();
      }
    }, {
      key: "componentDidMount",
      value: function componentDidMount() {
        this._enableXHRInterception();

        this._enableWebSocketInterception();
      }
    }, {
      key: "componentWillUnmount",
      value: function componentWillUnmount() {
        XHRInterceptor.disableInterception();
        WebSocketInterceptor.disableInterception();
      }
    }, {
      key: "_renderRow",
      value: function _renderRow(rowData, sectionID, rowID, highlightRow) {
        var _this4 = this;

        var urlCellViewStyle = styles.urlEvenCellView;
        var methodCellViewStyle = styles.methodEvenCellView;

        if (rowID % 2 === 1) {
          urlCellViewStyle = styles.urlOddCellView;
          methodCellViewStyle = styles.methodOddCellView;
        }

        return React.createElement(TouchableHighlight, {
          onPress: function onPress() {
            _this4._pressRow(rowID);

            highlightRow(sectionID, rowID);
          },
          __source: {
            fileName: _jsxFileName,
            lineNumber: 297
          }
        }, React.createElement(View, {
          __source: {
            fileName: _jsxFileName,
            lineNumber: 302
          }
        }, React.createElement(View, {
          style: styles.tableRow,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 303
          }
        }, React.createElement(View, {
          style: urlCellViewStyle,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 304
          }
        }, React.createElement(Text, {
          style: styles.cellText,
          numberOfLines: 1,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 305
          }
        }, rowData.url)), React.createElement(View, {
          style: methodCellViewStyle,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 309
          }
        }, React.createElement(Text, {
          style: styles.cellText,
          numberOfLines: 1,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 310
          }
        }, this._getTypeShortName(rowData.type))))));
      }
    }, {
      key: "_renderSeperator",
      value: function _renderSeperator(sectionID, rowID, adjacentRowHighlighted) {
        return React.createElement(View, {
          key: sectionID + "-" + rowID,
          style: {
            height: adjacentRowHighlighted ? SEPARATOR_THICKNESS : 0,
            backgroundColor: adjacentRowHighlighted ? '#3B5998' : '#CCCCCC'
          },
          __source: {
            fileName: _jsxFileName,
            lineNumber: 326
          }
        });
      }
    }, {
      key: "_scrollToBottom",
      value: function _scrollToBottom() {
        if (this._listView) {
          var scrollResponder = this._listView.getScrollResponder();

          if (scrollResponder) {
            var scrollY = Math.max(this._requests.length * LISTVIEW_CELL_HEIGHT + (this._listViewHighlighted ? 2 * SEPARATOR_THICKNESS : 0) - this._listViewHeight, 0);
            scrollResponder.scrollResponderScrollTo({
              x: 0,
              y: scrollY,
              animated: true
            });
          }
        }
      }
    }, {
      key: "_captureRequestListView",
      value: function _captureRequestListView(listRef) {
        this._listView = listRef;
      }
    }, {
      key: "_listViewOnLayout",
      value: function _listViewOnLayout(event) {
        var height = event.nativeEvent.layout.height;
        this._listViewHeight = height;
      }
    }, {
      key: "_pressRow",
      value: function _pressRow(rowID) {
        this._listViewHighlighted = true;
        this.setState({
          detailRowID: rowID
        }, this._scrollToTop());
      }
    }, {
      key: "_scrollToTop",
      value: function _scrollToTop() {
        if (this._scrollView) {
          this._scrollView.scrollTo({
            y: 0,
            animated: false
          });
        }
      }
    }, {
      key: "_captureDetailScrollView",
      value: function _captureDetailScrollView(scrollRef) {
        this._scrollView = scrollRef;
      }
    }, {
      key: "_closeButtonClicked",
      value: function _closeButtonClicked() {
        this.setState({
          detailRowID: null
        });
      }
    }, {
      key: "_getStringByValue",
      value: 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;
      }
    }, {
      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: "_getTypeShortName",
      value: function _getTypeShortName(type) {
        if (type === 'XMLHttpRequest') {
          return 'XHR';
        } else if (type === 'WebSocket') {
          return 'WS';
        }

        return '';
      }
    }, {
      key: "_genDetailViewItem",
      value: function _genDetailViewItem(index) {
        this._detailViewItems[index] = [];
        var detailViewItem = this._detailViewItems[index];
        var requestItem = this._requests[index];

        for (var _key in requestItem) {
          detailViewItem.push(React.createElement(View, {
            style: styles.detailViewRow,
            key: _key,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 439
            }
          }, React.createElement(Text, {
            style: [styles.detailViewText, styles.detailKeyCellView],
            __source: {
              fileName: _jsxFileName,
              lineNumber: 440
            }
          }, _key), React.createElement(Text, {
            style: [styles.detailViewText, styles.detailValueCellView],
            __source: {
              fileName: _jsxFileName,
              lineNumber: 443
            }
          }, this._getStringByValue(requestItem[_key]))));
        }

        if (this.state.detailRowID != null && Number(this.state.detailRowID) === index) {
          this.setState({
            newDetailInfo: true
          });
        }
      }
    }, {
      key: "render",
      value: function render() {
        return React.createElement(View, {
          style: styles.container,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 460
          }
        }, this.state.detailRowID != null && React.createElement(TouchableHighlight, {
          style: styles.closeButton,
          onPress: this._closeButtonClicked,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 462
          }
        }, React.createElement(View, {
          __source: {
            fileName: _jsxFileName,
            lineNumber: 465
          }
        }, React.createElement(Text, {
          style: styles.clostButtonText,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 466
          }
        }, "v"))), this.state.detailRowID != null && React.createElement(ScrollView, {
          style: styles.detailScrollView,
          ref: this._captureDetailScrollView,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 471
          }
        }, this._detailViewItems[this.state.detailRowID]), React.createElement(View, {
          style: styles.listViewTitle,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 477
          }
        }, this._requests.length > 0 && React.createElement(View, {
          style: styles.tableRow,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 479
          }
        }, React.createElement(View, {
          style: styles.urlTitleCellView,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 480
          }
        }, React.createElement(Text, {
          style: styles.cellText,
          numberOfLines: 1,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 481
          }
        }, "URL")), React.createElement(View, {
          style: styles.methodTitleCellView,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 485
          }
        }, React.createElement(Text, {
          style: styles.cellText,
          numberOfLines: 1,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 486
          }
        }, "Type")))), React.createElement(ListView, {
          style: styles.listView,
          ref: this._captureRequestListView,
          dataSource: this.state.dataSource,
          renderRow: this._renderRow,
          enableEmptySections: true,
          renderSeparator: this._renderSeperator,
          onLayout: this._listViewOnLayout,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 493
          }
        }));
      }
    }]);

    _inherits(NetworkOverlay, _React$Component);

    return NetworkOverlay;
  }(React.Component);

  NetworkOverlay = _wrapComponent("NetworkOverlay")(NetworkOverlay);
  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
    },
    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
    },
    methodOddCellView: {
      height: 15,
      borderColor: '#DCD7CD',
      borderRightWidth: 1,
      alignItems: 'center',
      justifyContent: 'center',
      backgroundColor: '#000',
      flex: 1
    },
    urlOddCellView: {
      height: 15,
      borderColor: '#DCD7CD',
      borderLeftWidth: 1,
      borderRightWidth: 1,
      justifyContent: 'center',
      backgroundColor: '#000',
      flex: 5,
      paddingLeft: 3
    },
    methodEvenCellView: {
      height: 15,
      borderColor: '#DCD7CD',
      borderRightWidth: 1,
      alignItems: 'center',
      justifyContent: 'center',
      backgroundColor: '#888',
      flex: 1
    },
    urlEvenCellView: {
      height: 15,
      borderColor: '#DCD7CD',
      borderLeftWidth: 1,
      borderRightWidth: 1,
      justifyContent: 'center',
      backgroundColor: '#888',
      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
    },
    clostButtonText: {
      color: 'white',
      fontSize: 10
    },
    closeButton: {
      marginTop: 5,
      backgroundColor: '#888',
      justifyContent: 'center',
      alignItems: 'center'
    }
  });
  module.exports = NetworkOverlay;
},423,[1,11,390,200,367,201,252,420,227,424,425],"node_modules/react-native/Libraries/Inspector/NetworkOverlay.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var RCTWebSocketModule = _$$_REQUIRE(_dependencyMap[0], 'NativeModules').WebSocketModule;

  var NativeEventEmitter = _$$_REQUIRE(_dependencyMap[1], 'NativeEventEmitter');

  var base64 = _$$_REQUIRE(_dependencyMap[2], 'base64-js');

  var originalRCTWebSocketConnect = RCTWebSocketModule.connect;
  var originalRCTWebSocketSend = RCTWebSocketModule.send;
  var originalRCTWebSocketSendBinary = RCTWebSocketModule.sendBinary;
  var originalRCTWebSocketClose = RCTWebSocketModule.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(RCTWebSocketModule);

      WebSocketInterceptor._registerEvents();

      RCTWebSocketModule.connect = function (url, protocols, options, socketId) {
        if (connectCallback) {
          connectCallback(url, protocols, options, socketId);
        }

        originalRCTWebSocketConnect.apply(this, arguments);
      };

      RCTWebSocketModule.send = function (data, socketId) {
        if (sendCallback) {
          sendCallback(data, socketId);
        }

        originalRCTWebSocketSend.apply(this, arguments);
      };

      RCTWebSocketModule.sendBinary = function (data, socketId) {
        if (sendCallback) {
          sendCallback(WebSocketInterceptor._arrayBufferToString(data), socketId);
        }

        originalRCTWebSocketSendBinary.apply(this, arguments);
      };

      RCTWebSocketModule.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;
      RCTWebSocketModule.send = originalRCTWebSocketSend;
      RCTWebSocketModule.sendBinary = originalRCTWebSocketSendBinary;
      RCTWebSocketModule.close = originalRCTWebSocketClose;
      RCTWebSocketModule.connect = originalRCTWebSocketConnect;
      connectCallback = null;
      closeCallback = null;
      sendCallback = null;
      onOpenCallback = null;
      onMessageCallback = null;
      onCloseCallback = null;
      onErrorCallback = null;

      WebSocketInterceptor._unregisterEvents();
    }
  };
  module.exports = WebSocketInterceptor;
},424,[168,286,289],"node_modules/react-native/Libraries/WebSocket/WebSocketInterceptor.js");
__d(function (global, _$$_REQUIRE, 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;
},425,[279],"node_modules/react-native/Libraries/Network/XHRInterceptor.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _default = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[0], "react")).default;

  var _reactTransformHmrLibIndexJs = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./../../../react-transform-hmr/lib/index.js")).default;

  var _jsxFileName = "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Inspector/PerformanceOverlay.js";

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var _components = {
    PerformanceOverlay: {
      displayName: "PerformanceOverlay"
    }
  };

  var _reactTransformHmrLibIndexJs2 = _reactTransformHmrLibIndexJs({
    filename: "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Inspector/PerformanceOverlay.js",
    components: _components,
    locals: [module],
    imports: [_default]
  });

  function _wrapComponent(id) {
    return function (Component) {
      return _reactTransformHmrLibIndexJs2(Component, id);
    };
  }

  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

  var PerformanceLogger = _$$_REQUIRE(_dependencyMap[2], 'PerformanceLogger');

  var React = _$$_REQUIRE(_dependencyMap[3], 'React');

  var StyleSheet = _$$_REQUIRE(_dependencyMap[4], 'StyleSheet');

  var Text = _$$_REQUIRE(_dependencyMap[5], 'Text');

  var View = _$$_REQUIRE(_dependencyMap[6], 'View');

  var PerformanceOverlay = function (_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);
      }
    }]);

    _inherits(PerformanceOverlay, _React$Component);

    return PerformanceOverlay;
  }(React.Component);

  PerformanceOverlay = _wrapComponent("PerformanceOverlay")(PerformanceOverlay);
  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;
},426,[1,11,308,200,201,252,227],"node_modules/react-native/Libraries/Inspector/PerformanceOverlay.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _default = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[0], "react")).default;

  var _reactTransformHmrLibIndexJs = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./../../../react-transform-hmr/lib/index.js")).default;

  var _jsxFileName = "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/YellowBox/YellowBox.js";

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var _components = {
    YellowBox: {
      displayName: "YellowBox"
    },
    _component: {}
  };

  var _reactTransformHmrLibIndexJs2 = _reactTransformHmrLibIndexJs({
    filename: "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/YellowBox/YellowBox.js",
    components: _components,
    locals: [module],
    imports: [_default]
  });

  function _wrapComponent(id) {
    return function (Component) {
      return _reactTransformHmrLibIndexJs2(Component, id);
    };
  }

  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

  var React = _$$_REQUIRE(_dependencyMap[2], 'React');

  var YellowBox;

  if (__DEV__) {
    var Platform = _$$_REQUIRE(_dependencyMap[3], 'Platform');

    var RCTLog = _$$_REQUIRE(_dependencyMap[4], 'RCTLog');

    var YellowBoxList = _$$_REQUIRE(_dependencyMap[5], 'YellowBoxList');

    var YellowBoxRegistry = _$$_REQUIRE(_dependencyMap[6], 'YellowBoxRegistry');

    var _console = console,
        error = _console.error,
        warn = _console.warn;
    YellowBox = _wrapComponent("YellowBox")(function (_React$Component) {
      function YellowBox() {
        var _getPrototypeOf2;

        var _temp, _this;

        _classCallCheck(this, YellowBox);

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

        return _possibleConstructorReturn(_this, (_temp = _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(YellowBox)).call.apply(_getPrototypeOf2, [this].concat(args))), _this.state = {
          registry: null
        }, _this._handleDismiss = function (category) {
          YellowBoxRegistry.delete(category);
        }, _temp));
      }

      _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: 104
            }
          });
        }
      }, {
        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;
        }
      }]);

      _inherits(YellowBox, _React$Component);

      return YellowBox;
    }(React.Component));

    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 = _wrapComponent("_component")(function (_React$Component2) {
      function _class2() {
        _classCallCheck(this, _class2);

        return _possibleConstructorReturn(this, _getPrototypeOf(_class2).apply(this, arguments));
      }

      _createClass(_class2, [{
        key: "render",
        value: function render() {
          return null;
        }
      }], [{
        key: "ignoreWarnings",
        value: function ignoreWarnings(patterns) {}
      }, {
        key: "install",
        value: function install() {}
      }, {
        key: "uninstall",
        value: function uninstall() {}
      }]);

      _inherits(_class2, _React$Component2);

      return _class2;
    }(React.Component));
  }

  module.exports = YellowBox;
},427,[1,11,200,176,306,428,444],"node_modules/react-native/Libraries/YellowBox/YellowBox.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _default = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[0], "react")).default;

  var _reactTransformHmrLibIndexJs = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./../../../../react-transform-hmr/lib/index.js")).default;

  var _jsxFileName = "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/YellowBox/UI/YellowBoxList.js";

  function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

  function _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; }

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var _components = {
    YellowBoxList: {
      displayName: "YellowBoxList"
    }
  };

  var _reactTransformHmrLibIndexJs2 = _reactTransformHmrLibIndexJs({
    filename: "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/YellowBox/UI/YellowBoxList.js",
    components: _components,
    locals: [module],
    imports: [_default]
  });

  function _wrapComponent(id) {
    return function (Component) {
      return _reactTransformHmrLibIndexJs2(Component, id);
    };
  }

  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

  var Dimensions = _$$_REQUIRE(_dependencyMap[2], 'Dimensions');

  var React = _$$_REQUIRE(_dependencyMap[3], 'React');

  var FlatList = _$$_REQUIRE(_dependencyMap[4], 'FlatList');

  var SafeAreaView = _$$_REQUIRE(_dependencyMap[5], 'SafeAreaView');

  var StyleSheet = _$$_REQUIRE(_dependencyMap[6], 'StyleSheet');

  var View = _$$_REQUIRE(_dependencyMap[7], 'View');

  var YellowBoxButton = _$$_REQUIRE(_dependencyMap[8], 'YellowBoxButton');

  var YellowBoxInspector = _$$_REQUIRE(_dependencyMap[9], 'YellowBoxInspector');

  var YellowBoxListRow = _$$_REQUIRE(_dependencyMap[10], 'YellowBoxListRow');

  var YellowBoxStyle = _$$_REQUIRE(_dependencyMap[11], '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) {
    function YellowBoxList() {
      var _getPrototypeOf2;

      var _temp, _this;

      _classCallCheck(this, YellowBoxList);

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

      return _possibleConstructorReturn(_this, (_temp = _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
        });
      }, _temp));
    }

    _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), _i2 = 0, _iterator = _isArray ? _iterator : _iterator[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"]();;) {
          var _ref3;

          if (_isArray) {
            if (_i2 >= _iterator.length) break;
            _ref3 = _iterator[_i2++];
          } else {
            _i2 = _iterator.next();
            if (_i2.done) break;
            _ref3 = _i2.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
          }
        }));
      }
    }]);

    _inherits(YellowBoxList, _React$Component);

    return YellowBoxList;
  }(React.Component);

  YellowBoxList = _wrapComponent("YellowBoxList")(YellowBoxList);
  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;
},428,[1,11,203,200,388,429,201,227,430,433,441,432],"node_modules/react-native/Libraries/YellowBox/UI/YellowBoxList.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  var _default = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[0], "react")).default;

  var _reactTransformHmrLibIndexJs = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./../../../../react-transform-hmr/lib/index.js")).default;

  var _jsxFileName = "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Components/SafeAreaView/SafeAreaView.ios.js";

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

  function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var _components = {
    SafeAreaView: {
      displayName: "SafeAreaView"
    }
  };

  var _reactTransformHmrLibIndexJs2 = _reactTransformHmrLibIndexJs({
    filename: "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Components/SafeAreaView/SafeAreaView.ios.js",
    components: _components,
    locals: [module],
    imports: [_default]
  });

  function _wrapComponent(id) {
    return function (Component) {
      return _reactTransformHmrLibIndexJs2(Component, id);
    };
  }

  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

  var React = _$$_REQUIRE(_dependencyMap[2], 'React');

  var ViewPropTypes = _$$_REQUIRE(_dependencyMap[3], 'ViewPropTypes');

  var requireNativeComponent = _$$_REQUIRE(_dependencyMap[4], 'requireNativeComponent');

  var RCTSafeAreaView = requireNativeComponent('RCTSafeAreaView');

  var SafeAreaView = function (_React$Component) {
    "use strict";

    function SafeAreaView() {
      _classCallCheck(this, SafeAreaView);

      return _possibleConstructorReturn(this, _getPrototypeOf(SafeAreaView).apply(this, arguments));
    }

    _createClass(SafeAreaView, [{
      key: "render",
      value: function render() {
        return React.createElement(RCTSafeAreaView, _extends({}, this.props, {
          __source: {
            fileName: _jsxFileName,
            lineNumber: 35
          }
        }));
      }
    }]);

    _inherits(SafeAreaView, _React$Component);

    return SafeAreaView;
  }(React.Component);

  SafeAreaView.propTypes = _objectSpread({}, ViewPropTypes);
  SafeAreaView = _wrapComponent("SafeAreaView")(SafeAreaView);
  module.exports = SafeAreaView;
},429,[1,11,200,376,229],"node_modules/react-native/Libraries/Components/SafeAreaView/SafeAreaView.ios.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _jsxFileName = "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/YellowBox/UI/YellowBoxButton.js";

  var React = _$$_REQUIRE(_dependencyMap[0], 'React');

  var StyleSheet = _$$_REQUIRE(_dependencyMap[1], 'StyleSheet');

  var Text = _$$_REQUIRE(_dependencyMap[2], '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;
},430,[200,201,252,431,432],"node_modules/react-native/Libraries/YellowBox/UI/YellowBoxButton.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _default = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[0], "react")).default;

  var _reactTransformHmrLibIndexJs = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./../../../../react-transform-hmr/lib/index.js")).default;

  var _jsxFileName = "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/YellowBox/UI/YellowBoxPressable.js";

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var _components = {
    YellowBoxPressable: {
      displayName: "YellowBoxPressable"
    }
  };

  var _reactTransformHmrLibIndexJs2 = _reactTransformHmrLibIndexJs({
    filename: "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/YellowBox/UI/YellowBoxPressable.js",
    components: _components,
    locals: [module],
    imports: [_default]
  });

  function _wrapComponent(id) {
    return function (Component) {
      return _reactTransformHmrLibIndexJs2(Component, id);
    };
  }

  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

  var React = _$$_REQUIRE(_dependencyMap[2], 'React');

  var StyleSheet = _$$_REQUIRE(_dependencyMap[3], 'StyleSheet');

  var TouchableWithoutFeedback = _$$_REQUIRE(_dependencyMap[4], 'TouchableWithoutFeedback');

  var View = _$$_REQUIRE(_dependencyMap[5], 'View');

  var YellowBoxStyle = _$$_REQUIRE(_dependencyMap[6], 'YellowBoxStyle');

  var YellowBoxPressable = function (_React$Component) {
    function YellowBoxPressable() {
      var _getPrototypeOf2;

      var _temp, _this;

      _classCallCheck(this, YellowBoxPressable);

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

      return _possibleConstructorReturn(_this, (_temp = _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
        });
      }, _temp));
    }

    _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: 52
          }
        }, 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: 67
          }
        }, content);
      }
    }]);

    _inherits(YellowBoxPressable, _React$Component);

    return YellowBoxPressable;
  }(React.Component);

  YellowBoxPressable.defaultProps = {
    backgroundColor: {
      default: YellowBoxStyle.getBackgroundColor(0.95),
      pressed: YellowBoxStyle.getHighlightColor(1)
    }
  };
  YellowBoxPressable = _wrapComponent("YellowBoxPressable")(YellowBoxPressable);
  module.exports = YellowBoxPressable;
},431,[1,11,200,201,383,227,432],"node_modules/react-native/Libraries/YellowBox/UI/YellowBoxPressable.js");
__d(function (global, _$$_REQUIRE, 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;
},432,[],"node_modules/react-native/Libraries/YellowBox/UI/YellowBoxStyle.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _default = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[0], "react")).default;

  var _reactTransformHmrLibIndexJs = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./../../../../react-transform-hmr/lib/index.js")).default;

  var _jsxFileName = "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/YellowBox/UI/YellowBoxInspector.js";

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var _components = {
    YellowBoxInspector: {
      displayName: "YellowBoxInspector"
    }
  };

  var _reactTransformHmrLibIndexJs2 = _reactTransformHmrLibIndexJs({
    filename: "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/YellowBox/UI/YellowBoxInspector.js",
    components: _components,
    locals: [module],
    imports: [_default]
  });

  function _wrapComponent(id) {
    return function (Component) {
      return _reactTransformHmrLibIndexJs2(Component, id);
    };
  }

  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

  var Platform = _$$_REQUIRE(_dependencyMap[2], 'Platform');

  var React = _$$_REQUIRE(_dependencyMap[3], 'React');

  var ScrollView = _$$_REQUIRE(_dependencyMap[4], 'ScrollView');

  var StyleSheet = _$$_REQUIRE(_dependencyMap[5], 'StyleSheet');

  var Text = _$$_REQUIRE(_dependencyMap[6], 'Text');

  var View = _$$_REQUIRE(_dependencyMap[7], 'View');

  var YellowBoxCategory = _$$_REQUIRE(_dependencyMap[8], 'YellowBoxCategory');

  var YellowBoxInspectorFooter = _$$_REQUIRE(_dependencyMap[9], 'YellowBoxInspectorFooter');

  var YellowBoxInspectorHeader = _$$_REQUIRE(_dependencyMap[10], 'YellowBoxInspectorHeader');

  var YellowBoxInspectorSourceMapStatus = _$$_REQUIRE(_dependencyMap[11], 'YellowBoxInspectorSourceMapStatus');

  var YellowBoxInspectorStackFrame = _$$_REQUIRE(_dependencyMap[12], 'YellowBoxInspectorStackFrame');

  var YellowBoxStyle = _$$_REQUIRE(_dependencyMap[13], 'YellowBoxStyle');

  var openFileInEditor = _$$_REQUIRE(_dependencyMap[14], 'openFileInEditor');

  var YellowBoxInspector = function (_React$Component) {
    function YellowBoxInspector() {
      var _getPrototypeOf2;

      var _temp, _this;

      _classCallCheck(this, YellowBoxInspector);

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

      return _possibleConstructorReturn(_this, (_temp = _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(YellowBoxInspector)).call.apply(_getPrototypeOf2, [this].concat(args))), _this.state = {
        selectedIndex: 0
      }, _this._handleSelectIndex = function (selectedIndex) {
        _this.setState({
          selectedIndex: selectedIndex
        });
      }, _temp));
    }

    _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, {
          status: warning.symbolicated.status,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 79
          }
        })), warning.getAvailableStack().map(function (frame, index) {
          return React.createElement(YellowBoxInspectorStackFrame, {
            key: index,
            frame: frame,
            onPress: warning.symbolicated.status === 'COMPLETE' ? function () {
              openFileInEditor(frame.file, frame.lineNumber);
            } : null,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 84
            }
          });
        }))), React.createElement(YellowBoxInspectorFooter, {
          onDismiss: this.props.onDismiss,
          onMinimize: this.props.onMinimize,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 98
          }
        }));
      }
    }, {
      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;
        }
      }
    }]);

    _inherits(YellowBoxInspector, _React$Component);

    return YellowBoxInspector;
  }(React.Component);

  YellowBoxInspector = _wrapComponent("YellowBoxInspector")(YellowBoxInspector);
  var styles = StyleSheet.create({
    root: {
      elevation: Platform.OS === '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;
},433,[1,11,176,200,367,201,252,227,434,436,437,438,440,432,422],"node_modules/react-native/Libraries/YellowBox/UI/YellowBoxInspector.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _jsxFileName = "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/YellowBox/Data/YellowBoxCategory.js";

  function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }

  function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); }

  function _iterableToArray(iter) { if ((typeof Symbol === "function" ? Symbol.iterator : "@@iterator") in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); }

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

  var React = _$$_REQUIRE(_dependencyMap[0], 'React');

  var Text = _$$_REQUIRE(_dependencyMap[1], 'Text');

  var UTFSequence = _$$_REQUIRE(_dependencyMap[2], 'UTFSequence');

  var stringifySafe = _$$_REQUIRE(_dependencyMap[3], '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 - 1) {
        var lastPart = content.substr(lastOffset);
        elements.push(React.createElement(Text, {
          key: "-1",
          __source: {
            fileName: _jsxFileName,
            lineNumber: 139
          }
        }, lastPart));
      }

      return elements;
    }
  };
  module.exports = YellowBoxCategory;
},434,[200,252,435,174],"node_modules/react-native/Libraries/YellowBox/Data/YellowBoxCategory.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var deepFreezeAndThrowOnMutationInDev = _$$_REQUIRE(_dependencyMap[0], '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;
},435,[173],"node_modules/react-native/Libraries/UTFSequence.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _jsxFileName = "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/YellowBox/UI/YellowBoxInspectorFooter.js";

  var React = _$$_REQUIRE(_dependencyMap[0], 'React');

  var SafeAreaView = _$$_REQUIRE(_dependencyMap[1], 'SafeAreaView');

  var StyleSheet = _$$_REQUIRE(_dependencyMap[2], 'StyleSheet');

  var Text = _$$_REQUIRE(_dependencyMap[3], 'Text');

  var View = _$$_REQUIRE(_dependencyMap[4], '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;
},436,[200,429,201,252,227,431,432],"node_modules/react-native/Libraries/YellowBox/UI/YellowBoxInspectorFooter.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _jsxFileName = "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/YellowBox/UI/YellowBoxInspectorHeader.js";

  var Platform = _$$_REQUIRE(_dependencyMap[0], 'Platform');

  var React = _$$_REQUIRE(_dependencyMap[1], 'React');

  var SafeAreaView = _$$_REQUIRE(_dependencyMap[2], 'SafeAreaView');

  var StyleSheet = _$$_REQUIRE(_dependencyMap[3], 'StyleSheet');

  var Text = _$$_REQUIRE(_dependencyMap[4], 'Text');

  var UTFSequence = _$$_REQUIRE(_dependencyMap[5], 'UTFSequence');

  var View = _$$_REQUIRE(_dependencyMap[6], 'View');

  var YellowBoxPressable = _$$_REQUIRE(_dependencyMap[7], 'YellowBoxPressable');

  var YellowBoxStyle = _$$_REQUIRE(_dependencyMap[8], '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: 41
      }
    }, React.createElement(View, {
      style: styles.header,
      __source: {
        fileName: _jsxFileName,
        lineNumber: 42
      }
    }, React.createElement(YellowBoxInspectorHeaderButton, {
      disabled: props.warnings[prevIndex] == null,
      label: UTFSequence.TRIANGLE_LEFT,
      onPress: function onPress() {
        return props.onSelectIndex(prevIndex);
      },
      __source: {
        fileName: _jsxFileName,
        lineNumber: 43
      }
    }), React.createElement(View, {
      style: styles.headerTitle,
      __source: {
        fileName: _jsxFileName,
        lineNumber: 48
      }
    }, React.createElement(Text, {
      style: styles.headerTitleText,
      __source: {
        fileName: _jsxFileName,
        lineNumber: 49
      }
    }, titleText)), React.createElement(YellowBoxInspectorHeaderButton, {
      disabled: props.warnings[nextIndex] == null,
      label: UTFSequence.TRIANGLE_RIGHT,
      onPress: function onPress() {
        return props.onSelectIndex(nextIndex);
      },
      __source: {
        fileName: _jsxFileName,
        lineNumber: 51
      }
    })));
  };

  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: 68
      }
    }, props.disabled ? null : React.createElement(Text, {
      style: styles.headerButtonText,
      __source: {
        fileName: _jsxFileName,
        lineNumber: 76
      }
    }, props.label));
  };

  var styles = StyleSheet.create({
    root: {
      backgroundColor: YellowBoxStyle.getBackgroundColor(0.95)
    },
    header: {
      flexDirection: 'row',
      height: Platform.select({
        android: 48,
        ios: 44
      })
    },
    headerButton: {
      alignItems: 'center',
      aspectRatio: 1,
      justifyContent: 'center'
    },
    headerButtonText: {
      color: YellowBoxStyle.getTextColor(1),
      fontSize: 16,
      includeFontPadding: false,
      lineHeight: 20
    },
    headerTitle: {
      alignItems: 'center',
      flex: 1,
      justifyContent: 'center'
    },
    headerTitleText: {
      color: YellowBoxStyle.getTextColor(1),
      fontSize: 16,
      fontWeight: '600',
      includeFontPadding: false,
      lineHeight: 20
    }
  });
  module.exports = YellowBoxInspectorHeader;
},437,[176,200,429,201,252,435,227,431,432],"node_modules/react-native/Libraries/YellowBox/UI/YellowBoxInspectorHeader.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _default = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[0], "react")).default;

  var _reactTransformHmrLibIndexJs = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./../../../../react-transform-hmr/lib/index.js")).default;

  var _jsxFileName = "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/YellowBox/UI/YellowBoxInspectorSourceMapStatus.js";

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var _components = {
    YellowBoxInspectorSourceMapStatus: {
      displayName: "YellowBoxInspectorSourceMapStatus"
    }
  };

  var _reactTransformHmrLibIndexJs2 = _reactTransformHmrLibIndexJs({
    filename: "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/YellowBox/UI/YellowBoxInspectorSourceMapStatus.js",
    components: _components,
    locals: [module],
    imports: [_default]
  });

  function _wrapComponent(id) {
    return function (Component) {
      return _reactTransformHmrLibIndexJs2(Component, id);
    };
  }

  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

  var Animated = _$$_REQUIRE(_dependencyMap[2], 'Animated');

  var Easing = _$$_REQUIRE(_dependencyMap[3], 'Easing');

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

  var StyleSheet = _$$_REQUIRE(_dependencyMap[5], 'StyleSheet');

  var Text = _$$_REQUIRE(_dependencyMap[6], 'Text');

  var View = _$$_REQUIRE(_dependencyMap[7], 'View');

  var YellowBoxImageSource = _$$_REQUIRE(_dependencyMap[8], 'YellowBoxImageSource');

  var YellowBoxStyle = _$$_REQUIRE(_dependencyMap[9], 'YellowBoxStyle');

  var YellowBoxInspectorSourceMapStatus = function (_React$Component) {
    function YellowBoxInspectorSourceMapStatus() {
      var _getPrototypeOf2;

      var _temp, _this;

      _classCallCheck(this, YellowBoxInspectorSourceMapStatus);

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

      return _possibleConstructorReturn(_this, (_temp = _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(YellowBoxInspectorSourceMapStatus)).call.apply(_getPrototypeOf2, [this].concat(args))), _this.state = {
        animation: null,
        rotate: null
      }, _temp));
    }

    _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(View, {
          style: StyleSheet.compose(styles.root, this.props.status === 'PENDING' ? styles.pending : null),
          __source: {
            fileName: _jsxFileName,
            lineNumber: 55
          }
        }, 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: 60
          }
        }), React.createElement(Text, {
          style: styles.text,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 69
          }
        }, "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
            });
          }
        }
      }
    }]);

    _inherits(YellowBoxInspectorSourceMapStatus, _React$Component);

    return YellowBoxInspectorSourceMapStatus;
  }(React.Component);

  YellowBoxInspectorSourceMapStatus = _wrapComponent("YellowBoxInspectorSourceMapStatus")(YellowBoxInspectorSourceMapStatus);
  var styles = StyleSheet.create({
    root: {
      alignItems: 'center',
      backgroundColor: YellowBoxStyle.getTextColor(0.8),
      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;
},438,[1,11,332,358,200,201,252,227,439,432],"node_modules/react-native/Libraries/YellowBox/UI/YellowBoxInspectorSourceMapStatus.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var PixelRatio = _$$_REQUIRE(_dependencyMap[0], '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',
    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;
},439,[202],"node_modules/react-native/Libraries/YellowBox/UI/YellowBoxImageSource.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _jsxFileName = "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/YellowBox/UI/YellowBoxInspectorStackFrame.js";

  var React = _$$_REQUIRE(_dependencyMap[0], 'React');

  var StyleSheet = _$$_REQUIRE(_dependencyMap[1], 'StyleSheet');

  var Text = _$$_REQUIRE(_dependencyMap[2], '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
      }
    }, getFrameLocation(frame.file) + ":" + frame.lineNumber + (frame.column == null ? '' : ':' + frame.column)));
  };

  var getFrameLocation = function getFrameLocation(uri) {
    var queryIndex = uri.indexOf('?');
    var query = queryIndex < 0 ? '' : uri.substr(queryIndex);
    var path = queryIndex < 0 ? uri : uri.substr(0, queryIndex);
    var file = path.substr(path.lastIndexOf('/') + 1);
    return file + query;
  };

  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;
},440,[200,201,252,431,432],"node_modules/react-native/Libraries/YellowBox/UI/YellowBoxInspectorStackFrame.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _default = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[0], "react")).default;

  var _reactTransformHmrLibIndexJs = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./../../../../react-transform-hmr/lib/index.js")).default;

  var _jsxFileName = "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/YellowBox/UI/YellowBoxListRow.js";

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var _components = {
    YellowBoxListRow: {
      displayName: "YellowBoxListRow"
    }
  };

  var _reactTransformHmrLibIndexJs2 = _reactTransformHmrLibIndexJs({
    filename: "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/YellowBox/UI/YellowBoxListRow.js",
    components: _components,
    locals: [module],
    imports: [_default]
  });

  function _wrapComponent(id) {
    return function (Component) {
      return _reactTransformHmrLibIndexJs2(Component, id);
    };
  }

  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

  var React = _$$_REQUIRE(_dependencyMap[2], 'React');

  var StyleSheet = _$$_REQUIRE(_dependencyMap[3], 'StyleSheet');

  var Text = _$$_REQUIRE(_dependencyMap[4], 'Text');

  var YellowBoxPressable = _$$_REQUIRE(_dependencyMap[5], 'YellowBoxPressable');

  var View = _$$_REQUIRE(_dependencyMap[6], 'View');

  var YellowBoxCategory = _$$_REQUIRE(_dependencyMap[7], 'YellowBoxCategory');

  var YellowBoxStyle = _$$_REQUIRE(_dependencyMap[8], 'YellowBoxStyle');

  var YellowBoxWarning = _$$_REQUIRE(_dependencyMap[9], 'YellowBoxWarning');

  var YellowBoxListRow = function (_React$Component) {
    function YellowBoxListRow() {
      var _getPrototypeOf2;

      var _temp, _this;

      _classCallCheck(this, YellowBoxListRow);

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

      return _possibleConstructorReturn(_this, (_temp = _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(YellowBoxListRow)).call.apply(_getPrototypeOf2, [this].concat(args))), _this._handlePress = function () {
        _this.props.onPress(_this.props.category);
      }, _temp));
    }

    _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[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))));
      }
    }]);

    _inherits(YellowBoxListRow, _React$Component);

    return YellowBoxListRow;
  }(React.Component);

  YellowBoxListRow.GUTTER = StyleSheet.hairlineWidth;
  YellowBoxListRow.HEIGHT = 48;
  YellowBoxListRow = _wrapComponent("YellowBoxListRow")(YellowBoxListRow);
  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;
},441,[1,11,200,201,252,431,227,434,432,442],"node_modules/react-native/Libraries/YellowBox/UI/YellowBoxListRow.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

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

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  var YellowBoxCategory = _$$_REQUIRE(_dependencyMap[0], 'YellowBoxCategory');

  var YellowBoxSymbolication = _$$_REQUIRE(_dependencyMap[1], 'YellowBoxSymbolication');

  var parseErrorStack = _$$_REQUIRE(_dependencyMap[2], '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: "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;
},442,[434,443,180],"node_modules/react-native/Libraries/YellowBox/Data/YellowBoxWarning.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var symbolicateStackTrace = _$$_REQUIRE(_dependencyMap[0], 'symbolicateStackTrace');

  var cache = new Map();
  var YellowBoxSymbolication = {
    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;
},443,[272],"node_modules/react-native/Libraries/YellowBox/Data/YellowBoxSymbolication.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }

  function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); }

  function _iterableToArray(iter) { if ((typeof Symbol === "function" ? Symbol.iterator : "@@iterator") in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); }

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

  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 YellowBoxWarning = _$$_REQUIRE(_dependencyMap[0], '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 (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 _observer2 = _ref8.observer;

          _observer2(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 = _toConsumableArray(warnings).concat([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) {
        return !ignorePatterns.has(pattern);
      });

      if (newPatterns.length === 0) {
        return;
      }

      for (var _iterator4 = newPatterns, _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 _pattern2 = _ref10;
        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;
},444,[442],"node_modules/react-native/Libraries/YellowBox/Data/YellowBoxRegistry.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var I18nManager = _$$_REQUIRE(_dependencyMap[0], 'NativeModules').I18nManager || {
    isRTL: false,
    doLeftAndRightSwapInRTL: true,
    allowRTL: function allowRTL() {},
    forceRTL: function forceRTL() {},
    swapLeftAndRightInRTL: function swapLeftAndRightInRTL() {}
  };
  module.exports = I18nManager;
},445,[168],"node_modules/react-native/Libraries/ReactNative/I18nManager.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _default = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[0], "react")).default;

  var _reactTransformHmrLibIndexJs = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./../../../../react-transform-hmr/lib/index.js")).default;

  var _jsxFileName = "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Components/Navigation/NavigatorIOS.ios.js";

  function _objectWithoutProperties(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]; } 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; }

  function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var _components = {
    NavigatorTransitionerIOS: {
      displayName: "NavigatorTransitionerIOS"
    }
  };

  var _reactTransformHmrLibIndexJs2 = _reactTransformHmrLibIndexJs({
    filename: "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Components/Navigation/NavigatorIOS.ios.js",
    components: _components,
    locals: [module],
    imports: [_default]
  });

  function _wrapComponent(id) {
    return function (Component) {
      return _reactTransformHmrLibIndexJs2(Component, id);
    };
  }

  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

  var EventEmitter = _$$_REQUIRE(_dependencyMap[2], 'EventEmitter');

  var Image = _$$_REQUIRE(_dependencyMap[3], 'Image');

  var RCTNavigatorManager = _$$_REQUIRE(_dependencyMap[4], 'NativeModules').NavigatorManager;

  var React = _$$_REQUIRE(_dependencyMap[5], 'React');

  var PropTypes = _$$_REQUIRE(_dependencyMap[6], 'prop-types');

  var ReactNative = _$$_REQUIRE(_dependencyMap[7], 'ReactNative');

  var StaticContainer = _$$_REQUIRE(_dependencyMap[8], 'StaticContainer.react');

  var StyleSheet = _$$_REQUIRE(_dependencyMap[9], 'StyleSheet');

  var TVEventHandler = _$$_REQUIRE(_dependencyMap[10], 'TVEventHandler');

  var View = _$$_REQUIRE(_dependencyMap[11], 'View');

  var ViewPropTypes = _$$_REQUIRE(_dependencyMap[12], 'ViewPropTypes');

  var createReactClass = _$$_REQUIRE(_dependencyMap[13], 'create-react-class');

  var invariant = _$$_REQUIRE(_dependencyMap[14], 'fbjs/lib/invariant');

  var requireNativeComponent = _$$_REQUIRE(_dependencyMap[15], 'requireNativeComponent');

  var keyMirror = _$$_REQUIRE(_dependencyMap[16], 'fbjs/lib/keyMirror');

  var TRANSITIONER_REF = 'transitionerRef';
  var __uid = 0;

  function getuid() {
    return __uid++;
  }

  var NavigatorTransitionerIOS = function (_React$Component) {
    function NavigatorTransitionerIOS() {
      _classCallCheck(this, NavigatorTransitionerIOS);

      return _possibleConstructorReturn(this, _getPrototypeOf(NavigatorTransitionerIOS).apply(this, arguments));
    }

    _createClass(NavigatorTransitionerIOS, [{
      key: "requestSchedulingNavigation",
      value: function requestSchedulingNavigation(cb) {
        RCTNavigatorManager.requestSchedulingJavaScriptNavigation(ReactNative.findNodeHandle(this), cb);
      }
    }, {
      key: "render",
      value: function render() {
        return React.createElement(RCTNavigator, _extends({}, this.props, {
          __source: {
            fileName: _jsxFileName,
            lineNumber: 50
          }
        }));
      }
    }]);

    _inherits(NavigatorTransitionerIOS, _React$Component);

    return NavigatorTransitionerIOS;
  }(React.Component);

  NavigatorTransitionerIOS = _wrapComponent("NavigatorTransitionerIOS")(NavigatorTransitionerIOS);
  var SystemIconLabels = {
    done: true,
    cancel: true,
    edit: true,
    save: true,
    add: true,
    compose: true,
    reply: true,
    action: true,
    organize: true,
    bookmarks: true,
    search: true,
    refresh: true,
    stop: true,
    camera: true,
    trash: true,
    play: true,
    pause: true,
    rewind: true,
    'fast-forward': true,
    undo: true,
    redo: true,
    'page-curl': true
  };
  var SystemIcons = keyMirror(SystemIconLabels);
  var NavigatorIOS = createReactClass({
    displayName: 'NavigatorIOS',
    propTypes: {
      initialRoute: PropTypes.shape({
        component: PropTypes.func.isRequired,
        title: PropTypes.string.isRequired,
        titleImage: Image.propTypes.source,
        passProps: PropTypes.object,
        backButtonIcon: Image.propTypes.source,
        backButtonTitle: PropTypes.string,
        leftButtonIcon: Image.propTypes.source,
        leftButtonTitle: PropTypes.string,
        leftButtonSystemIcon: PropTypes.oneOf(Object.keys(SystemIcons)),
        onLeftButtonPress: PropTypes.func,
        rightButtonIcon: Image.propTypes.source,
        rightButtonTitle: PropTypes.string,
        rightButtonSystemIcon: PropTypes.oneOf(Object.keys(SystemIcons)),
        onRightButtonPress: PropTypes.func,
        wrapperStyle: ViewPropTypes.style,
        navigationBarHidden: PropTypes.bool,
        shadowHidden: PropTypes.bool,
        tintColor: PropTypes.string,
        barTintColor: PropTypes.string,
        barStyle: PropTypes.oneOf(['default', 'black']),
        titleTextColor: PropTypes.string,
        translucent: PropTypes.bool
      }).isRequired,
      navigationBarHidden: PropTypes.bool,
      shadowHidden: PropTypes.bool,
      itemWrapperStyle: ViewPropTypes.style,
      tintColor: PropTypes.string,
      barTintColor: PropTypes.string,
      barStyle: PropTypes.oneOf(['default', 'black']),
      titleTextColor: PropTypes.string,
      translucent: PropTypes.bool,
      interactivePopGestureEnabled: PropTypes.bool
    },
    navigator: undefined,
    UNSAFE_componentWillMount: function UNSAFE_componentWillMount() {
      this.navigator = {
        push: this.push,
        pop: this.pop,
        popN: this.popN,
        replace: this.replace,
        replaceAtIndex: this.replaceAtIndex,
        replacePrevious: this.replacePrevious,
        replacePreviousAndPop: this.replacePreviousAndPop,
        resetTo: this.resetTo,
        popToRoute: this.popToRoute,
        popToTop: this.popToTop
      };
    },
    componentDidMount: function componentDidMount() {
      this._enableTVEventHandler();
    },
    componentWillUnmount: function componentWillUnmount() {
      this._disableTVEventHandler();
    },
    getDefaultProps: function getDefaultProps() {
      return {
        translucent: true
      };
    },
    getInitialState: function getInitialState() {
      return {
        idStack: [getuid()],
        routeStack: [this.props.initialRoute],
        requestedTopOfStack: 0,
        observedTopOfStack: 0,
        progress: 1,
        fromIndex: 0,
        toIndex: 0,
        makingNavigatorRequest: false,
        updatingAllIndicesAtOrBeyond: 0
      };
    },
    _toFocusOnNavigationComplete: undefined,
    _handleFocusRequest: function _handleFocusRequest(item) {
      if (this.state.makingNavigatorRequest) {
        this._toFocusOnNavigationComplete = item;
      } else {
        this._getFocusEmitter().emit('focus', item);
      }
    },
    _focusEmitter: undefined,
    _getFocusEmitter: function _getFocusEmitter() {
      var focusEmitter = this._focusEmitter;

      if (!focusEmitter) {
        focusEmitter = new EventEmitter();
        this._focusEmitter = focusEmitter;
      }

      return focusEmitter;
    },
    getChildContext: function getChildContext() {
      return {
        onFocusRequested: this._handleFocusRequest,
        focusEmitter: this._getFocusEmitter()
      };
    },
    childContextTypes: {
      onFocusRequested: PropTypes.func,
      focusEmitter: PropTypes.instanceOf(EventEmitter)
    },
    _tryLockNavigator: function _tryLockNavigator(cb) {
      this.refs[TRANSITIONER_REF].requestSchedulingNavigation(function (acquiredLock) {
        return acquiredLock && cb();
      });
    },
    _handleNavigatorStackChanged: function _handleNavigatorStackChanged(e) {
      var newObservedTopOfStack = e.nativeEvent.stackLength - 1;
      invariant(newObservedTopOfStack <= this.state.requestedTopOfStack, 'No navigator item should be pushed without JS knowing about it %s %s', newObservedTopOfStack, this.state.requestedTopOfStack);
      var wasWaitingForConfirmation = this.state.requestedTopOfStack !== this.state.observedTopOfStack;

      if (wasWaitingForConfirmation) {
        invariant(newObservedTopOfStack === this.state.requestedTopOfStack, 'If waiting for observedTopOfStack to reach requestedTopOfStack, ' + 'the only valid observedTopOfStack should be requestedTopOfStack.');
      }

      var nextState = {
        observedTopOfStack: newObservedTopOfStack,
        makingNavigatorRequest: false,
        updatingAllIndicesAtOrBeyond: null,
        progress: 1,
        toIndex: newObservedTopOfStack,
        fromIndex: newObservedTopOfStack
      };
      this.setState(nextState, this._eliminateUnneededChildren);
    },
    _eliminateUnneededChildren: function _eliminateUnneededChildren() {
      var updatingAllIndicesAtOrBeyond = this.state.routeStack.length > this.state.observedTopOfStack + 1 ? this.state.observedTopOfStack + 1 : null;
      this.setState({
        idStack: this.state.idStack.slice(0, this.state.observedTopOfStack + 1),
        routeStack: this.state.routeStack.slice(0, this.state.observedTopOfStack + 1),
        requestedTopOfStack: this.state.observedTopOfStack,
        makingNavigatorRequest: true,
        updatingAllIndicesAtOrBeyond: updatingAllIndicesAtOrBeyond
      });
    },
    push: function push(route) {
      var _this = this;

      invariant(!!route, 'Must supply route to push');

      if (this.state.requestedTopOfStack === this.state.observedTopOfStack) {
        this._tryLockNavigator(function () {
          var nextStack = _this.state.routeStack.concat([route]);

          var nextIDStack = _this.state.idStack.concat([getuid()]);

          _this.setState({
            idStack: nextIDStack,
            routeStack: nextStack,
            requestedTopOfStack: nextStack.length - 1,
            makingNavigatorRequest: true,
            updatingAllIndicesAtOrBeyond: nextStack.length - 1
          });
        });
      }
    },
    popN: function popN(n) {
      var _this2 = this;

      if (n === 0) {
        return;
      }

      if (this.state.requestedTopOfStack === this.state.observedTopOfStack) {
        if (this.state.requestedTopOfStack > 0) {
          this._tryLockNavigator(function () {
            var newRequestedTopOfStack = _this2.state.requestedTopOfStack - n;
            invariant(newRequestedTopOfStack >= 0, 'Cannot pop below 0');

            _this2.setState({
              requestedTopOfStack: newRequestedTopOfStack,
              makingNavigatorRequest: true,
              updatingAllIndicesAtOrBeyond: _this2.state.requestedTopOfStack - n
            });
          });
        }
      }
    },
    pop: function pop() {
      this.popN(1);
    },
    replaceAtIndex: function replaceAtIndex(route, index) {
      invariant(!!route, 'Must supply route to replace');

      if (index < 0) {
        index += this.state.routeStack.length;
      }

      if (this.state.routeStack.length <= index) {
        return;
      }

      var nextIDStack = this.state.idStack.slice();
      var nextRouteStack = this.state.routeStack.slice();
      nextIDStack[index] = getuid();
      nextRouteStack[index] = route;
      this.setState({
        idStack: nextIDStack,
        routeStack: nextRouteStack,
        makingNavigatorRequest: false,
        updatingAllIndicesAtOrBeyond: index
      });
    },
    replace: function replace(route) {
      this.replaceAtIndex(route, -1);
    },
    replacePrevious: function replacePrevious(route) {
      this.replaceAtIndex(route, -2);
    },
    popToTop: function popToTop() {
      this.popToRoute(this.state.routeStack[0]);
    },
    popToRoute: function popToRoute(route) {
      var indexOfRoute = this.state.routeStack.indexOf(route);
      invariant(indexOfRoute !== -1, "Calling pop to route for a route that doesn't exist!");
      var numToPop = this.state.routeStack.length - indexOfRoute - 1;
      this.popN(numToPop);
    },
    replacePreviousAndPop: function replacePreviousAndPop(route) {
      var _this3 = this;

      if (this.state.requestedTopOfStack !== this.state.observedTopOfStack) {
        return;
      }

      if (this.state.routeStack.length < 2) {
        return;
      }

      this._tryLockNavigator(function () {
        _this3.replacePrevious(route);

        _this3.setState({
          requestedTopOfStack: _this3.state.requestedTopOfStack - 1,
          makingNavigatorRequest: true
        });
      });
    },
    resetTo: function resetTo(route) {
      invariant(!!route, 'Must supply route to push');

      if (this.state.requestedTopOfStack !== this.state.observedTopOfStack) {
        return;
      }

      this.replaceAtIndex(route, 0);
      this.popToRoute(route);
    },
    _handleNavigationComplete: function _handleNavigationComplete(e) {
      e.stopPropagation();

      if (this._toFocusOnNavigationComplete) {
        this._getFocusEmitter().emit('focus', this._toFocusOnNavigationComplete);

        this._toFocusOnNavigationComplete = null;
      }

      this._handleNavigatorStackChanged(e);
    },
    _routeToStackItem: function _routeToStackItem(routeArg, i) {
      var component = routeArg.component,
          wrapperStyle = routeArg.wrapperStyle,
          passProps = routeArg.passProps,
          route = _objectWithoutProperties(routeArg, ["component", "wrapperStyle", "passProps"]);

      var _this$props = this.props,
          itemWrapperStyle = _this$props.itemWrapperStyle,
          props = _objectWithoutProperties(_this$props, ["itemWrapperStyle"]);

      var shouldUpdateChild = this.state.updatingAllIndicesAtOrBeyond != null && this.state.updatingAllIndicesAtOrBeyond >= i;
      var Component = component;
      return React.createElement(StaticContainer, {
        key: 'nav' + i,
        shouldUpdate: shouldUpdateChild,
        __source: {
          fileName: _jsxFileName,
          lineNumber: 850
        }
      }, React.createElement(RCTNavigatorItem, _extends({}, props, route, {
        style: [styles.stackItem, itemWrapperStyle, wrapperStyle],
        __source: {
          fileName: _jsxFileName,
          lineNumber: 851
        }
      }), React.createElement(Component, _extends({
        navigator: this.navigator,
        route: route
      }, passProps, {
        __source: {
          fileName: _jsxFileName,
          lineNumber: 855
        }
      }))));
    },
    _renderNavigationStackItems: function _renderNavigationStackItems() {
      var shouldRecurseToNavigator = this.state.makingNavigatorRequest || this.state.updatingAllIndicesAtOrBeyond !== null;
      var items = shouldRecurseToNavigator ? this.state.routeStack.map(this._routeToStackItem) : null;
      return React.createElement(StaticContainer, {
        shouldUpdate: shouldRecurseToNavigator,
        __source: {
          fileName: _jsxFileName,
          lineNumber: 871
        }
      }, React.createElement(NavigatorTransitionerIOS, {
        ref: TRANSITIONER_REF,
        style: styles.transitioner,
        vertical: this.props.vertical,
        requestedTopOfStack: this.state.requestedTopOfStack,
        onNavigationComplete: this._handleNavigationComplete,
        interactivePopGestureEnabled: this.props.interactivePopGestureEnabled,
        __source: {
          fileName: _jsxFileName,
          lineNumber: 872
        }
      }, items));
    },
    _tvEventHandler: undefined,
    _enableTVEventHandler: function _enableTVEventHandler() {
      this._tvEventHandler = new TVEventHandler();

      this._tvEventHandler.enable(this, function (cmp, evt) {
        if (evt && evt.eventType === 'menu') {
          cmp.pop();
        }
      });
    },
    _disableTVEventHandler: function _disableTVEventHandler() {
      if (this._tvEventHandler) {
        this._tvEventHandler.disable();

        delete this._tvEventHandler;
      }
    },
    render: function render() {
      return React.createElement(View, {
        style: this.props.style,
        __source: {
          fileName: _jsxFileName,
          lineNumber: 909
        }
      }, this._renderNavigationStackItems());
    }
  });
  var styles = StyleSheet.create({
    stackItem: {
      backgroundColor: 'white',
      overflow: 'hidden',
      position: 'absolute',
      top: 0,
      left: 0,
      right: 0,
      bottom: 0
    },
    transitioner: {
      flex: 1
    }
  });
  var RCTNavigator = requireNativeComponent('RCTNavigator');
  var RCTNavigatorItem = requireNativeComponent('RCTNavItem');
  module.exports = NavigatorIOS;
},446,[1,11,195,361,168,200,212,261,447,201,327,227,376,365,166,229,210],"node_modules/react-native/Libraries/Components/Navigation/NavigatorIOS.ios.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _default = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[0], "react")).default;

  var _reactTransformHmrLibIndexJs = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./../../../react-transform-hmr/lib/index.js")).default;

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var _components = {
    StaticContainer: {
      displayName: "StaticContainer"
    }
  };

  var _reactTransformHmrLibIndexJs2 = _reactTransformHmrLibIndexJs({
    filename: "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Components/StaticContainer.react.js",
    components: _components,
    locals: [module],
    imports: [_default]
  });

  function _wrapComponent(id) {
    return function (Component) {
      return _reactTransformHmrLibIndexJs2(Component, id);
    };
  }

  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

  var React = _$$_REQUIRE(_dependencyMap[2], 'React');

  var StaticContainer = function (_React$Component) {
    function StaticContainer() {
      _classCallCheck(this, StaticContainer);

      return _possibleConstructorReturn(this, _getPrototypeOf(StaticContainer).apply(this, arguments));
    }

    _createClass(StaticContainer, [{
      key: "shouldComponentUpdate",
      value: function shouldComponentUpdate(nextProps) {
        return !!nextProps.shouldUpdate;
      }
    }, {
      key: "render",
      value: function render() {
        var child = this.props.children;
        return child === null || child === false ? null : React.Children.only(child);
      }
    }]);

    _inherits(StaticContainer, _React$Component);

    return StaticContainer;
  }(React.Component);

  StaticContainer = _wrapComponent("StaticContainer")(StaticContainer);
  module.exports = StaticContainer;
},447,[1,11,200],"node_modules/react-native/Libraries/Components/StaticContainer.react.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _default = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[0], "react")).default;

  var _reactTransformHmrLibIndexJs = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./../../../../react-transform-hmr/lib/index.js")).default;

  var _jsxFileName = "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Components/Picker/Picker.js";

  function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  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 _components = {
    PickerItem: {
      displayName: "PickerItem"
    },
    Picker: {
      displayName: "Picker"
    }
  };

  var _reactTransformHmrLibIndexJs2 = _reactTransformHmrLibIndexJs({
    filename: "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Components/Picker/Picker.js",
    components: _components,
    locals: [module],
    imports: [_default]
  });

  function _wrapComponent(id) {
    return function (Component) {
      return _reactTransformHmrLibIndexJs2(Component, id);
    };
  }

  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

  var ColorPropType = _$$_REQUIRE(_dependencyMap[2], 'ColorPropType');

  var PickerIOS = _$$_REQUIRE(_dependencyMap[3], 'PickerIOS');

  var PickerAndroid = _$$_REQUIRE(_dependencyMap[4], 'PickerAndroid');

  var Platform = _$$_REQUIRE(_dependencyMap[5], 'Platform');

  var React = _$$_REQUIRE(_dependencyMap[6], 'React');

  var PropTypes = _$$_REQUIRE(_dependencyMap[7], 'prop-types');

  var StyleSheetPropType = _$$_REQUIRE(_dependencyMap[8], 'StyleSheetPropType');

  var TextStylePropTypes = _$$_REQUIRE(_dependencyMap[9], 'TextStylePropTypes');

  var UnimplementedView = _$$_REQUIRE(_dependencyMap[10], 'UnimplementedView');

  var ViewPropTypes = _$$_REQUIRE(_dependencyMap[11], 'ViewPropTypes');

  var ViewStylePropTypes = _$$_REQUIRE(_dependencyMap[12], 'ViewStylePropTypes');

  var itemStylePropType = StyleSheetPropType(TextStylePropTypes);
  var pickerStyleType = StyleSheetPropType(_objectSpread({}, ViewStylePropTypes, {
    color: ColorPropType
  }));
  var MODE_DIALOG = 'dialog';
  var MODE_DROPDOWN = 'dropdown';

  var PickerItem = function (_React$Component) {
    function PickerItem() {
      _classCallCheck(this, PickerItem);

      return _possibleConstructorReturn(this, _getPrototypeOf(PickerItem).apply(this, arguments));
    }

    _createClass(PickerItem, [{
      key: "render",
      value: function render() {
        throw null;
      }
    }]);

    _inherits(PickerItem, _React$Component);

    return PickerItem;
  }(React.Component);

  PickerItem.propTypes = {
    label: PropTypes.string.isRequired,
    value: PropTypes.any,
    color: ColorPropType,
    testID: PropTypes.string
  };
  PickerItem = _wrapComponent("PickerItem")(PickerItem);

  var Picker = function (_React$Component2) {
    function Picker() {
      _classCallCheck(this, Picker);

      return _possibleConstructorReturn(this, _getPrototypeOf(Picker).apply(this, arguments));
    }

    _createClass(Picker, [{
      key: "render",
      value: function render() {
        if (Platform.OS === 'ios') {
          return React.createElement(PickerIOS, _extends({}, this.props, {
            __source: {
              fileName: _jsxFileName,
              lineNumber: 155
            }
          }), this.props.children);
        } else if (Platform.OS === 'android') {
          return React.createElement(PickerAndroid, _extends({}, this.props, {
            __source: {
              fileName: _jsxFileName,
              lineNumber: 159
            }
          }), this.props.children);
        } else {
          return React.createElement(UnimplementedView, {
            __source: {
              fileName: _jsxFileName,
              lineNumber: 162
            }
          });
        }
      }
    }]);

    _inherits(Picker, _React$Component2);

    return Picker;
  }(React.Component);

  Picker.MODE_DIALOG = MODE_DIALOG;
  Picker.MODE_DROPDOWN = MODE_DROPDOWN;
  Picker.Item = PickerItem;
  Picker.defaultProps = {
    mode: MODE_DIALOG
  };
  Picker.propTypes = _objectSpread({}, ViewPropTypes, {
    style: pickerStyleType,
    selectedValue: PropTypes.any,
    onValueChange: PropTypes.func,
    enabled: PropTypes.bool,
    mode: PropTypes.oneOf(['dialog', 'dropdown']),
    itemStyle: itemStylePropType,
    prompt: PropTypes.string,
    testID: PropTypes.string
  });
  Picker = _wrapComponent("Picker")(Picker);
  module.exports = Picker;
},448,[1,11,207,449,450,176,200,212,255,219,240,376,220],"node_modules/react-native/Libraries/Components/Picker/Picker.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _default = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[0], "react")).default;

  var _reactTransformHmrLibIndexJs = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./../../../../react-transform-hmr/lib/index.js")).default;

  var _jsxFileName = "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Components/Picker/PickerIOS.ios.js";

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var _components = {
    PickerIOS: {
      displayName: "PickerIOS"
    }
  };

  var _reactTransformHmrLibIndexJs2 = _reactTransformHmrLibIndexJs({
    filename: "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Components/Picker/PickerIOS.ios.js",
    components: _components,
    locals: [module],
    imports: [_default]
  });

  function _wrapComponent(id) {
    return function (Component) {
      return _reactTransformHmrLibIndexJs2(Component, id);
    };
  }

  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

  var React = _$$_REQUIRE(_dependencyMap[2], 'React');

  var ReactNative = _$$_REQUIRE(_dependencyMap[3], 'ReactNative');

  var StyleSheet = _$$_REQUIRE(_dependencyMap[4], 'StyleSheet');

  var View = _$$_REQUIRE(_dependencyMap[5], 'View');

  var processColor = _$$_REQUIRE(_dependencyMap[6], 'processColor');

  var requireNativeComponent = _$$_REQUIRE(_dependencyMap[7], 'requireNativeComponent');

  var RCTPickerIOS = requireNativeComponent('RCTPicker');

  var PickerIOSItem = function PickerIOSItem(props) {
    return null;
  };

  var PickerIOS = function (_React$Component) {
    function PickerIOS() {
      var _getPrototypeOf2;

      var _temp, _this;

      _classCallCheck(this, PickerIOS);

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

      return _possibleConstructorReturn(_this, (_temp = _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(PickerIOS)).call.apply(_getPrototypeOf2, [this].concat(args))), _this._picker = null, _this.state = {
        selectedIndex: 0,
        items: []
      }, _this._onChange = function (event) {
        if (_this.props.onChange) {
          _this.props.onChange(event);
        }

        if (_this.props.onValueChange) {
          _this.props.onValueChange(event.nativeEvent.newValue, event.nativeEvent.newIndex);
        }

        if (_this._picker && _this.state.selectedIndex !== event.nativeEvent.newIndex) {
          _this._picker.setNativeProps({
            selectedIndex: _this.state.selectedIndex
          });
        }
      }, _temp));
    }

    _createClass(PickerIOS, [{
      key: "render",
      value: function render() {
        var _this2 = this;

        return React.createElement(View, {
          style: this.props.style,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 112
          }
        }, React.createElement(RCTPickerIOS, {
          ref: function ref(picker) {
            _this2._picker = picker;
          },
          style: [styles.pickerIOS, this.props.itemStyle],
          items: this.state.items,
          selectedIndex: this.state.selectedIndex,
          onChange: this._onChange,
          onStartShouldSetResponder: function onStartShouldSetResponder() {
            return true;
          },
          onResponderTerminationRequest: function onResponderTerminationRequest() {
            return false;
          },
          __source: {
            fileName: _jsxFileName,
            lineNumber: 113
          }
        }));
      }
    }], [{
      key: "getDerivedStateFromProps",
      value: function getDerivedStateFromProps(props) {
        var selectedIndex = 0;
        var items = [];
        React.Children.toArray(props.children).forEach(function (child, index) {
          if (child.props.value === props.selectedValue) {
            selectedIndex = index;
          }

          items.push({
            value: child.props.value,
            label: child.props.label,
            textColor: processColor(child.props.color)
          });
        });
        return {
          selectedIndex: selectedIndex,
          items: items
        };
      }
    }]);

    _inherits(PickerIOS, _React$Component);

    return PickerIOS;
  }(React.Component);

  PickerIOS.Item = PickerIOSItem;
  PickerIOS = _wrapComponent("PickerIOS")(PickerIOS);
  var styles = StyleSheet.create({
    pickerIOS: {
      height: 216
    }
  });
  module.exports = PickerIOS;
},449,[1,11,200,261,201,227,221,229],"node_modules/react-native/Libraries/Components/Picker/PickerIOS.ios.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  module.exports = _$$_REQUIRE(_dependencyMap[0], 'UnimplementedView');
},450,[240],"node_modules/react-native/Libraries/Components/Picker/PickerAndroid.ios.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _jsxFileName = "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Components/ProgressViewIOS/ProgressViewIOS.ios.js";

  function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

  function _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 Image = _$$_REQUIRE(_dependencyMap[0], 'Image');

  var NativeMethodsMixin = _$$_REQUIRE(_dependencyMap[1], 'NativeMethodsMixin');

  var React = _$$_REQUIRE(_dependencyMap[2], 'React');

  var ReactNative = _$$_REQUIRE(_dependencyMap[3], 'ReactNative');

  var PropTypes = _$$_REQUIRE(_dependencyMap[4], 'prop-types');

  var StyleSheet = _$$_REQUIRE(_dependencyMap[5], 'StyleSheet');

  var ViewPropTypes = _$$_REQUIRE(_dependencyMap[6], 'ViewPropTypes');

  var createReactClass = _$$_REQUIRE(_dependencyMap[7], 'create-react-class');

  var requireNativeComponent = _$$_REQUIRE(_dependencyMap[8], 'requireNativeComponent');

  var RCTProgressView = requireNativeComponent('RCTProgressView');
  var ProgressViewIOS = createReactClass({
    displayName: 'ProgressViewIOS',
    mixins: [NativeMethodsMixin],
    propTypes: _objectSpread({}, ViewPropTypes, {
      progressViewStyle: PropTypes.oneOf(['default', 'bar']),
      progress: PropTypes.number,
      progressTintColor: PropTypes.string,
      trackTintColor: PropTypes.string,
      progressImage: Image.propTypes.source,
      trackImage: Image.propTypes.source
    }),
    render: function render() {
      return React.createElement(RCTProgressView, _extends({}, this.props, {
        style: [styles.progressView, this.props.style],
        __source: {
          fileName: _jsxFileName,
          lineNumber: 82
        }
      }));
    }
  });
  var styles = StyleSheet.create({
    progressView: {
      height: 2
    }
  });
  module.exports = ProgressViewIOS;
},451,[361,364,200,261,212,201,376,365,229],"node_modules/react-native/Libraries/Components/ProgressViewIOS/ProgressViewIOS.ios.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _default = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[0], "react")).default;

  var _reactTransformHmrLibIndexJs = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./../../../react-transform-hmr/lib/index.js")).default;

  var _jsxFileName = "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Lists/SectionList.js";

  function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  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 _components = {
    SectionList: {
      displayName: "SectionList"
    }
  };

  var _reactTransformHmrLibIndexJs2 = _reactTransformHmrLibIndexJs({
    filename: "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Lists/SectionList.js",
    components: _components,
    locals: [module],
    imports: [_default]
  });

  function _wrapComponent(id) {
    return function (Component) {
      return _reactTransformHmrLibIndexJs2(Component, id);
    };
  }

  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

  var MetroListView = _$$_REQUIRE(_dependencyMap[2], 'MetroListView');

  var Platform = _$$_REQUIRE(_dependencyMap[3], 'Platform');

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

  var ScrollView = _$$_REQUIRE(_dependencyMap[5], 'ScrollView');

  var VirtualizedSectionList = _$$_REQUIRE(_dependencyMap[6], 'VirtualizedSectionList');

  var defaultProps = _objectSpread({}, VirtualizedSectionList.defaultProps, {
    stickySectionHeadersEnabled: Platform.OS === 'ios'
  });

  var SectionList = function (_React$PureComponent) {
    function SectionList() {
      var _getPrototypeOf2;

      var _temp, _this;

      _classCallCheck(this, SectionList);

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

      return _possibleConstructorReturn(_this, (_temp = _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(SectionList)).call.apply(_getPrototypeOf2, [this].concat(args))), _this._captureRef = function (ref) {
        _this._wrapperListRef = ref;
      }, _temp));
    }

    _createClass(SectionList, [{
      key: "scrollToLocation",
      value: function scrollToLocation(params) {
        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() {
        var List = this.props.legacyImplementation ? MetroListView : VirtualizedSectionList;
        return React.createElement(List, _extends({}, this.props, {
          ref: this._captureRef,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 332
          }
        }));
      }
    }]);

    _inherits(SectionList, _React$PureComponent);

    return SectionList;
  }(React.PureComponent);

  SectionList.defaultProps = defaultProps;
  SectionList = _wrapComponent("SectionList")(SectionList);
  module.exports = SectionList;
},452,[1,11,389,176,200,367,453],"node_modules/react-native/Libraries/Lists/SectionList.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _default = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[0], "react")).default;

  var _reactTransformHmrLibIndexJs = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./../../../react-transform-hmr/lib/index.js")).default;

  var _jsxFileName = "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Lists/VirtualizedSectionList.js";

  function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

  function _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; }

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

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

  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }

  var _components = {
    VirtualizedSectionList: {
      displayName: "VirtualizedSectionList"
    },
    ItemWithSeparator: {
      displayName: "ItemWithSeparator"
    }
  };

  var _reactTransformHmrLibIndexJs2 = _reactTransformHmrLibIndexJs({
    filename: "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Lists/VirtualizedSectionList.js",
    components: _components,
    locals: [module],
    imports: [_default]
  });

  function _wrapComponent(id) {
    return function (Component) {
      return _reactTransformHmrLibIndexJs2(Component, id);
    };
  }

  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

  var React = _$$_REQUIRE(_dependencyMap[2], 'React');

  var View = _$$_REQUIRE(_dependencyMap[3], 'View');

  var VirtualizedList = _$$_REQUIRE(_dependencyMap[4], 'VirtualizedList');

  var invariant = _$$_REQUIRE(_dependencyMap[5], 'fbjs/lib/invariant');

  var VirtualizedSectionList = function (_React$PureComponent) {
    _createClass(VirtualizedSectionList, [{
      key: "scrollToLocation",
      value: function scrollToLocation(params) {
        var index = params.itemIndex + 1;

        for (var ii = 0; ii < params.sectionIndex; ii++) {
          index += this.props.sections[ii].data.length + 2;
        }

        var toIndexParams = _objectSpread({}, params, {
          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(_assertThisInitialized(_this))).filter(Boolean),
            changed: changed.map(_this._convertViewable, _assertThisInitialized(_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: 316
            }
          });
        }
      };

      _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.reduce(function (v, section) {
          stickyHeaderIndices.push(v + offset);
          return v + section.data.length + 2;
        }, 0);
        return {
          childProps: _objectSpread({}, props, {
            renderItem: this._renderItem,
            ItemSeparatorComponent: undefined,
            data: props.sections,
            getItemCount: function getItemCount() {
              return itemCount;
            },
            getItem: getItem,
            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: 201
          }
        }));
      }
    }, {
      key: "_subExtractor",
      value: function _subExtractor(index) {
        var itemIndex = index;
        var defaultKeyExtractor = this.props.keyExtractor;

        for (var ii = 0; ii < this.props.sections.length; ii++) {
          var _section2 = this.props.sections[ii];

          var _key = _section2.key || String(ii);

          itemIndex -= 1;

          if (itemIndex >= _section2.data.length + 1) {
            itemIndex -= _section2.data.length + 1;
          } else if (itemIndex === -1) {
            return {
              section: _section2,
              key: _key + ':header',
              index: null,
              header: true,
              trailingSection: this.props.sections[ii + 1]
            };
          } else if (itemIndex === _section2.data.length) {
            return {
              section: _section2,
              key: _key + ':footer',
              index: null,
              header: false,
              trailingSection: this.props.sections[ii + 1]
            };
          } else {
            var _keyExtractor = _section2.keyExtractor || defaultKeyExtractor;

            return {
              section: _section2,
              key: _key + ':' + _keyExtractor(_section2.data[itemIndex], itemIndex),
              index: itemIndex,
              leadingItem: _section2.data[itemIndex - 1],
              leadingSection: this.props.sections[ii - 1],
              trailingItem: _section2.data[itemIndex + 1],
              trailingSection: this.props.sections[ii + 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 === info.section.data.length - 1;

        if (SectionSeparatorComponent && isLastItemInSection) {
          return SectionSeparatorComponent;
        }

        if (ItemSeparatorComponent && !isLastItemInSection && !isLastItemInList) {
          return ItemSeparatorComponent;
        }

        return null;
      }
    }]);

    _inherits(VirtualizedSectionList, _React$PureComponent);

    return VirtualizedSectionList;
  }(React.PureComponent);

  VirtualizedSectionList.defaultProps = _objectSpread({}, VirtualizedList.defaultProps, {
    data: []
  });
  VirtualizedSectionList = _wrapComponent("VirtualizedSectionList")(VirtualizedSectionList);

  var ItemWithSeparator = function (_React$Component) {
    function ItemWithSeparator() {
      var _getPrototypeOf2;

      var _temp, _this2;

      _classCallCheck(this, ItemWithSeparator);

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

      return _possibleConstructorReturn(_this2, (_temp = _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);
          }
        }
      }, _temp));
    }

    _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$props = this.props,
            LeadingSeparatorComponent = _this$props.LeadingSeparatorComponent,
            SeparatorComponent = _this$props.SeparatorComponent,
            item = _this$props.item,
            index = _this$props.index,
            section = _this$props.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: 502
          }
        }));
        var separator = SeparatorComponent && React.createElement(SeparatorComponent, _extends({}, this.state.separatorProps, {
          __source: {
            fileName: _jsxFileName,
            lineNumber: 505
          }
        }));
        return leadingSeparator || separator ? React.createElement(View, {
          __source: {
            fileName: _jsxFileName,
            lineNumber: 508
          }
        }, 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
          })
        };
      }
    }]);

    _inherits(ItemWithSeparator, _React$Component);

    return ItemWithSeparator;
  }(React.Component);

  ItemWithSeparator = _wrapComponent("ItemWithSeparator")(ItemWithSeparator);

  function getItem(sections, index) {
    if (!sections) {
      return null;
    }

    var itemIdx = index - 1;

    for (var ii = 0; ii < sections.length; ii++) {
      if (itemIdx === -1 || itemIdx === sections[ii].data.length) {
        return sections[ii];
      } else if (itemIdx < sections[ii].data.length) {
        return sections[ii].data[itemIdx];
      } else {
        itemIdx -= sections[ii].data.length + 2;
      }
    }

    return null;
  }

  module.exports = VirtualizedSectionList;
},453,[1,11,200,227,397,166],"node_modules/react-native/Libraries/Lists/VirtualizedSectionList.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _jsxFileName = "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Components/SegmentedControlIOS/SegmentedControlIOS.ios.js";

  function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

  function _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 NativeMethodsMixin = _$$_REQUIRE(_dependencyMap[0], 'NativeMethodsMixin');

  var React = _$$_REQUIRE(_dependencyMap[1], 'React');

  var ReactNative = _$$_REQUIRE(_dependencyMap[2], 'ReactNative');

  var PropTypes = _$$_REQUIRE(_dependencyMap[3], 'prop-types');

  var StyleSheet = _$$_REQUIRE(_dependencyMap[4], 'StyleSheet');

  var ViewPropTypes = _$$_REQUIRE(_dependencyMap[5], 'ViewPropTypes');

  var createReactClass = _$$_REQUIRE(_dependencyMap[6], 'create-react-class');

  var requireNativeComponent = _$$_REQUIRE(_dependencyMap[7], 'requireNativeComponent');

  var RCTSegmentedControl = requireNativeComponent('RCTSegmentedControl');
  var SEGMENTED_CONTROL_REFERENCE = 'segmentedcontrol';
  var SegmentedControlIOS = createReactClass({
    displayName: 'SegmentedControlIOS',
    mixins: [NativeMethodsMixin],
    propTypes: _objectSpread({}, ViewPropTypes, {
      values: PropTypes.arrayOf(PropTypes.string),
      selectedIndex: PropTypes.number,
      onValueChange: PropTypes.func,
      onChange: PropTypes.func,
      enabled: PropTypes.bool,
      tintColor: PropTypes.string,
      momentary: PropTypes.bool
    }),
    getDefaultProps: function getDefaultProps() {
      return {
        values: [],
        enabled: true
      };
    },
    _onChange: function _onChange(event) {
      this.props.onChange && this.props.onChange(event);
      this.props.onValueChange && this.props.onValueChange(event.nativeEvent.value);
    },
    render: function render() {
      return React.createElement(RCTSegmentedControl, _extends({}, this.props, {
        ref: SEGMENTED_CONTROL_REFERENCE,
        style: [styles.segmentedControl, this.props.style],
        onChange: this._onChange,
        __source: {
          fileName: _jsxFileName,
          lineNumber: 128
        }
      }));
    }
  });
  var styles = StyleSheet.create({
    segmentedControl: {
      height: 28
    }
  });
  module.exports = SegmentedControlIOS;
},454,[364,200,261,212,201,376,365,229],"node_modules/react-native/Libraries/Components/SegmentedControlIOS/SegmentedControlIOS.ios.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _jsxFileName = "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Components/Slider/Slider.js";

  function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

  var ReactNative = _$$_REQUIRE(_dependencyMap[0], 'ReactNative');

  var Platform = _$$_REQUIRE(_dependencyMap[1], 'Platform');

  var React = _$$_REQUIRE(_dependencyMap[2], 'React');

  var StyleSheet = _$$_REQUIRE(_dependencyMap[3], 'StyleSheet');

  var requireNativeComponent = _$$_REQUIRE(_dependencyMap[4], 'requireNativeComponent');

  var RCTSlider = requireNativeComponent('RCTSlider');

  var Slider = function Slider(props, forwardedRef) {
    var style = StyleSheet.compose(styles.slider, props.style);

    var onValueChange = props.onValueChange && function (event) {
      var userEvent = true;

      if (Platform.OS === 'android') {
        userEvent = event.nativeEvent.fromUser;
      }

      props.onValueChange && userEvent && props.onValueChange(event.nativeEvent.value);
    };

    var onChange = onValueChange;

    var onSlidingComplete = props.onSlidingComplete && function (event) {
      props.onSlidingComplete && props.onSlidingComplete(event.nativeEvent.value);
    };

    return React.createElement(RCTSlider, _extends({}, props, {
      ref: forwardedRef,
      style: style,
      onChange: onChange,
      onSlidingComplete: onSlidingComplete,
      onValueChange: onValueChange,
      enabled: !props.disabled,
      onStartShouldSetResponder: function onStartShouldSetResponder() {
        return true;
      },
      onResponderTerminationRequest: function onResponderTerminationRequest() {
        return false;
      },
      __source: {
        fileName: _jsxFileName,
        lineNumber: 229
      }
    }));
  };

  var SliderWithRef = React.forwardRef(Slider);
  SliderWithRef.defaultProps = {
    disabled: false,
    value: 0,
    minimumValue: 0,
    maximumValue: 1,
    step: 0
  };
  SliderWithRef.displayName = 'Slider';
  var styles;

  if (Platform.OS === 'ios') {
    styles = StyleSheet.create({
      slider: {
        height: 40
      }
    });
  } else {
    styles = StyleSheet.create({
      slider: {}
    });
  }

  module.exports = SliderWithRef;
},455,[261,176,200,201,229],"node_modules/react-native/Libraries/Components/Slider/Slider.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _default = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[0], "react")).default;

  var _reactTransformHmrLibIndexJs = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./../../../react-transform-hmr/lib/index.js")).default;

  var _jsxFileName = "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/RCTTest/SnapshotViewIOS.ios.js";

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

  function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var _components = {
    SnapshotViewIOS: {
      displayName: "SnapshotViewIOS"
    }
  };

  var _reactTransformHmrLibIndexJs2 = _reactTransformHmrLibIndexJs({
    filename: "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/RCTTest/SnapshotViewIOS.ios.js",
    components: _components,
    locals: [module],
    imports: [_default]
  });

  function _wrapComponent(id) {
    return function (Component) {
      return _reactTransformHmrLibIndexJs2(Component, id);
    };
  }

  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

  var React = _$$_REQUIRE(_dependencyMap[2], 'React');

  var PropTypes = _$$_REQUIRE(_dependencyMap[3], 'prop-types');

  var StyleSheet = _$$_REQUIRE(_dependencyMap[4], 'StyleSheet');

  var _require = _$$_REQUIRE(_dependencyMap[5], 'NativeModules'),
      TestModule = _require.TestModule;

  var UIManager = _$$_REQUIRE(_dependencyMap[6], 'UIManager');

  var View = _$$_REQUIRE(_dependencyMap[7], 'View');

  var ViewPropTypes = _$$_REQUIRE(_dependencyMap[8], 'ViewPropTypes');

  var requireNativeComponent = _$$_REQUIRE(_dependencyMap[9], 'requireNativeComponent');

  var RCTSnapshot = UIManager.RCTSnapshot ? requireNativeComponent('RCTSnapshot') : View;

  var SnapshotViewIOS = function (_React$Component) {
    function SnapshotViewIOS() {
      var _getPrototypeOf2;

      var _temp, _this;

      _classCallCheck(this, SnapshotViewIOS);

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

      return _possibleConstructorReturn(_this, (_temp = _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(SnapshotViewIOS)).call.apply(_getPrototypeOf2, [this].concat(args))), _this.onDefaultAction = function (event) {
        TestModule.verifySnapshot(TestModule.markTestPassed);
      }, _temp));
    }

    _createClass(SnapshotViewIOS, [{
      key: "render",
      value: function render() {
        var testIdentifier = this.props.testIdentifier || 'test';
        var onSnapshotReady = this.props.onSnapshotReady || this.onDefaultAction;
        return React.createElement(RCTSnapshot, _extends({
          style: style.snapshot
        }, this.props, {
          onSnapshotReady: onSnapshotReady,
          testIdentifier: testIdentifier,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 53
          }
        }));
      }
    }]);

    _inherits(SnapshotViewIOS, _React$Component);

    return SnapshotViewIOS;
  }(React.Component);

  SnapshotViewIOS.propTypes = _objectSpread({}, ViewPropTypes, {
    onSnapshotReady: PropTypes.func,
    testIdentifier: PropTypes.string
  });
  SnapshotViewIOS = _wrapComponent("SnapshotViewIOS")(SnapshotViewIOS);
  var style = StyleSheet.create({
    snapshot: {
      flex: 1
    }
  });
  module.exports = SnapshotViewIOS;
},456,[1,11,200,212,201,168,218,227,376,229],"node_modules/react-native/Libraries/RCTTest/SnapshotViewIOS.ios.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _default = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[0], "react")).default;

  var _reactTransformHmrLibIndexJs = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./../../../../react-transform-hmr/lib/index.js")).default;

  var _jsxFileName = "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Components/Switch/Switch.js";

  function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

  function _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; }

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var _components = {
    Switch: {
      displayName: "Switch"
    }
  };

  var _reactTransformHmrLibIndexJs2 = _reactTransformHmrLibIndexJs({
    filename: "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Components/Switch/Switch.js",
    components: _components,
    locals: [module],
    imports: [_default]
  });

  function _wrapComponent(id) {
    return function (Component) {
      return _reactTransformHmrLibIndexJs2(Component, id);
    };
  }

  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

  var Platform = _$$_REQUIRE(_dependencyMap[2], 'Platform');

  var React = _$$_REQUIRE(_dependencyMap[3], 'React');

  var ReactNative = _$$_REQUIRE(_dependencyMap[4], 'ReactNative');

  var StyleSheet = _$$_REQUIRE(_dependencyMap[5], 'StyleSheet');

  var nullthrows = _$$_REQUIRE(_dependencyMap[6], 'fbjs/lib/nullthrows');

  var requireNativeComponent = _$$_REQUIRE(_dependencyMap[7], 'requireNativeComponent');

  var RCTSwitch = Platform.OS === 'android' ? requireNativeComponent('AndroidSwitch') : requireNativeComponent('RCTSwitch');

  var Switch = function (_React$Component) {
    function Switch() {
      var _getPrototypeOf2;

      var _temp, _this;

      _classCallCheck(this, Switch);

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

      return _possibleConstructorReturn(_this, (_temp = _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(Switch)).call.apply(_getPrototypeOf2, [this].concat(args))), _this._rctSwitch = null, _this._onChange = function (event) {
        if (Platform.OS === 'android') {
          nullthrows(_this._rctSwitch).setNativeProps({
            on: _this.props.value
          });
        } else {
          nullthrows(_this._rctSwitch).setNativeProps({
            value: _this.props.value
          });
        }

        _this.props.onChange && _this.props.onChange(event);
        _this.props.onValueChange && _this.props.onValueChange(event.nativeEvent.value);
      }, _temp));
    }

    _createClass(Switch, [{
      key: "render",
      value: function render() {
        var _this2 = this;

        var props = _objectSpread({}, this.props, {
          onStartShouldSetResponder: function onStartShouldSetResponder() {
            return true;
          },
          onResponderTerminationRequest: function onResponderTerminationRequest() {
            return false;
          }
        });

        var platformProps = Platform.OS === 'android' ? {
          enabled: !this.props.disabled,
          on: this.props.value,
          style: this.props.style,
          trackTintColor: this.props.value ? this.props.onTintColor : this.props.tintColor
        } : {
          style: StyleSheet.compose(styles.rctSwitchIOS, this.props.style)
        };
        return React.createElement(RCTSwitch, _extends({}, props, platformProps, {
          ref: function ref(_ref) {
            _this2._rctSwitch = _ref;
          },
          onChange: this._onChange,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 144
          }
        }));
      }
    }]);

    _inherits(Switch, _React$Component);

    return Switch;
  }(React.Component);

  Switch.defaultProps = {
    value: false,
    disabled: false
  };
  Switch = _wrapComponent("Switch")(Switch);
  var styles = StyleSheet.create({
    rctSwitchIOS: {
      height: 31,
      width: 51
    }
  });
  module.exports = Switch;
},457,[1,11,176,200,261,201,329,229],"node_modules/react-native/Libraries/Components/Switch/Switch.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _default = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[0], "react")).default;

  var _reactTransformHmrLibIndexJs = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./../../../../react-transform-hmr/lib/index.js")).default;

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

  var _components = {
    StatusBar: {
      displayName: "StatusBar"
    }
  };

  var _reactTransformHmrLibIndexJs2 = _reactTransformHmrLibIndexJs({
    filename: "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Components/StatusBar/StatusBar.js",
    components: _components,
    locals: [module],
    imports: [_default]
  });

  function _wrapComponent(id) {
    return function (Component) {
      return _reactTransformHmrLibIndexJs2(Component, id);
    };
  }

  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

  var React = _$$_REQUIRE(_dependencyMap[2], 'React');

  var PropTypes = _$$_REQUIRE(_dependencyMap[3], 'prop-types');

  var ColorPropType = _$$_REQUIRE(_dependencyMap[4], 'ColorPropType');

  var Platform = _$$_REQUIRE(_dependencyMap[5], 'Platform');

  var processColor = _$$_REQUIRE(_dependencyMap[6], 'processColor');

  var StatusBarManager = _$$_REQUIRE(_dependencyMap[7], 'NativeModules').StatusBarManager;

  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;
    }, _extends({}, 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) {
    function StatusBar() {
      var _getPrototypeOf2;

      var _temp, _this;

      _classCallCheck(this, StatusBar);

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

      return _possibleConstructorReturn(_this, (_temp = _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(StatusBar)).call.apply(_getPrototypeOf2, [this].concat(args))), _this._stackEntry = null, _this._updatePropsStack = function () {
        clearImmediate(StatusBar._updateImmediate);
        StatusBar._updateImmediate = setImmediate(function () {
          var oldProps = StatusBar._currentValues;
          var mergedProps = mergePropsStack(StatusBar._propsStack, StatusBar._defaultProps);

          if (Platform.OS === 'ios') {
            if (!oldProps || oldProps.barStyle.value !== mergedProps.barStyle.value) {
              StatusBarManager.setStyle(mergedProps.barStyle.value, mergedProps.barStyle.animated);
            }

            if (!oldProps || oldProps.hidden.value !== mergedProps.hidden.value) {
              StatusBarManager.setHidden(mergedProps.hidden.value, mergedProps.hidden.animated ? mergedProps.hidden.transition : 'none');
            }

            if (!oldProps || oldProps.networkActivityIndicatorVisible !== mergedProps.networkActivityIndicatorVisible) {
              StatusBarManager.setNetworkActivityIndicatorVisible(mergedProps.networkActivityIndicatorVisible);
            }
          } else if (Platform.OS === 'android') {
            if (!oldProps || oldProps.barStyle.value !== mergedProps.barStyle.value) {
              StatusBarManager.setStyle(mergedProps.barStyle.value);
            }

            if (!oldProps || oldProps.backgroundColor.value !== mergedProps.backgroundColor.value) {
              StatusBarManager.setColor(processColor(mergedProps.backgroundColor.value), mergedProps.backgroundColor.animated);
            }

            if (!oldProps || oldProps.hidden.value !== mergedProps.hidden.value) {
              StatusBarManager.setHidden(mergedProps.hidden.value);
            }

            if (!oldProps || oldProps.translucent !== mergedProps.translucent) {
              StatusBarManager.setTranslucent(mergedProps.translucent);
            }
          }

          StatusBar._currentValues = mergedProps;
        });
      }, _temp));
    }

    _createClass(StatusBar, [{
      key: "componentDidMount",
      value: function componentDidMount() {
        this._stackEntry = createStackEntry(this.props);

        StatusBar._propsStack.push(this._stackEntry);

        this._updatePropsStack();
      }
    }, {
      key: "componentWillUnmount",
      value: function componentWillUnmount() {
        var index = StatusBar._propsStack.indexOf(this._stackEntry);

        StatusBar._propsStack.splice(index, 1);

        this._updatePropsStack();
      }
    }, {
      key: "componentDidUpdate",
      value: function componentDidUpdate() {
        var index = StatusBar._propsStack.indexOf(this._stackEntry);

        this._stackEntry = createStackEntry(this.props);
        StatusBar._propsStack[index] = this._stackEntry;

        this._updatePropsStack();
      }
    }, {
      key: "render",
      value: function render() {
        return null;
      }
    }], [{
      key: "setHidden",
      value: function setHidden(hidden, animation) {
        animation = animation || 'none';
        StatusBar._defaultProps.hidden.value = hidden;

        if (Platform.OS === 'ios') {
          StatusBarManager.setHidden(hidden, animation);
        } else if (Platform.OS === 'android') {
          StatusBarManager.setHidden(hidden);
        }
      }
    }, {
      key: "setBarStyle",
      value: function setBarStyle(style, animated) {
        animated = animated || false;
        StatusBar._defaultProps.barStyle.value = style;

        if (Platform.OS === 'ios') {
          StatusBarManager.setStyle(style, animated);
        } else if (Platform.OS === 'android') {
          StatusBarManager.setStyle(style);
        }
      }
    }, {
      key: "setNetworkActivityIndicatorVisible",
      value: function setNetworkActivityIndicatorVisible(visible) {
        if (Platform.OS !== 'ios') {
          console.warn('`setNetworkActivityIndicatorVisible` is only available on iOS');
          return;
        }

        StatusBar._defaultProps.networkActivityIndicatorVisible = visible;
        StatusBarManager.setNetworkActivityIndicatorVisible(visible);
      }
    }, {
      key: "setBackgroundColor",
      value: function setBackgroundColor(color, animated) {
        if (Platform.OS !== 'android') {
          console.warn('`setBackgroundColor` is only available on Android');
          return;
        }

        animated = animated || false;
        StatusBar._defaultProps.backgroundColor.value = color;
        StatusBarManager.setColor(processColor(color), animated);
      }
    }, {
      key: "setTranslucent",
      value: function setTranslucent(translucent) {
        if (Platform.OS !== 'android') {
          console.warn('`setTranslucent` is only available on Android');
          return;
        }

        StatusBar._defaultProps.translucent = translucent;
        StatusBarManager.setTranslucent(translucent);
      }
    }]);

    _inherits(StatusBar, _React$Component);

    return StatusBar;
  }(React.Component);

  StatusBar._propsStack = [];
  StatusBar._defaultProps = createStackEntry({
    animated: false,
    showHideTransition: 'fade',
    backgroundColor: 'black',
    barStyle: 'default',
    translucent: false,
    hidden: false,
    networkActivityIndicatorVisible: false
  });
  StatusBar._updateImmediate = null;
  StatusBar._currentValues = null;
  StatusBar.currentHeight = StatusBarManager.HEIGHT;
  StatusBar.propTypes = {
    hidden: PropTypes.bool,
    animated: PropTypes.bool,
    backgroundColor: ColorPropType,
    translucent: PropTypes.bool,
    barStyle: PropTypes.oneOf(['default', 'light-content', 'dark-content']),
    networkActivityIndicatorVisible: PropTypes.bool,
    showHideTransition: PropTypes.oneOf(['fade', 'slide'])
  };
  StatusBar.defaultProps = {
    animated: false,
    showHideTransition: 'fade'
  };
  StatusBar = _wrapComponent("StatusBar")(StatusBar);
  module.exports = StatusBar;
},458,[1,11,200,212,207,176,221,168],"node_modules/react-native/Libraries/Components/StatusBar/StatusBar.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _default = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[0], "react")).default;

  var _reactTransformHmrLibIndexJs = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./../../../../react-transform-hmr/lib/index.js")).default;

  var _jsxFileName = "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Experimental/SwipeableRow/SwipeableFlatList.js";

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

  function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var _components = {
    SwipeableFlatList: {
      displayName: "SwipeableFlatList"
    }
  };

  var _reactTransformHmrLibIndexJs2 = _reactTransformHmrLibIndexJs({
    filename: "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Experimental/SwipeableRow/SwipeableFlatList.js",
    components: _components,
    locals: [module],
    imports: [_default]
  });

  function _wrapComponent(id) {
    return function (Component) {
      return _reactTransformHmrLibIndexJs2(Component, id);
    };
  }

  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

  var PropTypes = _$$_REQUIRE(_dependencyMap[2], 'prop-types');

  var React = _$$_REQUIRE(_dependencyMap[3], 'React');

  var SwipeableRow = _$$_REQUIRE(_dependencyMap[4], 'SwipeableRow');

  var FlatList = _$$_REQUIRE(_dependencyMap[5], 'FlatList');

  var SwipeableFlatList = function (_React$Component) {
    function SwipeableFlatList(props, context) {
      var _this;

      _classCallCheck(this, SwipeableFlatList);

      _this = _possibleConstructorReturn(this, _getPrototypeOf(SwipeableFlatList).call(this, props, context));
      _this._flatListRef = null;
      _this._shouldBounceFirstRowOnMount = false;

      _this._onScroll = function (e) {
        if (_this.state.openRowKey) {
          _this.setState({
            openRowKey: null
          });
        }

        _this.props.onScroll && _this.props.onScroll(e);
      };

      _this._renderItem = function (info) {
        var slideoutView = _this.props.renderQuickActions(info);

        var key = _this.props.keyExtractor(info.item, info.index);

        if (!slideoutView) {
          return _this.props.renderItem(info);
        }

        var shouldBounceOnMount = false;

        if (_this._shouldBounceFirstRowOnMount) {
          _this._shouldBounceFirstRowOnMount = false;
          shouldBounceOnMount = true;
        }

        return React.createElement(SwipeableRow, {
          slideoutView: slideoutView,
          isOpen: key === _this.state.openRowKey,
          maxSwipeDistance: _this._getMaxSwipeDistance(info),
          onOpen: function onOpen() {
            return _this._onOpen(key);
          },
          onClose: function onClose() {
            return _this._onClose(key);
          },
          shouldBounceOnMount: shouldBounceOnMount,
          onSwipeEnd: _this._setListViewScrollable,
          onSwipeStart: _this._setListViewNotScrollable,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 134
          }
        }, _this.props.renderItem(info));
      };

      _this._setListViewScrollable = function () {
        _this._setListViewScrollableTo(true);
      };

      _this._setListViewNotScrollable = function () {
        _this._setListViewScrollableTo(false);
      };

      _this.state = {
        openRowKey: null
      };
      _this._shouldBounceFirstRowOnMount = _this.props.bounceFirstRowOnMount;
      return _this;
    }

    _createClass(SwipeableFlatList, [{
      key: "render",
      value: function render() {
        var _this2 = this;

        return React.createElement(FlatList, _extends({}, this.props, {
          ref: function ref(_ref) {
            _this2._flatListRef = _ref;
          },
          onScroll: this._onScroll,
          renderItem: this._renderItem,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 96
          }
        }));
      }
    }, {
      key: "_getMaxSwipeDistance",
      value: function _getMaxSwipeDistance(info) {
        if (typeof this.props.maxSwipeDistance === 'function') {
          return this.props.maxSwipeDistance(info);
        }

        return this.props.maxSwipeDistance;
      }
    }, {
      key: "_setListViewScrollableTo",
      value: function _setListViewScrollableTo(value) {
        if (this._flatListRef) {
          this._flatListRef.setNativeProps({
            scrollEnabled: value
          });
        }
      }
    }, {
      key: "_onOpen",
      value: function _onOpen(key) {
        this.setState({
          openRowKey: key
        });
      }
    }, {
      key: "_onClose",
      value: function _onClose(key) {
        this.setState({
          openRowKey: null
        });
      }
    }]);

    _inherits(SwipeableFlatList, _React$Component);

    return SwipeableFlatList;
  }(React.Component);

  SwipeableFlatList.propTypes = _objectSpread({}, FlatList.propTypes, {
    bounceFirstRowOnMount: PropTypes.bool.isRequired,
    maxSwipeDistance: PropTypes.oneOfType([PropTypes.number, PropTypes.func]).isRequired,
    renderQuickActions: PropTypes.func.isRequired
  });
  SwipeableFlatList.defaultProps = _objectSpread({}, FlatList.defaultProps, {
    bounceFirstRowOnMount: true,
    renderQuickActions: function renderQuickActions() {
      return null;
    }
  });
  SwipeableFlatList = _wrapComponent("SwipeableFlatList")(SwipeableFlatList);
  module.exports = SwipeableFlatList;
},459,[1,11,212,200,460,388],"node_modules/react-native/Libraries/Experimental/SwipeableRow/SwipeableFlatList.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _jsxFileName = "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Experimental/SwipeableRow/SwipeableRow.js";

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

  var Animated = _$$_REQUIRE(_dependencyMap[0], 'Animated');

  var I18nManager = _$$_REQUIRE(_dependencyMap[1], 'I18nManager');

  var PanResponder = _$$_REQUIRE(_dependencyMap[2], 'PanResponder');

  var React = _$$_REQUIRE(_dependencyMap[3], 'React');

  var PropTypes = _$$_REQUIRE(_dependencyMap[4], 'prop-types');

  var StyleSheet = _$$_REQUIRE(_dependencyMap[5], 'StyleSheet');

  var TimerMixin = _$$_REQUIRE(_dependencyMap[6], 'react-timer-mixin');

  var View = _$$_REQUIRE(_dependencyMap[7], 'View');

  var createReactClass = _$$_REQUIRE(_dependencyMap[8], 'create-react-class');

  var emptyFunction = _$$_REQUIRE(_dependencyMap[9], 'fbjs/lib/emptyFunction');

  var IS_RTL = I18nManager.isRTL;
  var CLOSED_LEFT_POSITION = 0;
  var HORIZONTAL_SWIPE_DISTANCE_THRESHOLD = 10;
  var HORIZONTAL_FULL_SWIPE_SPEED_THRESHOLD = 0.3;
  var SLOW_SPEED_SWIPE_FACTOR = 4;
  var SWIPE_DURATION = 300;
  var ON_MOUNT_BOUNCE_DELAY = 700;
  var ON_MOUNT_BOUNCE_DURATION = 400;
  var RIGHT_SWIPE_BOUNCE_BACK_DISTANCE = 30;
  var RIGHT_SWIPE_BOUNCE_BACK_DURATION = 300;
  var RIGHT_SWIPE_THRESHOLD = 30 * SLOW_SPEED_SWIPE_FACTOR;
  var SwipeableRow = createReactClass({
    displayName: 'SwipeableRow',
    _panResponder: {},
    _previousLeft: CLOSED_LEFT_POSITION,
    mixins: [TimerMixin],
    propTypes: {
      children: PropTypes.any,
      isOpen: PropTypes.bool,
      preventSwipeRight: PropTypes.bool,
      maxSwipeDistance: PropTypes.number.isRequired,
      onOpen: PropTypes.func.isRequired,
      onClose: PropTypes.func.isRequired,
      onSwipeEnd: PropTypes.func.isRequired,
      onSwipeStart: PropTypes.func.isRequired,
      shouldBounceOnMount: PropTypes.bool,
      slideoutView: PropTypes.node.isRequired,
      swipeThreshold: PropTypes.number.isRequired
    },
    getInitialState: function getInitialState() {
      return {
        currentLeft: new Animated.Value(this._previousLeft),
        isSwipeableViewRendered: false,
        rowHeight: null
      };
    },
    getDefaultProps: function getDefaultProps() {
      return {
        isOpen: false,
        preventSwipeRight: false,
        maxSwipeDistance: 0,
        onOpen: emptyFunction,
        onClose: emptyFunction,
        onSwipeEnd: emptyFunction,
        onSwipeStart: emptyFunction,
        swipeThreshold: 30
      };
    },
    UNSAFE_componentWillMount: function UNSAFE_componentWillMount() {
      this._panResponder = PanResponder.create({
        onMoveShouldSetPanResponderCapture: this._handleMoveShouldSetPanResponderCapture,
        onPanResponderGrant: this._handlePanResponderGrant,
        onPanResponderMove: this._handlePanResponderMove,
        onPanResponderRelease: this._handlePanResponderEnd,
        onPanResponderTerminationRequest: this._onPanResponderTerminationRequest,
        onPanResponderTerminate: this._handlePanResponderEnd,
        onShouldBlockNativeResponder: function onShouldBlockNativeResponder(event, gestureState) {
          return false;
        }
      });
    },
    componentDidMount: function componentDidMount() {
      var _this = this;

      if (this.props.shouldBounceOnMount) {
        this.setTimeout(function () {
          _this._animateBounceBack(ON_MOUNT_BOUNCE_DURATION);
        }, ON_MOUNT_BOUNCE_DELAY);
      }
    },
    UNSAFE_componentWillReceiveProps: function UNSAFE_componentWillReceiveProps(nextProps) {
      if (this.props.isOpen && !nextProps.isOpen) {
        this._animateToClosedPosition();
      }
    },
    render: function render() {
      var slideOutView;

      if (this.state.isSwipeableViewRendered && this.state.rowHeight) {
        slideOutView = React.createElement(View, {
          style: [styles.slideOutContainer, {
            height: this.state.rowHeight
          }],
          __source: {
            fileName: _jsxFileName,
            lineNumber: 178
          }
        }, this.props.slideoutView);
      }

      var swipeableView = React.createElement(Animated.View, {
        onLayout: this._onSwipeableViewLayout,
        style: {
          transform: [{
            translateX: this.state.currentLeft
          }]
        },
        __source: {
          fileName: _jsxFileName,
          lineNumber: 187
        }
      }, this.props.children);
      return React.createElement(View, _extends({}, this._panResponder.panHandlers, {
        __source: {
          fileName: _jsxFileName,
          lineNumber: 195
        }
      }), slideOutView, swipeableView);
    },
    close: function close() {
      this.props.onClose();

      this._animateToClosedPosition();
    },
    _onSwipeableViewLayout: function _onSwipeableViewLayout(event) {
      this.setState({
        isSwipeableViewRendered: true,
        rowHeight: event.nativeEvent.layout.height
      });
    },
    _handleMoveShouldSetPanResponderCapture: function _handleMoveShouldSetPanResponderCapture(event, gestureState) {
      return gestureState.dy < 10 && this._isValidSwipe(gestureState);
    },
    _handlePanResponderGrant: function _handlePanResponderGrant(event, gestureState) {},
    _handlePanResponderMove: function _handlePanResponderMove(event, gestureState) {
      if (this._isSwipingExcessivelyRightFromClosedPosition(gestureState)) {
        return;
      }

      this.props.onSwipeStart();

      if (this._isSwipingRightFromClosed(gestureState)) {
        this._swipeSlowSpeed(gestureState);
      } else {
        this._swipeFullSpeed(gestureState);
      }
    },
    _isSwipingRightFromClosed: function _isSwipingRightFromClosed(gestureState) {
      var gestureStateDx = IS_RTL ? -gestureState.dx : gestureState.dx;
      return this._previousLeft === CLOSED_LEFT_POSITION && gestureStateDx > 0;
    },
    _swipeFullSpeed: function _swipeFullSpeed(gestureState) {
      this.state.currentLeft.setValue(this._previousLeft + gestureState.dx);
    },
    _swipeSlowSpeed: function _swipeSlowSpeed(gestureState) {
      this.state.currentLeft.setValue(this._previousLeft + gestureState.dx / SLOW_SPEED_SWIPE_FACTOR);
    },
    _isSwipingExcessivelyRightFromClosedPosition: function _isSwipingExcessivelyRightFromClosedPosition(gestureState) {
      var gestureStateDx = IS_RTL ? -gestureState.dx : gestureState.dx;
      return this._isSwipingRightFromClosed(gestureState) && gestureStateDx > RIGHT_SWIPE_THRESHOLD;
    },
    _onPanResponderTerminationRequest: function _onPanResponderTerminationRequest(event, gestureState) {
      return false;
    },
    _animateTo: function _animateTo(toValue) {
      var _this2 = this;

      var duration = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : SWIPE_DURATION;
      var callback = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : emptyFunction;
      Animated.timing(this.state.currentLeft, {
        duration: duration,
        toValue: toValue,
        useNativeDriver: true
      }).start(function () {
        _this2._previousLeft = toValue;
        callback();
      });
    },
    _animateToOpenPosition: function _animateToOpenPosition() {
      var maxSwipeDistance = IS_RTL ? -this.props.maxSwipeDistance : this.props.maxSwipeDistance;

      this._animateTo(-maxSwipeDistance);
    },
    _animateToOpenPositionWith: function _animateToOpenPositionWith(speed, distMoved) {
      speed = speed > HORIZONTAL_FULL_SWIPE_SPEED_THRESHOLD ? speed : HORIZONTAL_FULL_SWIPE_SPEED_THRESHOLD;
      var duration = Math.abs((this.props.maxSwipeDistance - Math.abs(distMoved)) / speed);
      var maxSwipeDistance = IS_RTL ? -this.props.maxSwipeDistance : this.props.maxSwipeDistance;

      this._animateTo(-maxSwipeDistance, duration);
    },
    _animateToClosedPosition: function _animateToClosedPosition() {
      var duration = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : SWIPE_DURATION;

      this._animateTo(CLOSED_LEFT_POSITION, duration);
    },
    _animateToClosedPositionDuringBounce: function _animateToClosedPositionDuringBounce() {
      this._animateToClosedPosition(RIGHT_SWIPE_BOUNCE_BACK_DURATION);
    },
    _animateBounceBack: function _animateBounceBack(duration) {
      var swipeBounceBackDistance = IS_RTL ? -RIGHT_SWIPE_BOUNCE_BACK_DISTANCE : RIGHT_SWIPE_BOUNCE_BACK_DISTANCE;

      this._animateTo(-swipeBounceBackDistance, duration, this._animateToClosedPositionDuringBounce);
    },
    _isValidSwipe: function _isValidSwipe(gestureState) {
      if (this.props.preventSwipeRight && this._previousLeft === CLOSED_LEFT_POSITION && gestureState.dx > 0) {
        return false;
      }

      return Math.abs(gestureState.dx) > HORIZONTAL_SWIPE_DISTANCE_THRESHOLD;
    },
    _shouldAnimateRemainder: function _shouldAnimateRemainder(gestureState) {
      return Math.abs(gestureState.dx) > this.props.swipeThreshold || gestureState.vx > HORIZONTAL_FULL_SWIPE_SPEED_THRESHOLD;
    },
    _handlePanResponderEnd: function _handlePanResponderEnd(event, gestureState) {
      var horizontalDistance = IS_RTL ? -gestureState.dx : gestureState.dx;

      if (this._isSwipingRightFromClosed(gestureState)) {
        this.props.onOpen();

        this._animateBounceBack(RIGHT_SWIPE_BOUNCE_BACK_DURATION);
      } else if (this._shouldAnimateRemainder(gestureState)) {
        if (horizontalDistance < 0) {
          this.props.onOpen();

          this._animateToOpenPositionWith(gestureState.vx, horizontalDistance);
        } else {
          this.props.onClose();

          this._animateToClosedPosition();
        }
      } else {
        if (this._previousLeft === CLOSED_LEFT_POSITION) {
          this._animateToClosedPosition();
        } else {
          this._animateToOpenPosition();
        }
      }

      this.props.onSwipeEnd();
    }
  });

  var TypedSwipeableRow = function (_React$Component) {
    function TypedSwipeableRow() {
      _classCallCheck(this, TypedSwipeableRow);

      return _possibleConstructorReturn(this, _getPrototypeOf(TypedSwipeableRow).apply(this, arguments));
    }

    _createClass(TypedSwipeableRow, [{
      key: "close",
      value: function close() {}
    }]);

    _inherits(TypedSwipeableRow, _React$Component);

    return TypedSwipeableRow;
  }(React.Component);

  var styles = StyleSheet.create({
    slideOutContainer: {
      bottom: 0,
      left: 0,
      position: 'absolute',
      right: 0,
      top: 0
    }
  });
  module.exports = SwipeableRow;
},460,[332,445,461,200,212,201,382,227,365,184],"node_modules/react-native/Libraries/Experimental/SwipeableRow/SwipeableRow.js");
__d(function (global, _$$_REQUIRE, 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()
      };

      PanResponder._initializeGestureState(gestureState);

      var panHandlers = {
        onStartShouldSetResponder: function onStartShouldSetResponder(e) {
          return config.onStartShouldSetPanResponder === undefined ? false : config.onStartShouldSetPanResponder(e, gestureState);
        },
        onMoveShouldSetResponder: function onMoveShouldSetResponder(e) {
          return config.onMoveShouldSetPanResponder === undefined ? false : config.onMoveShouldSetPanResponder(e, gestureState);
        },
        onStartShouldSetResponderCapture: function onStartShouldSetResponderCapture(e) {
          if (e.nativeEvent.touches.length === 1) {
            PanResponder._initializeGestureState(gestureState);
          }

          gestureState.numberActiveTouches = e.touchHistory.numberActiveTouches;
          return config.onStartShouldSetPanResponderCapture !== undefined ? config.onStartShouldSetPanResponderCapture(e, gestureState) : false;
        },
        onMoveShouldSetResponderCapture: function onMoveShouldSetResponderCapture(e) {
          var touchHistory = e.touchHistory;

          if (gestureState._accountsForMovesUpTo === touchHistory.mostRecentTimeStamp) {
            return false;
          }

          PanResponder._updateGestureStateOnMove(gestureState, touchHistory);

          return config.onMoveShouldSetPanResponderCapture ? config.onMoveShouldSetPanResponderCapture(e, gestureState) : false;
        },
        onResponderGrant: function onResponderGrant(e) {
          if (!interactionState.handle) {
            interactionState.handle = InteractionManager.createInteractionHandle();
          }

          gestureState.x0 = currentCentroidX(e.touchHistory);
          gestureState.y0 = currentCentroidY(e.touchHistory);
          gestureState.dx = 0;
          gestureState.dy = 0;

          if (config.onPanResponderGrant) {
            config.onPanResponderGrant(e, gestureState);
          }

          return config.onShouldBlockNativeResponder === undefined ? true : config.onShouldBlockNativeResponder();
        },
        onResponderReject: function onResponderReject(e) {
          clearInteractionHandle(interactionState, config.onPanResponderReject, e, gestureState);
        },
        onResponderRelease: function onResponderRelease(e) {
          clearInteractionHandle(interactionState, config.onPanResponderRelease, e, gestureState);

          PanResponder._initializeGestureState(gestureState);
        },
        onResponderStart: function onResponderStart(e) {
          var touchHistory = e.touchHistory;
          gestureState.numberActiveTouches = touchHistory.numberActiveTouches;

          if (config.onPanResponderStart) {
            config.onPanResponderStart(e, gestureState);
          }
        },
        onResponderMove: function onResponderMove(e) {
          var touchHistory = e.touchHistory;

          if (gestureState._accountsForMovesUpTo === touchHistory.mostRecentTimeStamp) {
            return;
          }

          PanResponder._updateGestureStateOnMove(gestureState, touchHistory);

          if (config.onPanResponderMove) {
            config.onPanResponderMove(e, gestureState);
          }
        },
        onResponderEnd: function onResponderEnd(e) {
          var touchHistory = e.touchHistory;
          gestureState.numberActiveTouches = touchHistory.numberActiveTouches;
          clearInteractionHandle(interactionState, config.onPanResponderEnd, e, gestureState);
        },
        onResponderTerminate: function onResponderTerminate(e) {
          clearInteractionHandle(interactionState, config.onPanResponderTerminate, e, gestureState);

          PanResponder._initializeGestureState(gestureState);
        },
        onResponderTerminationRequest: function onResponderTerminationRequest(e) {
          return config.onPanResponderTerminationRequest === undefined ? true : config.onPanResponderTerminationRequest(e, 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;
},461,[340,462],"node_modules/react-native/Libraries/Interaction/PanResponder.js");
__d(function (global, _$$_REQUIRE, 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;
},462,[],"node_modules/react-native/Libraries/Interaction/TouchHistoryMath.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _default = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[0], "react")).default;

  var _reactTransformHmrLibIndexJs = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./../../../../react-transform-hmr/lib/index.js")).default;

  var _jsxFileName = "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Experimental/SwipeableRow/SwipeableListView.js";

  function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

  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 _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

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

  var _components = {
    SwipeableListView: {
      displayName: "SwipeableListView"
    }
  };

  var _reactTransformHmrLibIndexJs2 = _reactTransformHmrLibIndexJs({
    filename: "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Experimental/SwipeableRow/SwipeableListView.js",
    components: _components,
    locals: [module],
    imports: [_default]
  });

  function _wrapComponent(id) {
    return function (Component) {
      return _reactTransformHmrLibIndexJs2(Component, id);
    };
  }

  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

  var ListView = _$$_REQUIRE(_dependencyMap[2], 'ListView');

  var PropTypes = _$$_REQUIRE(_dependencyMap[3], 'prop-types');

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

  var SwipeableListViewDataSource = _$$_REQUIRE(_dependencyMap[5], 'SwipeableListViewDataSource');

  var SwipeableRow = _$$_REQUIRE(_dependencyMap[6], 'SwipeableRow');

  var SwipeableListView = function (_React$Component) {
    _createClass(SwipeableListView, null, [{
      key: "getNewDataSource",
      value: function getNewDataSource() {
        return new SwipeableListViewDataSource({
          getRowData: function getRowData(data, sectionID, rowID) {
            return data[sectionID][rowID];
          },
          getSectionHeaderData: function getSectionHeaderData(data, sectionID) {
            return data[sectionID];
          },
          rowHasChanged: function rowHasChanged(row1, row2) {
            return row1 !== row2;
          },
          sectionHeaderHasChanged: function sectionHeaderHasChanged(s1, s2) {
            return s1 !== s2;
          }
        });
      }
    }]);

    function SwipeableListView(props, context) {
      var _this;

      _classCallCheck(this, SwipeableListView);

      _this = _possibleConstructorReturn(this, _getPrototypeOf(SwipeableListView).call(this, props, context));
      _this._listViewRef = null;
      _this._shouldBounceFirstRowOnMount = false;

      _this._onScroll = function (e) {
        if (_this.props.dataSource.getOpenRowID()) {
          _this.setState({
            dataSource: _this.state.dataSource.setOpenRowID(null)
          });
        }

        _this.props.onScroll && _this.props.onScroll(e);
      };

      _this._renderRow = function (rowData, sectionID, rowID) {
        var slideoutView = _this.props.renderQuickActions(rowData, sectionID, rowID);

        if (!slideoutView) {
          return _this.props.renderRow(rowData, sectionID, rowID);
        }

        var shouldBounceOnMount = false;

        if (_this._shouldBounceFirstRowOnMount) {
          _this._shouldBounceFirstRowOnMount = false;
          shouldBounceOnMount = rowID === _this.props.dataSource.getFirstRowID();
        }

        return React.createElement(SwipeableRow, {
          slideoutView: slideoutView,
          isOpen: rowData.id === _this.props.dataSource.getOpenRowID(),
          maxSwipeDistance: _this._getMaxSwipeDistance(rowData, sectionID, rowID),
          key: rowID,
          onOpen: function onOpen() {
            return _this._onOpen(rowData.id);
          },
          onClose: function onClose() {
            return _this._onClose(rowData.id);
          },
          onSwipeEnd: function onSwipeEnd() {
            return _this._setListViewScrollable(true);
          },
          onSwipeStart: function onSwipeStart() {
            return _this._setListViewScrollable(false);
          },
          shouldBounceOnMount: shouldBounceOnMount,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 213
          }
        }, _this.props.renderRow(rowData, sectionID, rowID));
      };

      _this._shouldBounceFirstRowOnMount = _this.props.bounceFirstRowOnMount;
      _this.state = {
        dataSource: _this.props.dataSource
      };
      return _this;
    }

    _createClass(SwipeableListView, [{
      key: "UNSAFE_componentWillReceiveProps",
      value: function UNSAFE_componentWillReceiveProps(nextProps) {
        if (this.state.dataSource.getDataSource() !== nextProps.dataSource.getDataSource()) {
          this.setState({
            dataSource: nextProps.dataSource
          });
        }
      }
    }, {
      key: "render",
      value: function render() {
        var _this2 = this;

        return React.createElement(ListView, _extends({}, this.props, {
          ref: function ref(_ref) {
            _this2._listViewRef = _ref;
          },
          dataSource: this.state.dataSource.getDataSource(),
          onScroll: this._onScroll,
          renderRow: this._renderRow,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 121
          }
        }));
      }
    }, {
      key: "_setListViewScrollable",
      value: function _setListViewScrollable(value) {
        if (this._listViewRef && typeof this._listViewRef.setNativeProps === 'function') {
          this._listViewRef.setNativeProps({
            scrollEnabled: value
          });
        }
      }
    }, {
      key: "getScrollResponder",
      value: function getScrollResponder() {
        if (this._listViewRef && typeof this._listViewRef.getScrollResponder === 'function') {
          return this._listViewRef.getScrollResponder();
        }
      }
    }, {
      key: "_getMaxSwipeDistance",
      value: function _getMaxSwipeDistance(rowData, sectionID, rowID) {
        if (typeof this.props.maxSwipeDistance === 'function') {
          return this.props.maxSwipeDistance(rowData, sectionID, rowID);
        }

        return this.props.maxSwipeDistance;
      }
    }, {
      key: "_onOpen",
      value: function _onOpen(rowID) {
        this.setState({
          dataSource: this.state.dataSource.setOpenRowID(rowID)
        });
      }
    }, {
      key: "_onClose",
      value: function _onClose(rowID) {
        this.setState({
          dataSource: this.state.dataSource.setOpenRowID(null)
        });
      }
    }]);

    _inherits(SwipeableListView, _React$Component);

    return SwipeableListView;
  }(React.Component);

  SwipeableListView.propTypes = {
    bounceFirstRowOnMount: PropTypes.bool.isRequired,
    dataSource: PropTypes.instanceOf(SwipeableListViewDataSource).isRequired,
    maxSwipeDistance: PropTypes.oneOfType([PropTypes.number, PropTypes.func]).isRequired,
    renderRow: PropTypes.func.isRequired,
    renderQuickActions: PropTypes.func.isRequired
  };
  SwipeableListView.defaultProps = {
    bounceFirstRowOnMount: false,
    renderQuickActions: function renderQuickActions() {
      return null;
    }
  };
  SwipeableListView = _wrapComponent("SwipeableListView")(SwipeableListView);
  module.exports = SwipeableListView;
},463,[1,11,390,212,200,464,460],"node_modules/react-native/Libraries/Experimental/SwipeableRow/SwipeableListView.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  var ListViewDataSource = _$$_REQUIRE(_dependencyMap[0], 'ListViewDataSource');

  var SwipeableListViewDataSource = function () {
    function SwipeableListViewDataSource(params) {
      var _this = this;

      _classCallCheck(this, SwipeableListViewDataSource);

      this._dataSource = new ListViewDataSource({
        getRowData: params.getRowData,
        getSectionHeaderData: params.getSectionHeaderData,
        rowHasChanged: function rowHasChanged(row1, row2) {
          return row1.id !== _this._previousOpenRowID && row2.id === _this._openRowID || row1.id === _this._previousOpenRowID && row2.id !== _this._openRowID || params.rowHasChanged(row1, row2);
        },
        sectionHeaderHasChanged: params.sectionHeaderHasChanged
      });
    }

    _createClass(SwipeableListViewDataSource, [{
      key: "cloneWithRowsAndSections",
      value: function cloneWithRowsAndSections(dataBlob, sectionIdentities, rowIdentities) {
        this._dataSource = this._dataSource.cloneWithRowsAndSections(dataBlob, sectionIdentities, rowIdentities);
        this._dataBlob = dataBlob;
        this.rowIdentities = this._dataSource.rowIdentities;
        this.sectionIdentities = this._dataSource.sectionIdentities;
        return this;
      }
    }, {
      key: "getDataSource",
      value: function getDataSource() {
        return this._dataSource;
      }
    }, {
      key: "getOpenRowID",
      value: function getOpenRowID() {
        return this._openRowID;
      }
    }, {
      key: "getFirstRowID",
      value: function getFirstRowID() {
        if (this.rowIdentities) {
          return this.rowIdentities[0] && this.rowIdentities[0][0];
        }

        return Object.keys(this._dataBlob)[0];
      }
    }, {
      key: "getLastRowID",
      value: function getLastRowID() {
        if (this.rowIdentities && this.rowIdentities.length) {
          var lastSection = this.rowIdentities[this.rowIdentities.length - 1];

          if (lastSection && lastSection.length) {
            return lastSection[lastSection.length - 1];
          }
        }

        return Object.keys(this._dataBlob)[this._dataBlob.length - 1];
      }
    }, {
      key: "setOpenRowID",
      value: function setOpenRowID(rowID) {
        this._previousOpenRowID = this._openRowID;
        this._openRowID = rowID;
        this._dataSource = this._dataSource.cloneWithRowsAndSections(this._dataBlob, this.sectionIdentities, this.rowIdentities);
        return this;
      }
    }]);

    return SwipeableListViewDataSource;
  }();

  module.exports = SwipeableListViewDataSource;
},464,[392],"node_modules/react-native/Libraries/Experimental/SwipeableRow/SwipeableListViewDataSource.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _default = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[0], "react")).default;

  var _reactTransformHmrLibIndexJs = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./../../../../react-transform-hmr/lib/index.js")).default;

  var _jsxFileName = "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Components/TabBarIOS/TabBarIOS.ios.js";

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

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var _components = {
    TabBarIOS: {
      displayName: "TabBarIOS"
    }
  };

  var _reactTransformHmrLibIndexJs2 = _reactTransformHmrLibIndexJs({
    filename: "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Components/TabBarIOS/TabBarIOS.ios.js",
    components: _components,
    locals: [module],
    imports: [_default]
  });

  function _wrapComponent(id) {
    return function (Component) {
      return _reactTransformHmrLibIndexJs2(Component, id);
    };
  }

  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

  var ColorPropType = _$$_REQUIRE(_dependencyMap[2], 'ColorPropType');

  var React = _$$_REQUIRE(_dependencyMap[3], 'React');

  var PropTypes = _$$_REQUIRE(_dependencyMap[4], 'prop-types');

  var StyleSheet = _$$_REQUIRE(_dependencyMap[5], 'StyleSheet');

  var TabBarItemIOS = _$$_REQUIRE(_dependencyMap[6], 'TabBarItemIOS');

  var ViewPropTypes = _$$_REQUIRE(_dependencyMap[7], 'ViewPropTypes');

  var requireNativeComponent = _$$_REQUIRE(_dependencyMap[8], 'requireNativeComponent');

  var RCTTabBar = requireNativeComponent('RCTTabBar');

  var TabBarIOS = function (_React$Component) {
    function TabBarIOS() {
      _classCallCheck(this, TabBarIOS);

      return _possibleConstructorReturn(this, _getPrototypeOf(TabBarIOS).apply(this, arguments));
    }

    _createClass(TabBarIOS, [{
      key: "render",
      value: function render() {
        return React.createElement(RCTTabBar, {
          style: [styles.tabGroup, this.props.style],
          unselectedTintColor: this.props.unselectedTintColor,
          unselectedItemTintColor: this.props.unselectedItemTintColor,
          tintColor: this.props.tintColor,
          barTintColor: this.props.barTintColor,
          barStyle: this.props.barStyle,
          itemPositioning: this.props.itemPositioning,
          translucent: this.props.translucent !== false,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 86
          }
        }, this.props.children);
      }
    }]);

    _inherits(TabBarIOS, _React$Component);

    return TabBarIOS;
  }(React.Component);

  TabBarIOS.Item = TabBarItemIOS;
  TabBarIOS.propTypes = _objectSpread({}, ViewPropTypes, {
    style: ViewPropTypes.style,
    unselectedTintColor: ColorPropType,
    tintColor: ColorPropType,
    unselectedItemTintColor: ColorPropType,
    barTintColor: ColorPropType,
    barStyle: PropTypes.oneOf(['default', 'black']),
    translucent: PropTypes.bool,
    itemPositioning: PropTypes.oneOf(['fill', 'center', 'auto'])
  });
  TabBarIOS = _wrapComponent("TabBarIOS")(TabBarIOS);
  var styles = StyleSheet.create({
    tabGroup: {
      flex: 1
    }
  });
  module.exports = TabBarIOS;
},465,[1,11,207,200,212,201,466,376,229],"node_modules/react-native/Libraries/Components/TabBarIOS/TabBarIOS.ios.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _default = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[0], "react")).default;

  var _reactTransformHmrLibIndexJs = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./../../../../react-transform-hmr/lib/index.js")).default;

  var _jsxFileName = "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Components/TabBarIOS/TabBarItemIOS.ios.js";

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

  function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

  function _objectWithoutProperties(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]; } 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; }

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var _components = {
    TabBarItemIOS: {
      displayName: "TabBarItemIOS"
    }
  };

  var _reactTransformHmrLibIndexJs2 = _reactTransformHmrLibIndexJs({
    filename: "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Components/TabBarIOS/TabBarItemIOS.ios.js",
    components: _components,
    locals: [module],
    imports: [_default]
  });

  function _wrapComponent(id) {
    return function (Component) {
      return _reactTransformHmrLibIndexJs2(Component, id);
    };
  }

  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

  var ColorPropType = _$$_REQUIRE(_dependencyMap[2], 'ColorPropType');

  var Image = _$$_REQUIRE(_dependencyMap[3], 'Image');

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

  var PropTypes = _$$_REQUIRE(_dependencyMap[5], 'prop-types');

  var StaticContainer = _$$_REQUIRE(_dependencyMap[6], 'StaticContainer.react');

  var StyleSheet = _$$_REQUIRE(_dependencyMap[7], 'StyleSheet');

  var View = _$$_REQUIRE(_dependencyMap[8], 'View');

  var ViewPropTypes = _$$_REQUIRE(_dependencyMap[9], 'ViewPropTypes');

  var requireNativeComponent = _$$_REQUIRE(_dependencyMap[10], 'requireNativeComponent');

  var TabBarItemIOS = function (_React$Component) {
    function TabBarItemIOS() {
      var _getPrototypeOf2;

      var _temp, _this;

      _classCallCheck(this, TabBarItemIOS);

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

      return _possibleConstructorReturn(_this, (_temp = _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(TabBarItemIOS)).call.apply(_getPrototypeOf2, [this].concat(args))), _this.state = {
        hasBeenSelected: false
      }, _temp));
    }

    _createClass(TabBarItemIOS, [{
      key: "UNSAFE_componentWillMount",
      value: function UNSAFE_componentWillMount() {
        if (this.props.selected) {
          this.setState({
            hasBeenSelected: true
          });
        }
      }
    }, {
      key: "UNSAFE_componentWillReceiveProps",
      value: function UNSAFE_componentWillReceiveProps(nextProps) {
        if (this.state.hasBeenSelected || nextProps.selected) {
          this.setState({
            hasBeenSelected: true
          });
        }
      }
    }, {
      key: "render",
      value: function render() {
        var _this$props = this.props,
            style = _this$props.style,
            children = _this$props.children,
            props = _objectWithoutProperties(_this$props, ["style", "children"]);

        if (this.state.hasBeenSelected) {
          var tabContents = React.createElement(StaticContainer, {
            shouldUpdate: this.props.selected,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 120
            }
          }, children);
        } else {
          var tabContents = React.createElement(View, {
            __source: {
              fileName: _jsxFileName,
              lineNumber: 125
            }
          });
        }

        return React.createElement(RCTTabBarItem, _extends({}, props, {
          style: [styles.tab, style],
          __source: {
            fileName: _jsxFileName,
            lineNumber: 129
          }
        }), tabContents);
      }
    }]);

    _inherits(TabBarItemIOS, _React$Component);

    return TabBarItemIOS;
  }(React.Component);

  TabBarItemIOS.propTypes = _objectSpread({}, ViewPropTypes, {
    badge: PropTypes.oneOfType([PropTypes.string, PropTypes.number]),
    badgeColor: ColorPropType,
    systemIcon: PropTypes.oneOf(['bookmarks', 'contacts', 'downloads', 'favorites', 'featured', 'history', 'more', 'most-recent', 'most-viewed', 'recents', 'search', 'top-rated']),
    icon: Image.propTypes.source,
    selectedIcon: Image.propTypes.source,
    onPress: PropTypes.func,
    renderAsOriginal: PropTypes.bool,
    selected: PropTypes.bool,
    style: ViewPropTypes.style,
    title: PropTypes.string,
    isTVSelectable: PropTypes.bool
  });
  TabBarItemIOS = _wrapComponent("TabBarItemIOS")(TabBarItemIOS);
  var styles = StyleSheet.create({
    tab: {
      position: 'absolute',
      top: 0,
      right: 0,
      bottom: 0,
      left: 0
    }
  });
  var RCTTabBarItem = requireNativeComponent('RCTTabBarItem');
  module.exports = TabBarItemIOS;
},466,[1,11,207,361,200,212,447,201,227,376,229],"node_modules/react-native/Libraries/Components/TabBarIOS/TabBarItemIOS.ios.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _jsxFileName = "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Components/TextInput/TextInput.js";

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

  function _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 ColorPropType = _$$_REQUIRE(_dependencyMap[0], 'ColorPropType');

  var DocumentSelectionState = _$$_REQUIRE(_dependencyMap[1], 'DocumentSelectionState');

  var EventEmitter = _$$_REQUIRE(_dependencyMap[2], 'EventEmitter');

  var NativeMethodsMixin = _$$_REQUIRE(_dependencyMap[3], 'NativeMethodsMixin');

  var Platform = _$$_REQUIRE(_dependencyMap[4], 'Platform');

  var React = _$$_REQUIRE(_dependencyMap[5], 'React');

  var createReactClass = _$$_REQUIRE(_dependencyMap[6], 'create-react-class');

  var PropTypes = _$$_REQUIRE(_dependencyMap[7], 'prop-types');

  var ReactNative = _$$_REQUIRE(_dependencyMap[8], 'ReactNative');

  var StyleSheet = _$$_REQUIRE(_dependencyMap[9], 'StyleSheet');

  var Text = _$$_REQUIRE(_dependencyMap[10], 'Text');

  var TextAncestor = _$$_REQUIRE(_dependencyMap[11], 'TextAncestor');

  var TextInputState = _$$_REQUIRE(_dependencyMap[12], 'TextInputState');

  var TimerMixin = _$$_REQUIRE(_dependencyMap[13], 'react-timer-mixin');

  var TouchableWithoutFeedback = _$$_REQUIRE(_dependencyMap[14], 'TouchableWithoutFeedback');

  var UIManager = _$$_REQUIRE(_dependencyMap[15], 'UIManager');

  var ViewPropTypes = _$$_REQUIRE(_dependencyMap[16], 'ViewPropTypes');

  var emptyFunction = _$$_REQUIRE(_dependencyMap[17], 'fbjs/lib/emptyFunction');

  var invariant = _$$_REQUIRE(_dependencyMap[18], 'fbjs/lib/invariant');

  var requireNativeComponent = _$$_REQUIRE(_dependencyMap[19], 'requireNativeComponent');

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

  var AndroidTextInput;
  var RCTMultilineTextInputView;
  var RCTSinglelineTextInputView;

  if (Platform.OS === 'android') {
    AndroidTextInput = requireNativeComponent('AndroidTextInput');
  } else if (Platform.OS === 'ios') {
    RCTMultilineTextInputView = requireNativeComponent('RCTMultilineTextInputView');
    RCTSinglelineTextInputView = requireNativeComponent('RCTSinglelineTextInputView');
  }

  var onlyMultiline = {
    onTextInput: true,
    children: true
  };
  var DataDetectorTypes = ['phoneNumber', 'link', 'address', 'calendarEvent', 'none', 'all'];
  var TextInput = createReactClass({
    displayName: 'TextInput',
    statics: {
      State: {
        currentlyFocusedField: TextInputState.currentlyFocusedField,
        focusTextInput: function focusTextInput(textFieldID) {
          console.warn('`focusTextInput` is deprecated, use the `focus` method of the `TextInput` ref instead.');
          TextInputState.focusTextInput(textFieldID);
        },
        blurTextInput: function blurTextInput(textFieldID) {
          console.warn('`blurTextInput` is deprecated, use `Keyboard.dismiss` or the `blur` method of the `TextInput` ref.');
          TextInputState.blurTextInput(textFieldID);
        }
      }
    },
    propTypes: _objectSpread({}, ViewPropTypes, {
      autoCapitalize: PropTypes.oneOf(['none', 'sentences', 'words', 'characters']),
      autoCorrect: PropTypes.bool,
      spellCheck: PropTypes.bool,
      autoFocus: PropTypes.bool,
      allowFontScaling: PropTypes.bool,
      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: ColorPropType,
      secureTextEntry: PropTypes.bool,
      selectionColor: ColorPropType,
      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: ColorPropType,
      inlineImageLeft: PropTypes.string,
      inlineImagePadding: PropTypes.number,
      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'])
    }),
    getDefaultProps: function getDefaultProps() {
      return {
        allowFontScaling: true,
        underlineColorAndroid: 'transparent'
      };
    },
    mixins: [NativeMethodsMixin, TimerMixin],
    isFocused: function isFocused() {
      return TextInputState.currentlyFocusedField() === ReactNative.findNodeHandle(this._inputRef);
    },
    _inputRef: undefined,
    _focusSubscription: undefined,
    _lastNativeText: undefined,
    _lastNativeSelection: undefined,
    componentDidMount: function componentDidMount() {
      var _this = this;

      this._lastNativeText = this.props.value;
      var tag = ReactNative.findNodeHandle(this._inputRef);

      if (tag != null) {
        TextInputState.registerInput(tag);
      }

      if (this.context.focusEmitter) {
        this._focusSubscription = this.context.focusEmitter.addListener('focus', function (el) {
          if (_this === el) {
            _this.requestAnimationFrame(_this.focus);
          } else if (_this.isFocused()) {
            _this.blur();
          }
        });

        if (this.props.autoFocus) {
          this.context.onFocusRequested(this);
        }
      } else {
        if (this.props.autoFocus) {
          this.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);
      }
    },
    contextTypes: {
      onFocusRequested: PropTypes.func,
      focusEmitter: PropTypes.instanceOf(EventEmitter)
    },
    clear: function clear() {
      this.setNativeProps({
        text: ''
      });
    },
    render: function render() {
      var textInput;

      if (Platform.OS === 'ios') {
        textInput = UIManager.RCTVirtualText ? this._renderIOS() : this._renderIOSLegacy();
      } else if (Platform.OS === 'android') {
        textInput = this._renderAndroid();
      }

      return React.createElement(TextAncestor.Provider, {
        value: true,
        __source: {
          fileName: _jsxFileName,
          lineNumber: 875
        }
      }, 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: emptyFunction.thatReturnsTrue,
          text: this._getText(),
          __source: {
            fileName: _jsxFileName,
            lineNumber: 918
          }
        }));
      } 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,
            __source: {
              fileName: _jsxFileName,
              lineNumber: 939
            }
          }, 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: emptyFunction.thatReturnsTrue,
          text: this._getText(),
          dataDetectorTypes: this.props.dataDetectorTypes,
          onScroll: this._onScroll,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 949
          }
        }));
      }

      return React.createElement(TouchableWithoutFeedback, {
        onLayout: props.onLayout,
        onPress: this._onPress,
        rejectResponderTermination: true,
        accessible: props.accessible,
        accessibilityLabel: props.accessibilityLabel,
        accessibilityTraits: props.accessibilityTraits,
        nativeID: this.props.nativeID,
        testID: props.testID,
        __source: {
          fileName: _jsxFileName,
          lineNumber: 968
        }
      }, 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: emptyFunction.thatReturnsTrue,
        text: this._getText(),
        dataDetectorTypes: this.props.dataDetectorTypes,
        onScroll: this._onScroll,
        __source: {
          fileName: _jsxFileName,
          lineNumber: 1002
        }
      }));
      return React.createElement(TouchableWithoutFeedback, {
        onLayout: props.onLayout,
        onPress: this._onPress,
        rejectResponderTermination: true,
        accessible: props.accessible,
        accessibilityLabel: props.accessibilityLabel,
        accessibilityTraits: props.accessibilityTraits,
        nativeID: this.props.nativeID,
        testID: props.testID,
        __source: {
          fileName: _jsxFileName,
          lineNumber: 1019
        }
      }, textContainer);
    },
    _renderAndroid: function _renderAndroid() {
      var props = _extends({}, this.props);

      props.style = [this.props.style];
      props.autoCapitalize = UIManager.AndroidTextInput.Constants.AutoCapitalizationType[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: 1051
          }
        }, 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: 1062
        }
      }));
      return React.createElement(TouchableWithoutFeedback, {
        onLayout: props.onLayout,
        onPress: this._onPress,
        accessible: this.props.accessible,
        accessibilityLabel: this.props.accessibilityLabel,
        accessibilityComponentType: this.props.accessibilityComponentType,
        nativeID: this.props.nativeID,
        testID: this.props.testID,
        __source: {
          fileName: _jsxFileName,
          lineNumber: 1080
        }
      }, 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({
          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(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) {
    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() {}
    }]);

    _inherits(InternalTextInputType, _ReactNative$NativeCo);

    return InternalTextInputType;
  }(ReactNative.NativeComponent);

  var TypedTextInput = TextInput;
  var styles = StyleSheet.create({
    multilineInput: {
      paddingTop: 5
    }
  });
  module.exports = TypedTextInput;
},467,[207,468,195,364,176,200,365,212,261,201,252,228,325,382,383,218,376,184,166,229,183],"node_modules/react-native/Libraries/Components/TextInput/TextInput.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  var mixInEventEmitter = _$$_REQUIRE(_dependencyMap[0], '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;
},468,[469],"node_modules/react-native/Libraries/vendor/document/selection/DocumentSelectionState.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

  var EventEmitter = _$$_REQUIRE(_dependencyMap[0], 'EventEmitter');

  var EventEmitterWithHolding = _$$_REQUIRE(_dependencyMap[1], 'EventEmitterWithHolding');

  var EventHolder = _$$_REQUIRE(_dependencyMap[2], 'EventHolder');

  var invariant = _$$_REQUIRE(_dependencyMap[3], 'fbjs/lib/invariant');

  var keyOf = _$$_REQUIRE(_dependencyMap[4], '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[5], 'EventValidator');

          emitter = EventValidator.addValidation(emitter, this.__types);
        }

        var holder = new EventHolder();
        this.__eventEmitter = new EventEmitterWithHolding(emitter, holder);
      }

      return this.__eventEmitter;
    }
  };
  module.exports = mixInEventEmitter;
},469,[195,470,471,166,472,473],"node_modules/react-native/Libraries/vendor/emitter/mixInEventEmitter.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  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;
},470,[],"node_modules/react-native/Libraries/vendor/emitter/EventEmitterWithHolding.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  var invariant = _$$_REQUIRE(_dependencyMap[0], 'fbjs/lib/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;
},471,[166],"node_modules/react-native/Libraries/vendor/emitter/EventHolder.js");
__d(function (global, _$$_REQUIRE, 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;
},472,[],"node_modules/react-native/node_modules/fbjs/lib/keyOf.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

  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;
},473,[],"node_modules/react-native/Libraries/vendor/emitter/EventValidator.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

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

  var ToastAndroid = {
    show: function show(message, duration) {
      warning(false, 'ToastAndroid is not supported on this platform.');
    }
  };
  module.exports = ToastAndroid;
},474,[183],"node_modules/react-native/Libraries/Components/ToastAndroid/ToastAndroid.ios.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  module.exports = _$$_REQUIRE(_dependencyMap[0], 'UnimplementedView');
},475,[240],"node_modules/react-native/Libraries/Components/ToolbarAndroid/ToolbarAndroid.ios.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  module.exports = _$$_REQUIRE(_dependencyMap[0], 'UnimplementedView');
},476,[240],"node_modules/react-native/Libraries/Components/ViewPager/ViewPagerAndroid.ios.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _default = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[0], "react")).default;

  var _reactTransformHmrLibIndexJs = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./../../../../react-transform-hmr/lib/index.js")).default;

  var _jsxFileName = "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Components/WebView/WebView.ios.js";

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

  function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var _components = {
    WebView: {
      displayName: "WebView"
    }
  };

  var _reactTransformHmrLibIndexJs2 = _reactTransformHmrLibIndexJs({
    filename: "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/Components/WebView/WebView.ios.js",
    components: _components,
    locals: [module],
    imports: [_default]
  });

  function _wrapComponent(id) {
    return function (Component) {
      return _reactTransformHmrLibIndexJs2(Component, id);
    };
  }

  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

  var ActivityIndicator = _$$_REQUIRE(_dependencyMap[2], 'ActivityIndicator');

  var EdgeInsetsPropType = _$$_REQUIRE(_dependencyMap[3], 'EdgeInsetsPropType');

  var Linking = _$$_REQUIRE(_dependencyMap[4], 'Linking');

  var PropTypes = _$$_REQUIRE(_dependencyMap[5], 'prop-types');

  var React = _$$_REQUIRE(_dependencyMap[6], 'React');

  var ReactNative = _$$_REQUIRE(_dependencyMap[7], 'ReactNative');

  var ScrollView = _$$_REQUIRE(_dependencyMap[8], 'ScrollView');

  var StyleSheet = _$$_REQUIRE(_dependencyMap[9], 'StyleSheet');

  var Text = _$$_REQUIRE(_dependencyMap[10], 'Text');

  var UIManager = _$$_REQUIRE(_dependencyMap[11], 'UIManager');

  var View = _$$_REQUIRE(_dependencyMap[12], 'View');

  var ViewPropTypes = _$$_REQUIRE(_dependencyMap[13], 'ViewPropTypes');

  var WebViewShared = _$$_REQUIRE(_dependencyMap[14], 'WebViewShared');

  var deprecatedPropType = _$$_REQUIRE(_dependencyMap[15], 'deprecatedPropType');

  var invariant = _$$_REQUIRE(_dependencyMap[16], 'fbjs/lib/invariant');

  var keyMirror = _$$_REQUIRE(_dependencyMap[17], 'fbjs/lib/keyMirror');

  var processDecelerationRate = _$$_REQUIRE(_dependencyMap[18], 'processDecelerationRate');

  var requireNativeComponent = _$$_REQUIRE(_dependencyMap[19], 'requireNativeComponent');

  var resolveAssetSource = _$$_REQUIRE(_dependencyMap[20], 'resolveAssetSource');

  var RCTWebViewManager = _$$_REQUIRE(_dependencyMap[21], 'NativeModules').WebViewManager;

  var BGWASH = 'rgba(255,255,255,0.8)';
  var RCT_WEBVIEW_REF = 'webview';
  var WebViewState = keyMirror({
    IDLE: null,
    LOADING: null,
    ERROR: null
  });
  var NavigationType = keyMirror({
    click: true,
    formsubmit: true,
    backforward: true,
    reload: true,
    formresubmit: true,
    other: true
  });
  var JSNavigationScheme = 'react-js-navigation';
  var DataDetectorTypes = ['phoneNumber', 'link', 'address', 'calendarEvent', 'none', 'all'];

  var defaultRenderLoading = function defaultRenderLoading() {
    return React.createElement(View, {
      style: styles.loadingView,
      __source: {
        fileName: _jsxFileName,
        lineNumber: 74
      }
    }, React.createElement(ActivityIndicator, {
      __source: {
        fileName: _jsxFileName,
        lineNumber: 75
      }
    }));
  };

  var defaultRenderError = function defaultRenderError(errorDomain, errorCode, errorDesc) {
    return React.createElement(View, {
      style: styles.errorContainer,
      __source: {
        fileName: _jsxFileName,
        lineNumber: 79
      }
    }, React.createElement(Text, {
      style: styles.errorTextTitle,
      __source: {
        fileName: _jsxFileName,
        lineNumber: 80
      }
    }, "Error loading page"), React.createElement(Text, {
      style: styles.errorText,
      __source: {
        fileName: _jsxFileName,
        lineNumber: 81
      }
    }, 'Domain: ' + errorDomain), React.createElement(Text, {
      style: styles.errorText,
      __source: {
        fileName: _jsxFileName,
        lineNumber: 82
      }
    }, 'Error Code: ' + errorCode), React.createElement(Text, {
      style: styles.errorText,
      __source: {
        fileName: _jsxFileName,
        lineNumber: 83
      }
    }, 'Description: ' + errorDesc));
  };

  var WebView = function (_React$Component) {
    function WebView() {
      var _getPrototypeOf2;

      var _temp, _this;

      _classCallCheck(this, WebView);

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

      return _possibleConstructorReturn(_this, (_temp = _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(WebView)).call.apply(_getPrototypeOf2, [this].concat(args))), _this.state = {
        viewState: WebViewState.IDLE,
        lastErrorEvent: null,
        startInLoadingState: true
      }, _this.goForward = function () {
        UIManager.dispatchViewManagerCommand(_this.getWebViewHandle(), UIManager.RCTWebView.Commands.goForward, null);
      }, _this.goBack = function () {
        UIManager.dispatchViewManagerCommand(_this.getWebViewHandle(), UIManager.RCTWebView.Commands.goBack, null);
      }, _this.reload = function () {
        _this.setState({
          viewState: WebViewState.LOADING
        });

        UIManager.dispatchViewManagerCommand(_this.getWebViewHandle(), UIManager.RCTWebView.Commands.reload, null);
      }, _this.stopLoading = function () {
        UIManager.dispatchViewManagerCommand(_this.getWebViewHandle(), UIManager.RCTWebView.Commands.stopLoading, null);
      }, _this.postMessage = function (data) {
        UIManager.dispatchViewManagerCommand(_this.getWebViewHandle(), UIManager.RCTWebView.Commands.postMessage, [String(data)]);
      }, _this.injectJavaScript = function (data) {
        UIManager.dispatchViewManagerCommand(_this.getWebViewHandle(), UIManager.RCTWebView.Commands.injectJavaScript, [data]);
      }, _this._updateNavigationState = function (event) {
        if (_this.props.onNavigationStateChange) {
          _this.props.onNavigationStateChange(event.nativeEvent);
        }
      }, _this.getWebViewHandle = function () {
        return ReactNative.findNodeHandle(_this.refs[RCT_WEBVIEW_REF]);
      }, _this._onLoadingStart = function (event) {
        var onLoadStart = _this.props.onLoadStart;
        onLoadStart && onLoadStart(event);

        _this._updateNavigationState(event);
      }, _this._onLoadingError = function (event) {
        event.persist();
        var _this$props = _this.props,
            onError = _this$props.onError,
            onLoadEnd = _this$props.onLoadEnd;
        onError && onError(event);
        onLoadEnd && onLoadEnd(event);
        console.warn('Encountered an error loading page', event.nativeEvent);

        _this.setState({
          lastErrorEvent: event.nativeEvent,
          viewState: WebViewState.ERROR
        });
      }, _this._onLoadingFinish = function (event) {
        var _this$props2 = _this.props,
            onLoad = _this$props2.onLoad,
            onLoadEnd = _this$props2.onLoadEnd;
        onLoad && onLoad(event);
        onLoadEnd && onLoadEnd(event);

        _this.setState({
          viewState: WebViewState.IDLE
        });

        _this._updateNavigationState(event);
      }, _this._onMessage = function (event) {
        var onMessage = _this.props.onMessage;
        onMessage && onMessage(event);
      }, _temp));
    }

    _createClass(WebView, [{
      key: "UNSAFE_componentWillMount",
      value: function UNSAFE_componentWillMount() {
        if (this.props.startInLoadingState) {
          this.setState({
            viewState: WebViewState.LOADING
          });
        }
      }
    }, {
      key: "render",
      value: function render() {
        var _this2 = this;

        var otherView = null;

        if (this.state.viewState === WebViewState.LOADING) {
          otherView = (this.props.renderLoading || defaultRenderLoading)();
        } else if (this.state.viewState === WebViewState.ERROR) {
          var errorEvent = this.state.lastErrorEvent;
          invariant(errorEvent != null, 'lastErrorEvent expected to be non-null');
          otherView = (this.props.renderError || defaultRenderError)(errorEvent.domain, errorEvent.code, errorEvent.description);
        } else if (this.state.viewState !== WebViewState.IDLE) {
          console.error('RCTWebView invalid state encountered: ' + this.state.loading);
        }

        var webViewStyles = [styles.container, styles.webView, this.props.style];

        if (this.state.viewState === WebViewState.LOADING || this.state.viewState === WebViewState.ERROR) {
          webViewStyles.push(styles.hidden);
        }

        var nativeConfig = this.props.nativeConfig || {};
        var viewManager = nativeConfig.viewManager || RCTWebViewManager;
        var compiledWhitelist = (this.props.originWhitelist || []).map(WebViewShared.originWhitelistToRegex);

        var onShouldStartLoadWithRequest = function onShouldStartLoadWithRequest(event) {
          var shouldStart = true;
          var url = event.nativeEvent.url;
          var origin = WebViewShared.extractOrigin(url);
          var passesWhitelist = compiledWhitelist.some(function (x) {
            return new RegExp(x).test(origin);
          });
          shouldStart = shouldStart && passesWhitelist;

          if (!passesWhitelist) {
            Linking.openURL(url);
          }

          if (_this2.props.onShouldStartLoadWithRequest) {
            shouldStart = shouldStart && _this2.props.onShouldStartLoadWithRequest(event.nativeEvent);
          }

          viewManager.startLoadWithResult(!!shouldStart, event.nativeEvent.lockIdentifier);
        };

        var decelerationRate = processDecelerationRate(this.props.decelerationRate);
        var source = this.props.source || {};

        if (this.props.html) {
          source.html = this.props.html;
        } else if (this.props.url) {
          source.uri = this.props.url;
        }

        var messagingEnabled = typeof this.props.onMessage === 'function';
        var NativeWebView = nativeConfig.component || RCTWebView;
        var webView = React.createElement(NativeWebView, _extends({
          ref: RCT_WEBVIEW_REF,
          key: "webViewKey",
          style: webViewStyles,
          source: resolveAssetSource(source),
          injectedJavaScript: this.props.injectedJavaScript,
          bounces: this.props.bounces,
          scrollEnabled: this.props.scrollEnabled,
          decelerationRate: decelerationRate,
          contentInset: this.props.contentInset,
          automaticallyAdjustContentInsets: this.props.automaticallyAdjustContentInsets,
          onLoadingStart: this._onLoadingStart,
          onLoadingFinish: this._onLoadingFinish,
          onLoadingError: this._onLoadingError,
          messagingEnabled: messagingEnabled,
          onMessage: this._onMessage,
          onShouldStartLoadWithRequest: onShouldStartLoadWithRequest,
          scalesPageToFit: this.props.scalesPageToFit,
          allowsInlineMediaPlayback: this.props.allowsInlineMediaPlayback,
          mediaPlaybackRequiresUserAction: this.props.mediaPlaybackRequiresUserAction,
          dataDetectorTypes: this.props.dataDetectorTypes
        }, nativeConfig.props, {
          __source: {
            fileName: _jsxFileName,
            lineNumber: 476
          }
        }));
        return React.createElement(View, {
          style: styles.container,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 506
          }
        }, webView, otherView);
      }
    }]);

    _inherits(WebView, _React$Component);

    return WebView;
  }(React.Component);

  WebView.JSNavigationScheme = JSNavigationScheme;
  WebView.NavigationType = NavigationType;
  WebView.propTypes = _objectSpread({}, ViewPropTypes, {
    html: deprecatedPropType(PropTypes.string, 'Use the `source` prop instead.'),
    url: deprecatedPropType(PropTypes.string, 'Use the `source` prop instead.'),
    source: PropTypes.oneOfType([PropTypes.shape({
      uri: PropTypes.string,
      method: PropTypes.string,
      headers: PropTypes.object,
      body: PropTypes.string
    }), PropTypes.shape({
      html: PropTypes.string,
      baseUrl: PropTypes.string
    }), PropTypes.number]),
    renderError: PropTypes.func,
    renderLoading: PropTypes.func,
    onLoad: PropTypes.func,
    onLoadEnd: PropTypes.func,
    onLoadStart: PropTypes.func,
    onError: PropTypes.func,
    bounces: PropTypes.bool,
    decelerationRate: ScrollView.propTypes.decelerationRate,
    scrollEnabled: PropTypes.bool,
    automaticallyAdjustContentInsets: PropTypes.bool,
    contentInset: EdgeInsetsPropType,
    onNavigationStateChange: PropTypes.func,
    onMessage: PropTypes.func,
    startInLoadingState: PropTypes.bool,
    style: ViewPropTypes.style,
    dataDetectorTypes: PropTypes.oneOfType([PropTypes.oneOf(DataDetectorTypes), PropTypes.arrayOf(PropTypes.oneOf(DataDetectorTypes))]),
    javaScriptEnabled: PropTypes.bool,
    thirdPartyCookiesEnabled: PropTypes.bool,
    domStorageEnabled: PropTypes.bool,
    injectedJavaScript: PropTypes.string,
    userAgent: PropTypes.string,
    scalesPageToFit: PropTypes.bool,
    onShouldStartLoadWithRequest: PropTypes.func,
    allowsInlineMediaPlayback: PropTypes.bool,
    mediaPlaybackRequiresUserAction: PropTypes.bool,
    originWhitelist: PropTypes.arrayOf(PropTypes.string),
    injectJavaScript: PropTypes.func,
    mixedContentMode: PropTypes.oneOf(['never', 'always', 'compatibility']),
    nativeConfig: PropTypes.shape({
      component: PropTypes.any,
      props: PropTypes.object,
      viewManager: PropTypes.object
    })
  });
  WebView.defaultProps = {
    originWhitelist: WebViewShared.defaultOriginWhitelist,
    scalesPageToFit: true
  };
  WebView = _wrapComponent("WebView")(WebView);
  var RCTWebView = requireNativeComponent('RCTWebView');
  var styles = StyleSheet.create({
    container: {
      flex: 1
    },
    errorContainer: {
      flex: 1,
      justifyContent: 'center',
      alignItems: 'center',
      backgroundColor: BGWASH
    },
    errorText: {
      fontSize: 14,
      textAlign: 'center',
      marginBottom: 2
    },
    errorTextTitle: {
      fontSize: 15,
      fontWeight: '500',
      marginBottom: 10
    },
    hidden: {
      height: 0,
      flex: 0
    },
    loadingView: {
      backgroundColor: BGWASH,
      flex: 1,
      justifyContent: 'center',
      alignItems: 'center',
      height: 100
    },
    webView: {
      backgroundColor: '#ffffff'
    }
  });
  module.exports = WebView;
},477,[1,11,199,254,478,212,200,261,367,201,252,218,227,376,479,217,166,210,381,229,235,168],"node_modules/react-native/Libraries/Components/WebView/WebView.ios.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var NativeEventEmitter = _$$_REQUIRE(_dependencyMap[0], 'NativeEventEmitter');

  var NativeModules = _$$_REQUIRE(_dependencyMap[1], 'NativeModules');

  var Platform = _$$_REQUIRE(_dependencyMap[2], 'Platform');

  var invariant = _$$_REQUIRE(_dependencyMap[3], 'fbjs/lib/invariant');

  var LinkingManager = Platform.OS === 'android' ? NativeModules.IntentAndroid : NativeModules.LinkingManager;

  var Linking = function (_NativeEventEmitter) {
    function Linking() {
      _classCallCheck(this, Linking);

      return _possibleConstructorReturn(this, _getPrototypeOf(Linking).call(this, LinkingManager));
    }

    _createClass(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 LinkingManager.openURL(url);
      }
    }, {
      key: "canOpenURL",
      value: function canOpenURL(url) {
        this._validateURL(url);

        return LinkingManager.canOpenURL(url);
      }
    }, {
      key: "getInitialURL",
      value: function getInitialURL() {
        return LinkingManager.getInitialURL();
      }
    }, {
      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');
      }
    }]);

    _inherits(Linking, _NativeEventEmitter);

    return Linking;
  }(NativeEventEmitter);

  module.exports = new Linking();
},478,[286,168,176,166],"node_modules/react-native/Libraries/Linking/Linking.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var escapeStringRegexp = _$$_REQUIRE(_dependencyMap[0], 'escape-string-regexp');

  var WebViewShared = {
    defaultOriginWhitelist: ['http://*', 'https://*'],
    extractOrigin: function extractOrigin(url) {
      var result = /^[A-Za-z0-9]+:(\/\/)?[^/]*/.exec(url);
      return result === null ? null : result[0];
    },
    originWhitelistToRegex: function originWhitelistToRegex(originWhitelist) {
      return escapeStringRegexp(originWhitelist).replace(/\\\*/g, '.*');
    }
  };
  module.exports = WebViewShared;
},479,[480],"node_modules/react-native/Libraries/Components/WebView/WebViewShared.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var matchOperatorsRe = /[|\\{}()[\]^$+*?.]/g;

  module.exports = function (str) {
    if (typeof str !== 'string') {
      throw new TypeError('Expected a string');
    }

    return str.replace(matchOperatorsRe, '\\$&');
  };
},480,[],"node_modules/escape-string-regexp/index.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  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 RCTActionSheetManager = _$$_REQUIRE(_dependencyMap[0], 'NativeModules').ActionSheetManager;

  var invariant = _$$_REQUIRE(_dependencyMap[1], 'fbjs/lib/invariant');

  var processColor = _$$_REQUIRE(_dependencyMap[2], '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');
      RCTActionSheetManager.showActionSheetWithOptions(_objectSpread({}, options, {
        tintColor: processColor(options.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');
      RCTActionSheetManager.showShareActionSheetWithOptions(_objectSpread({}, options, {
        tintColor: processColor(options.tintColor)
      }), failureCallback, successCallback);
    }
  };
  module.exports = ActionSheetIOS;
},481,[168,166,221],"node_modules/react-native/Libraries/ActionSheetIOS/ActionSheetIOS.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  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 BatchedBridge = _$$_REQUIRE(_dependencyMap[0], 'BatchedBridge');

  var BugReporting = _$$_REQUIRE(_dependencyMap[1], 'BugReporting');

  var NativeModules = _$$_REQUIRE(_dependencyMap[2], 'NativeModules');

  var ReactNative = _$$_REQUIRE(_dependencyMap[3], 'ReactNative');

  var SceneTracker = _$$_REQUIRE(_dependencyMap[4], 'SceneTracker');

  var infoLog = _$$_REQUIRE(_dependencyMap[5], 'infoLog');

  var invariant = _$$_REQUIRE(_dependencyMap[6], 'fbjs/lib/invariant');

  var renderApplication = _$$_REQUIRE(_dependencyMap[7], 'renderApplication');

  var runnables = {};
  var runCount = 1;
  var sections = {};
  var tasks = new Map();

  var componentProviderInstrumentationHook = function componentProviderInstrumentationHook(component) {
    return component();
  };

  var wrapperComponentProvider;
  var AppRegistry = {
    setWrapperComponentProvider: function setWrapperComponentProvider(provider) {
      wrapperComponentProvider = provider;
    },
    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) {
      runnables[appKey] = {
        componentProvider: componentProvider,
        run: function run(appParameters) {
          renderApplication(componentProviderInstrumentationHook(componentProvider), appParameters.initialProps, appParameters.rootTag, wrapperComponentProvider && wrapperComponentProvider(appParameters), appParameters.fabric);
        }
      };

      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 application "' + appKey + '" with appParams: ' + JSON.stringify(appParameters) + '. ' + '__DEV__ === ' + String(__DEV__) + ', development-level warning are ' + (__DEV__ ? 'ON' : 'OFF') + ', performance optimizations are ' + (__DEV__ ? 'OFF' : 'ON');
      infoLog(msg);
      BugReporting.addSource('AppRegistry.runApplication' + runCount++, function () {
        return msg;
      });
      invariant(runnables[appKey] && runnables[appKey].run, 'Application ' + appKey + ' has not been registered.\n\n' + "Hint: This error often happens when you're running the packager " + '(local dev server) from a wrong folder. For example you have ' + 'multiple apps and the packager is still running for the app you ' + 'were working on before.\nIf this is the case, simply kill the old ' + 'packager instance (e.g. close the packager terminal window) ' + 'and start the packager in the correct app folder (e.g. cd into app ' + "folder and run 'npm start').\n\n" + 'This error can also happen due to a require() error during ' + 'initialization or failure to call AppRegistry.registerComponent.\n\n');
      SceneTracker.setActiveScene({
        name: appKey
      });
      runnables[appKey].run(appParameters);
    },
    unmountApplicationComponentAtRootTag: function unmountApplicationComponentAtRootTag(rootTag) {
      ReactNative.unmountComponentAtNodeAndRemoveContainer(rootTag);
    },
    registerHeadlessTask: function registerHeadlessTask(taskKey, task) {
      if (tasks.has(taskKey)) {
        console.warn("registerHeadlessTask called multiple times for same key '" + taskKey + "'");
      }

      tasks.set(taskKey, task);
    },
    startHeadlessTask: function startHeadlessTask(taskId, taskKey, data) {
      var taskProvider = tasks.get(taskKey);

      if (!taskProvider) {
        throw new Error("No task registered for key " + taskKey);
      }

      taskProvider()(data).then(function () {
        return NativeModules.HeadlessJsTaskSupport.notifyTaskFinished(taskId);
      }).catch(function (reason) {
        console.error(reason);
        NativeModules.HeadlessJsTaskSupport.notifyTaskFinished(taskId);
      });
    }
  };
  BatchedBridge.registerCallableModule('AppRegistry', AppRegistry);
  module.exports = AppRegistry;
},482,[169,483,168,261,485,309,166,486],"node_modules/react-native/Libraries/ReactNative/AppRegistry.js");
__d(function (global, _$$_REQUIRE, 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; }

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  var RCTDeviceEventEmitter = _$$_REQUIRE(_dependencyMap[0], 'RCTDeviceEventEmitter');

  var Map = _$$_REQUIRE(_dependencyMap[1], 'Map');

  var infoLog = _$$_REQUIRE(_dependencyMap[2], 'infoLog');

  function defaultExtras() {
    BugReporting.addFileSource('react_hierarchy.txt', function () {
      return _$$_REQUIRE(_dependencyMap[3], 'dumpReactTree')();
    });
  }

  var BugReporting = function () {
    function BugReporting() {
      _classCallCheck(this, BugReporting);
    }

    _createClass(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), _i2 = 0, _iterator = _isArray ? _iterator : _iterator[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"]();;) {
          var _ref3;

          if (_isArray) {
            if (_i2 >= _iterator.length) break;
            _ref3 = _iterator[_i2++];
          } else {
            _i2 = _iterator.next();
            if (_i2.done) break;
            _ref3 = _i2.value;
          }

          var _ref7 = _ref3;

          var _ref2 = _slicedToArray(_ref7, 2);

          var _key3 = _ref2[0];
          var _callback2 = _ref2[1];
          extraData[_key3] = _callback2();
        }

        var fileData = {};

        for (var _iterator2 = BugReporting._fileSources, _isArray2 = Array.isArray(_iterator2), _i3 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[typeof Symbol === "function" ? Symbol.iterator : "@@iterator"]();;) {
          var _ref6;

          if (_isArray2) {
            if (_i3 >= _iterator2.length) break;
            _ref6 = _iterator2[_i3++];
          } else {
            _i3 = _iterator2.next();
            if (_i3.done) break;
            _ref6 = _i3.value;
          }

          var _ref8 = _ref6;

          var _ref5 = _slicedToArray(_ref8, 2);

          var _key4 = _ref5[0];
          var _callback3 = _ref5[1];
          fileData[_key4] = _callback3();
        }

        infoLog('BugReporting extraData:', extraData);

        var BugReportingNativeModule = _$$_REQUIRE(_dependencyMap[4], 'NativeModules').BugReporting;

        BugReportingNativeModule && BugReportingNativeModule.setExtraData && BugReportingNativeModule.setExtraData(extraData, fileData);

        var RedBoxNativeModule = _$$_REQUIRE(_dependencyMap[4], 'NativeModules').RedBox;

        RedBoxNativeModule && RedBoxNativeModule.setExtraData && RedBoxNativeModule.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;
},483,[194,266,309,484,168],"node_modules/react-native/Libraries/BugReporting/BugReporting.js");
__d(function (global, _$$_REQUIRE, 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;
},484,[],"node_modules/react-native/Libraries/BugReporting/dumpReactTree.js");
__d(function (global, _$$_REQUIRE, 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;
},485,[],"node_modules/react-native/Libraries/Utilities/SceneTracker.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var _jsxFileName = "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native/Libraries/ReactNative/renderApplication.js";

  function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

  var AppContainer = _$$_REQUIRE(_dependencyMap[0], 'AppContainer');

  var React = _$$_REQUIRE(_dependencyMap[1], 'React');

  var invariant = _$$_REQUIRE(_dependencyMap[2], 'fbjs/lib/invariant');

  _$$_REQUIRE(_dependencyMap[3], 'BackHandler');

  function renderApplication(RootComponent, initialProps, rootTag, WrapperComponent, fabric) {
    invariant(rootTag, 'Expect to have a valid rootTag, instead got ', rootTag);
    var renderable = React.createElement(AppContainer, {
      rootTag: rootTag,
      WrapperComponent: WrapperComponent,
      __source: {
        fileName: _jsxFileName,
        lineNumber: 31
      }
    }, React.createElement(RootComponent, _extends({}, initialProps, {
      rootTag: rootTag,
      __source: {
        fileName: _jsxFileName,
        lineNumber: 32
      }
    })));

    if (RootComponent.prototype != null && RootComponent.prototype.unstable_isAsyncReactComponent === true) {
      var AsyncMode = React.unstable_AsyncMode;
      renderable = React.createElement(AsyncMode, {
        __source: {
          fileName: _jsxFileName,
          lineNumber: 48
        }
      }, renderable);
    }

    if (fabric) {
      _$$_REQUIRE(_dependencyMap[4], 'ReactFabric').render(renderable, rootTag);
    } else {
      _$$_REQUIRE(_dependencyMap[5], 'ReactNative').render(renderable, rootTag);
    }
  }

  module.exports = renderApplication;
},486,[410,200,166,487,488,261],"node_modules/react-native/Libraries/ReactNative/renderApplication.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var Platform = _$$_REQUIRE(_dependencyMap[0], 'Platform');

  var TVEventHandler = _$$_REQUIRE(_dependencyMap[1], 'TVEventHandler');

  function emptyFunction() {}

  var BackHandler;

  if (Platform.isTV) {
    var _tvEventHandler = new TVEventHandler();

    var _backPressSubscriptions = new Set();

    _tvEventHandler.enable(this, function (cmp, evt) {
      if (evt && evt.eventType === 'menu') {
        var invokeDefault = true;
        var subscriptions = Array.from(_backPressSubscriptions.values()).reverse();

        for (var i = 0; i < subscriptions.length; ++i) {
          if (subscriptions[i]()) {
            invokeDefault = false;
            break;
          }
        }

        if (invokeDefault) {
          BackHandler.exitApp();
        }
      }
    });

    BackHandler = {
      exitApp: emptyFunction,
      addEventListener: function addEventListener(eventName, handler) {
        _backPressSubscriptions.add(handler);

        return {
          remove: function remove() {
            return BackHandler.removeEventListener(eventName, handler);
          }
        };
      },
      removeEventListener: function removeEventListener(eventName, handler) {
        _backPressSubscriptions.delete(handler);
      }
    };
  } else {
    BackHandler = {
      exitApp: emptyFunction,
      addEventListener: function addEventListener() {
        return {
          remove: emptyFunction
        };
      },
      removeEventListener: emptyFunction
    };
  }

  module.exports = BackHandler;
},487,[176,327],"node_modules/react-native/Libraries/Utilities/BackHandler.ios.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var BatchedBridge = _$$_REQUIRE(_dependencyMap[0], 'BatchedBridge');

  var ReactFabric;

  if (__DEV__) {
    ReactFabric = _$$_REQUIRE(_dependencyMap[1], 'ReactFabric-dev');
  } else {
    ReactFabric = _$$_REQUIRE(_dependencyMap[2], 'ReactFabric-prod');
  }

  BatchedBridge.registerCallableModule('ReactFabric', ReactFabric);
  module.exports = ReactFabric;
},488,[169,489,491],"node_modules/react-native/Libraries/Renderer/shims/ReactFabric.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

  if (__DEV__) {
    (function () {
      "use strict";

      _$$_REQUIRE(_dependencyMap[0], "InitializeCore");

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

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

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

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

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

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

      var deepDiffer = _$$_REQUIRE(_dependencyMap[7], "deepDiffer");

      var flattenStyle = _$$_REQUIRE(_dependencyMap[8], "flattenStyle");

      var deepFreezeAndThrowOnMutationInDev = _$$_REQUIRE(_dependencyMap[9], "deepFreezeAndThrowOnMutationInDev");

      var TextInputState = _$$_REQUIRE(_dependencyMap[10], "TextInputState");

      var FabricUIManager = _$$_REQUIRE(_dependencyMap[11], "FabricUIManager");

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

      var ExceptionsManager = _$$_REQUIRE(_dependencyMap[13], "ExceptionsManager");

      var invokeGuardedCallback = function invokeGuardedCallback(name, func, context, a, b, c, d, e, f) {
        this._hasCaughtError = false;
        this._caughtError = null;
        var funcArgs = Array.prototype.slice.call(arguments, 3);

        try {
          func.apply(context, funcArgs);
        } catch (error) {
          this._caughtError = error;
          this._hasCaughtError = true;
        }
      };

      {
        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) {
            invariant(typeof document !== "undefined", "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 funcArgs = Array.prototype.slice.call(arguments, 3);

            function callCallback() {
              fakeNode.removeEventListener(evtType, callCallback, false);
              func.apply(context, funcArgs);
              didError = false;
            }

            var error = void 0;
            var didSetError = false;
            var isCrossOriginError = false;

            function onError(event) {
              error = event.error;
              didSetError = true;

              if (error === null && event.colno === 0 && event.lineno === 0) {
                isCrossOriginError = true;
              }
            }

            var evtType = "react-" + (name ? name : "invokeguardedcallback");
            window.addEventListener("error", onError);
            fakeNode.addEventListener(evtType, callCallback, false);
            evt.initEvent(evtType, false, false);
            fakeNode.dispatchEvent(evt);

            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._hasCaughtError = true;
              this._caughtError = error;
            } else {
              this._hasCaughtError = false;
              this._caughtError = null;
            }

            window.removeEventListener("error", onError);
          };

          invokeGuardedCallback = invokeGuardedCallbackDev;
        }
      }
      var invokeGuardedCallback$1 = invokeGuardedCallback;
      var ReactErrorUtils = {
        _caughtError: null,
        _hasCaughtError: false,
        _rethrowError: null,
        _hasRethrowError: false,
        invokeGuardedCallback: function invokeGuardedCallback(name, func, context, a, b, c, d, e, f) {
          invokeGuardedCallback$1.apply(ReactErrorUtils, arguments);
        },
        invokeGuardedCallbackAndCatchFirstError: function invokeGuardedCallbackAndCatchFirstError(name, func, context, a, b, c, d, e, f) {
          ReactErrorUtils.invokeGuardedCallback.apply(this, arguments);

          if (ReactErrorUtils.hasCaughtError()) {
            var error = ReactErrorUtils.clearCaughtError();

            if (!ReactErrorUtils._hasRethrowError) {
              ReactErrorUtils._hasRethrowError = true;
              ReactErrorUtils._rethrowError = error;
            }
          }
        },
        rethrowCaughtError: function rethrowCaughtError() {
          return _rethrowCaughtError.apply(ReactErrorUtils, arguments);
        },
        hasCaughtError: function hasCaughtError() {
          return ReactErrorUtils._hasCaughtError;
        },
        clearCaughtError: function clearCaughtError() {
          if (ReactErrorUtils._hasCaughtError) {
            var error = ReactErrorUtils._caughtError;
            ReactErrorUtils._caughtError = null;
            ReactErrorUtils._hasCaughtError = false;
            return error;
          } else {
            invariant(false, "clearCaughtError was called but no error was captured. This error " + "is likely caused by a bug in React. Please file an issue.");
          }
        }
      };

      var _rethrowCaughtError = function _rethrowCaughtError() {
        if (ReactErrorUtils._hasRethrowError) {
          var error = ReactErrorUtils._rethrowError;
          ReactErrorUtils._rethrowError = null;
          ReactErrorUtils._hasRethrowError = false;
          throw 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);
          invariant(pluginIndex > -1, "EventPluginRegistry: Cannot inject event plugins that do not exist in " + "the plugin ordering, `%s`.", pluginName);

          if (plugins[pluginIndex]) {
            continue;
          }

          invariant(pluginModule.extractEvents, "EventPluginRegistry: Event plugins must implement an `extractEvents` " + "method, but `%s` does not.", pluginName);
          plugins[pluginIndex] = pluginModule;
          var publishedEvents = pluginModule.eventTypes;

          for (var eventName in publishedEvents) {
            invariant(publishEventForPlugin(publishedEvents[eventName], pluginModule, eventName), "EventPluginRegistry: Failed to publish event `%s` for plugin `%s`.", eventName, pluginName);
          }
        }
      }

      function publishEventForPlugin(dispatchConfig, pluginModule, eventName) {
        invariant(!eventNameDispatchConfigs.hasOwnProperty(eventName), "EventPluginHub: More than one plugin attempted to publish the same " + "event name, `%s`.", 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) {
        invariant(!registrationNameModules[registrationName], "EventPluginHub: More than one plugin attempted to publish the same " + "registration name, `%s`.", 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) {
        invariant(!eventPluginOrder, "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) {
            invariant(!namesToPlugins[pluginName], "EventPluginRegistry: Cannot inject two different event plugins " + "using the same name, `%s`.", pluginName);
            namesToPlugins[pluginName] = pluginModule;
            isOrderingDirty = true;
          }
        }

        if (isOrderingDirty) {
          recomputePluginOrdering();
        }
      }

      var getFiberCurrentPropsFromNode = null;
      var getInstanceFromNode = null;
      var getNodeFromInstance = null;
      var injection$1 = {
        injectComponentTree: function injectComponentTree(Injected) {
          getFiberCurrentPropsFromNode = Injected.getFiberCurrentPropsFromNode;
          getInstanceFromNode = Injected.getInstanceFromNode;
          getNodeFromInstance = Injected.getNodeFromInstance;
          {
            !(getNodeFromInstance && getInstanceFromNode) ? warning(false, "EventPluginUtils.injection.injectComponentTree(...): 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) ? warning(false, "EventPluginUtils: Invalid `event`.") : void 0;
        };
      }

      function executeDispatch(event, simulated, listener, inst) {
        var type = event.type || "unknown-event";
        event.currentTarget = getNodeFromInstance(inst);
        ReactErrorUtils.invokeGuardedCallbackAndCatchFirstError(type, listener, undefined, event);
        event.currentTarget = null;
      }

      function executeDispatchesInOrder(event, simulated) {
        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, simulated, dispatchListeners[i], dispatchInstances[i]);
          }
        } else if (dispatchListeners) {
          executeDispatch(event, simulated, 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;
        invariant(!Array.isArray(dispatchListener), "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) {
        invariant(next != null, "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, simulated) {
        if (event) {
          executeDispatchesInOrder(event, simulated);

          if (!event.isPersistent()) {
            event.constructor.release(event);
          }
        }
      };

      var executeDispatchesAndReleaseSimulated = function executeDispatchesAndReleaseSimulated(e) {
        return executeDispatchesAndRelease(e, true);
      };

      var executeDispatchesAndReleaseTopLevel = function executeDispatchesAndReleaseTopLevel(e) {
        return executeDispatchesAndRelease(e, false);
      };

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

        invariant(!listener || typeof listener === "function", "Expected `%s` listener to be a function, instead got a value of `%s` type.", registrationName, typeof listener);
        return listener;
      }

      function extractEvents(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 runEventsInBatch(events, simulated) {
        if (events !== null) {
          eventQueue = accumulateInto(eventQueue, events);
        }

        var processingEventQueue = eventQueue;
        eventQueue = null;

        if (!processingEventQueue) {
          return;
        }

        if (simulated) {
          forEachAccumulated(processingEventQueue, executeDispatchesAndReleaseSimulated);
        } else {
          forEachAccumulated(processingEventQueue, executeDispatchesAndReleaseTopLevel);
        }

        invariant(!eventQueue, "processEventQueue(): Additional events were enqueued while processing " + "an event queue. Support for this has not yet been implemented.");
        ReactErrorUtils.rethrowCaughtError();
      }

      function runExtractedEventsInBatch(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
        var events = extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget);
        runEventsInBatch(events, false);
      }

      var IndeterminateComponent = 0;
      var FunctionalComponent = 1;
      var ClassComponent = 2;
      var HostRoot = 3;
      var HostPortal = 4;
      var HostComponent = 5;
      var HostText = 6;
      var Fragment = 10;
      var Mode = 11;
      var ContextConsumer = 12;
      var ContextProvider = 13;
      var ForwardRef = 14;
      var Profiler = 15;
      var TimeoutComponent = 16;

      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 ? warning(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 didWarnForAddedNewProperty = false;
      var EVENT_POOL_SIZE = 10;
      var shouldBeReleasedProperties = ["dispatchConfig", "_targetInst", "nativeEvent", "isDefaultPrevented", "isPropagationStopped", "_dispatchListeners", "_dispatchInstances"];
      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;
        }
        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]));
            }
          }

          for (var i = 0; i < shouldBeReleasedProperties.length; i++) {
            this[shouldBeReleasedProperties[i]] = null;
          }

          {
            Object.defineProperty(this, "nativeEvent", getPooledWarningPropertyDefinition("nativeEvent", null));
            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;
      };

      {
        var isProxySupported = typeof Proxy === "function" && !Object.isSealed(new Proxy({}, {}));

        if (isProxySupported) {
          SyntheticEvent = new Proxy(SyntheticEvent, {
            construct: function construct(target, args) {
              return this.apply(target, Object.create(target.prototype), args);
            },
            apply: function apply(constructor, that, args) {
              return new Proxy(constructor.apply(that, args), {
                set: function set(target, prop, value) {
                  if (prop !== "isPersistent" && !target.constructor.Interface.hasOwnProperty(prop) && shouldBeReleasedProperties.indexOf(prop) === -1) {
                    !(didWarnForAddedNewProperty || target.isPersistent()) ? warning(false, "This synthetic event is reused for performance reasons. If you're " + "seeing this, you're adding a new property in the synthetic event object. " + "The property is never released. See " + "https://fb.me/react-event-pooling for more information.") : void 0;
                    didWarnForAddedNewProperty = true;
                  }

                  target[prop] = value;
                  return true;
                }
              });
            }
          });
        }
      }
      addEventPoolingTo(SyntheticEvent);

      function getPooledWarningPropertyDefinition(propName, getVal) {
        var isFunction = typeof getVal === "function";
        return {
          configurable: true,
          set: set,
          get: get$$1
        };

        function set(val) {
          var action = isFunction ? "setting the method" : "setting the property";
          warn(action, "This is effectively a no-op");
          return val;
        }

        function get$$1() {
          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 ? warning(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;
        invariant(event instanceof EventConstructor, "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 SyntheticEvent$1 = SyntheticEvent;
      var ResponderSyntheticEvent = SyntheticEvent$1.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;
        invariant(identifier != null, "Touch object is missing identifier.");
        {
          !(identifier <= MAX_TOUCH_BANK) ? warning(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.error("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.error("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) ? warning(false, "Cannot find single active touch.") : void 0;
              }
            }
          }
        },
        touchHistory: touchHistory
      };

      function accumulate(current, next) {
        invariant(next != null, "accumulate(...): Accumulated items must be 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$1 = {
        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$1.startShouldSetResponder : isMoveish(topLevelType) ? eventTypes$1.moveShouldSetResponder : topLevelType === TOP_SELECTION_CHANGE ? eventTypes$1.selectionChangeShouldSetResponder : eventTypes$1.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$1.responderGrant, wantsResponderInst, nativeEvent, nativeEventTarget);
        grantEvent.touchHistory = ResponderTouchHistoryStore.touchHistory;
        accumulateDirectDispatches(grantEvent);
        var blockHostResponder = executeDirectDispatch(grantEvent) === true;

        if (responderInst) {
          var terminationRequestEvent = ResponderSyntheticEvent.getPooled(eventTypes$1.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$1.responderTerminate, responderInst, nativeEvent, nativeEventTarget);
            terminateEvent.touchHistory = ResponderTouchHistoryStore.touchHistory;
            accumulateDirectDispatches(terminateEvent);
            extracted = accumulate(extracted, [grantEvent, terminateEvent]);
            changeResponder(wantsResponderInst, blockHostResponder);
          } else {
            var rejectEvent = ResponderSyntheticEvent.getPooled(eventTypes$1.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$1,
        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$1.responderStart : isResponderTouchMove ? eventTypes$1.responderMove : isResponderTouchEnd ? eventTypes$1.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$1.responderTerminate : isResponderRelease ? eventTypes$1.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$1 = ReactNativeViewConfigRegistry.customBubblingEventTypes;
      var customDirectEventTypes$1 = ReactNativeViewConfigRegistry.customDirectEventTypes;
      var eventTypes$2 = ReactNativeViewConfigRegistry.eventTypes;
      var ReactNativeBridgeEventPlugin = {
        eventTypes: eventTypes$2,
        extractEvents: function extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
          if (targetInst == null) {
            return null;
          }

          var bubbleDispatchConfig = customBubblingEventTypes$1[topLevelType];
          var directDispatchConfig = customDirectEventTypes$1[topLevelType];
          invariant(bubbleDispatchConfig || directDispatchConfig, 'Unsupported top level event type "%s" dispatched', topLevelType);
          var event = SyntheticEvent$1.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;
        invariant(tag, "All native instances should have a tag.");
        return tag;
      }

      function getFiberCurrentPropsFromNode$1(inst) {
        return inst.canonical.currentProps;
      }

      var ReactFabricComponentTree = Object.freeze({
        getClosestInstanceFromNode: getInstanceFromInstance,
        getInstanceFromNode: getInstanceFromInstance,
        getNodeFromInstance: getTagFromInstance,
        getFiberCurrentPropsFromNode: getFiberCurrentPropsFromNode$1
      });
      var ReactFabricGlobalResponderHandler = {
        onChange: function onChange(from, to, blockNativeResponder) {
          if (to !== null) {
            var tag = to.stateNode.canonical._nativeTag;
            UIManager.setJSResponder(tag, blockNativeResponder);
          } else {
            UIManager.clearJSResponder();
          }
        }
      };
      injection$1.injectComponentTree(ReactFabricComponentTree);
      ResponderEventPlugin.injection.injectGlobalResponderHandler(ReactFabricGlobalResponderHandler);

      function get$1(key) {
        return key._reactInternalFiber;
      }

      function set(key, value) {
        key._reactInternalFiber = value;
      }

      var ReactInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
      var ReactCurrentOwner = ReactInternals.ReactCurrentOwner;
      var ReactDebugCurrentFrame = ReactInternals.ReactDebugCurrentFrame;
      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_FORWARD_REF_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.forward_ref") : 0xead0;
      var REACT_TIMEOUT_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.timeout") : 0xead1;
      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 === "undefined") {
          return null;
        }

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

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

        return null;
      }

      function getComponentName(fiber) {
        var type = fiber.type;

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

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

        switch (type) {
          case REACT_ASYNC_MODE_TYPE:
            return "AsyncMode";

          case REACT_CONTEXT_TYPE:
            return "Context.Consumer";

          case REACT_FRAGMENT_TYPE:
            return "ReactFragment";

          case REACT_PORTAL_TYPE:
            return "ReactPortal";

          case REACT_PROFILER_TYPE:
            return "Profiler(" + fiber.pendingProps.id + ")";

          case REACT_PROVIDER_TYPE:
            return "Context.Provider";

          case REACT_STRICT_MODE_TYPE:
            return "StrictMode";

          case REACT_TIMEOUT_TYPE:
            return "Timeout";
        }

        if (typeof type === "object" && type !== null) {
          switch (type.$$typeof) {
            case REACT_FORWARD_REF_TYPE:
              var functionName = type.render.displayName || type.render.name || "";
              return functionName !== "" ? "ForwardRef(" + functionName + ")" : "ForwardRef";
          }
        }

        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 HostEffectMask = 511;
      var Incomplete = 512;
      var ShouldCapture = 1024;
      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.current;

          if (owner !== null && owner.tag === ClassComponent) {
            var ownerFiber = owner;
            var instance = ownerFiber.stateNode;
            !instance._warnedAboutRefsInRender ? warning(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) || "A component") : void 0;
            instance._warnedAboutRefsInRender = true;
          }
        }
        var fiber = get$1(component);

        if (!fiber) {
          return false;
        }

        return isFiberMountedImpl(fiber) === MOUNTED;
      }

      function assertIsMounted(fiber) {
        invariant(isFiberMountedImpl(fiber) === MOUNTED, "Unable to find node on an unmounted component.");
      }

      function findCurrentFiberUsingSlowPath(fiber) {
        var alternate = fiber.alternate;

        if (!alternate) {
          var state = isFiberMountedImpl(fiber);
          invariant(state !== UNMOUNTED, "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;
          var parentB = parentA ? parentA.alternate : null;

          if (!parentA || !parentB) {
            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;
            }

            invariant(false, "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;
              }

              invariant(didFindChild, "Child was not found in either parent set. This indicates a bug " + "in React related to the return pointer. Please file an issue.");
            }
          }

          invariant(a.alternate === b, "Return fibers should always be each others' alternates. " + "This error is likely caused by a bug in React. Please file an issue.");
        }

        invariant(a.tag === HostRoot, "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 findCurrentHostFiberWithNoPortals(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.tag !== HostPortal) {
            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(context, callback) {
        return function () {
          if (!callback) {
            return undefined;
          }

          if (typeof context.__isMounted === "boolean") {
            if (!context.__isMounted) {
              return undefined;
            }
          } else if (typeof context.isMounted === "function") {
            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$1 = {};
      var removedKeys = null;
      var removedKeyCount = 0;

      function defaultDiffer(prevProp, nextProp) {
        if (typeof nextProp !== "object" || nextProp === null) {
          return true;
        } else {
          return 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, flattenStyle(prevProp), nextProp, validAttributes);
        }

        return diffProperties(updatePayload, prevProp, 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$1, props, validAttributes);
      }

      function clearProperties(updatePayload, prevProps, validAttributes) {
        return diffProperties(updatePayload, prevProps, emptyObject$1, validAttributes);
      }

      function create(props, validAttributes) {
        return addProperties(null, props, validAttributes);
      }

      function diff(prevProps, nextProps, validAttributes) {
        return diffProperties(null, prevProps, nextProps, validAttributes);
      }

      var hasNativePerformanceNow = typeof performance === "object" && typeof performance.now === "function";
      var now$1 = hasNativePerformanceNow ? function () {
        return performance.now();
      } : function () {
        return Date.now();
      };
      var scheduledCallback = null;
      var frameDeadline = 0;
      var frameDeadlineObject = {
        timeRemaining: function timeRemaining() {
          return frameDeadline - now$1();
        },
        didTimeout: false
      };

      function setTimeoutCallback() {
        frameDeadline = now$1() + 5;
        var callback = scheduledCallback;
        scheduledCallback = null;

        if (callback !== null) {
          callback(frameDeadlineObject);
        }
      }

      function scheduleDeferredCallback$1(callback, options) {
        scheduledCallback = callback;
        var timeoutId = setTimeout(setTimeoutCallback, 1);
        return timeoutId;
      }

      function cancelDeferredCallback$1(callbackID) {
        scheduledCallback = null;
        clearTimeout(callbackID);
      }

      var fiberHostComponent = null;
      var restoreTarget = null;
      var restoreQueue = null;

      function restoreStateOfTarget(target) {
        var internalInstance = getInstanceFromNode(target);

        if (!internalInstance) {
          return;
        }

        invariant(fiberHostComponent && typeof fiberHostComponent.restoreControlledState === "function", "Fiber needs to be injected to handle a fiber target for controlled " + "events. This error is likely caused by a bug in React. Please file an issue.");
        var props = getFiberCurrentPropsFromNode(internalInstance.stateNode);
        fiberHostComponent.restoreControlledState(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 _batchedUpdates = function _batchedUpdates(fn, bookkeeping) {
        return fn(bookkeeping);
      };

      var _interactiveUpdates = function _interactiveUpdates(fn, a, b) {
        return fn(a, b);
      };

      var _flushInteractiveUpdates = function _flushInteractiveUpdates() {};

      var isBatching = false;

      function batchedUpdates(fn, bookkeeping) {
        if (isBatching) {
          return fn(bookkeeping);
        }

        isBatching = true;

        try {
          return _batchedUpdates(fn, bookkeeping);
        } finally {
          isBatching = false;
          var controlledComponentsHavePendingUpdates = needsStateRestore();

          if (controlledComponentsHavePendingUpdates) {
            _flushInteractiveUpdates();

            restoreStateIfNeeded();
          }
        }
      }

      var injection$2 = {
        injectRenderer: function injectRenderer(renderer) {
          _batchedUpdates = renderer.batchedUpdates;
          _interactiveUpdates = renderer.interactiveUpdates;
          _flushInteractiveUpdates = renderer.flushInteractiveUpdates;
        }
      };

      function dispatchEvent(target, topLevelType, nativeEvent) {
        var targetFiber = target;
        batchedUpdates(function () {
          runExtractedEventsInBatch(topLevelType, targetFiber, nativeEvent, nativeEvent.target);
        });
      }

      function shim() {
        invariant(false, "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$1 = 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;

      function shim$1() {
        invariant(false, "The current renderer does not support hyration. " + "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 getNextHydratableSibling = shim$1;
      var getFirstHydratableChild = shim$1;
      var hydrateInstance = shim$1;
      var hydrateTextInstance = 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 didNotFindHydratableInstance = shim$1;
      var didNotFindHydratableTextInstance = shim$1;

      function _classCallCheck(instance, Constructor) {
        if (!(instance instanceof Constructor)) {
          throw new TypeError("Cannot call a class as a function");
        }
      }

      var nextReactTag = 2;

      if (FabricUIManager.registerEventHandler) {
        FabricUIManager.registerEventHandler(dispatchEvent);
      }

      var ReactFabricHostComponent = function () {
        function ReactFabricHostComponent(tag, viewConfig, props) {
          _classCallCheck(this, ReactFabricHostComponent);

          this._nativeTag = tag;
          this.viewConfig = viewConfig;
          this.currentProps = props;
        }

        ReactFabricHostComponent.prototype.blur = function blur() {
          TextInputState.blurTextInput(this._nativeTag);
        };

        ReactFabricHostComponent.prototype.focus = function focus() {
          TextInputState.focusTextInput(this._nativeTag);
        };

        ReactFabricHostComponent.prototype.measure = function measure(callback) {
          UIManager.measure(this._nativeTag, mountSafeCallback(this, callback));
        };

        ReactFabricHostComponent.prototype.measureInWindow = function measureInWindow(callback) {
          UIManager.measureInWindow(this._nativeTag, mountSafeCallback(this, callback));
        };

        ReactFabricHostComponent.prototype.measureLayout = function measureLayout(relativeToNativeNode, onSuccess, onFail) {
          UIManager.measureLayout(this._nativeTag, relativeToNativeNode, mountSafeCallback(this, onFail), mountSafeCallback(this, onSuccess));
        };

        ReactFabricHostComponent.prototype.setNativeProps = function setNativeProps(nativeProps) {
          {
            warnForStyleProps(nativeProps, this.viewConfig.validAttributes);
          }
          var updatePayload = create(nativeProps, this.viewConfig.validAttributes);

          if (updatePayload != null) {
            UIManager.updateView(this._nativeTag, this.viewConfig.uiViewClassName, updatePayload);
          }
        };

        return ReactFabricHostComponent;
      }();

      function appendInitialChild(parentInstance, child) {
        FabricUIManager.appendChild(parentInstance.node, child.node);
      }

      function createInstance(type, props, rootContainerInstance, hostContext, internalInstanceHandle) {
        var tag = nextReactTag;
        nextReactTag += 2;
        var viewConfig = ReactNativeViewConfigRegistry.get(type);
        {
          for (var key in viewConfig.validAttributes) {
            if (props.hasOwnProperty(key)) {
              deepFreezeAndThrowOnMutationInDev(props[key]);
            }
          }
        }
        invariant(type !== "RCTView" || !hostContext.isInAParentText, "Nesting of <View> within <Text> is not currently supported.");
        var updatePayload = create(props, viewConfig.validAttributes);
        var node = FabricUIManager.createNode(tag, viewConfig.uiViewClassName, rootContainerInstance, updatePayload, internalInstanceHandle);
        var component = new ReactFabricHostComponent(tag, viewConfig, props);
        return {
          node: node,
          canonical: component
        };
      }

      function createTextInstance(text, rootContainerInstance, hostContext, internalInstanceHandle) {
        invariant(hostContext.isInAParentText, "Text strings must be rendered within a <Text> component.");
        var tag = nextReactTag;
        nextReactTag += 2;
        var node = FabricUIManager.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 now = now$1;
      var scheduleDeferredCallback = scheduleDeferredCallback$1;
      var cancelDeferredCallback = cancelDeferredCallback$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 = FabricUIManager.cloneNodeWithNewProps(node, updatePayload, internalInstanceHandle);
          } else {
            clone = FabricUIManager.cloneNode(node, internalInstanceHandle);
          }
        } else {
          if (updatePayload !== null) {
            clone = FabricUIManager.cloneNodeWithNewChildrenAndProps(node, updatePayload, internalInstanceHandle);
          } else {
            clone = FabricUIManager.cloneNodeWithNewChildren(node, internalInstanceHandle);
          }
        }

        return {
          node: clone,
          canonical: instance.canonical
        };
      }

      function createContainerChildSet(container) {
        return FabricUIManager.createChildSet(container);
      }

      function appendChildToContainerChildSet(childSet, child) {
        FabricUIManager.appendChildToSet(childSet, child.node);
      }

      function finalizeContainerChildren(container, newChildren) {
        FabricUIManager.completeRoot(container, newChildren);
      }

      var describeComponentFrame = function describeComponentFrame(name, source, ownerName) {
        return "\n    in " + (name || "Unknown") + (source ? " (at " + source.fileName.replace(/^.*[\\\/]/, "") + ":" + source.lineNumber + ")" : ownerName ? " (created by " + ownerName + ")" : "");
      };

      function describeFiber(fiber) {
        switch (fiber.tag) {
          case IndeterminateComponent:
          case FunctionalComponent:
          case ClassComponent:
          case HostComponent:
            var owner = fiber._debugOwner;
            var source = fiber._debugSource;
            var name = getComponentName(fiber);
            var ownerName = null;

            if (owner) {
              ownerName = getComponentName(owner);
            }

            return describeComponentFrame(name, source, ownerName);

          default:
            return "";
        }
      }

      function getStackAddendumByWorkInProgressFiber(workInProgress) {
        var info = "";
        var node = workInProgress;

        do {
          info += describeFiber(node);
          node = node.return;
        } while (node);

        return info;
      }

      function getCurrentFiberOwnerName() {
        {
          var fiber = ReactDebugCurrentFiber.current;

          if (fiber === null) {
            return null;
          }

          var owner = fiber._debugOwner;

          if (owner !== null && typeof owner !== "undefined") {
            return getComponentName(owner);
          }
        }
        return null;
      }

      function getCurrentFiberStackAddendum() {
        {
          var fiber = ReactDebugCurrentFiber.current;

          if (fiber === null) {
            return null;
          }

          return getStackAddendumByWorkInProgressFiber(fiber);
        }
        return null;
      }

      function resetCurrentFiber() {
        ReactDebugCurrentFrame.getCurrentStack = null;
        ReactDebugCurrentFiber.current = null;
        ReactDebugCurrentFiber.phase = null;
      }

      function setCurrentFiber(fiber) {
        ReactDebugCurrentFrame.getCurrentStack = getCurrentFiberStackAddendum;
        ReactDebugCurrentFiber.current = fiber;
        ReactDebugCurrentFiber.phase = null;
      }

      function setCurrentPhase(phase) {
        ReactDebugCurrentFiber.phase = phase;
      }

      var ReactDebugCurrentFiber = {
        current: null,
        phase: null,
        resetCurrentFiber: resetCurrentFiber,
        setCurrentFiber: setCurrentFiber,
        setCurrentPhase: setCurrentPhase,
        getCurrentFiberOwnerName: getCurrentFiberOwnerName,
        getCurrentFiberStackAddendum: getCurrentFiberStackAddendum
      };
      var debugRenderPhaseSideEffects = false;
      var debugRenderPhaseSideEffectsForStrictMode = false;
      var enableUserTimingAPI = true;
      var enableGetDerivedStateFromCatch = false;
      var enableSuspense = false;
      var warnAboutDeprecatedLifecycles = false;
      var warnAboutLegacyContextAPI = false;
      var replayFailedUnitOfWorkWithInvokeGuardedCallback = true;
      var enableProfilerTimer = true;
      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$$1) {
        var prefix = warning$$1 ? warningEmoji + " " : reactEmoji + " ";
        var suffix = warning$$1 ? " Warning: " + warning$$1 : "";
        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$$1) {
        var formattedMarkName = formatMarkName(markName);
        var formattedLabel = formatLabel(label, warning$$1);

        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) || "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) || "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$$1) {
        var componentName = getComponentName(fiber) || "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$$1);
      };

      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, expirationTime) {
        if (enableUserTimingAPI) {
          if (supportsUserTiming) {
            isWaitingForCallback = false;
            var warning$$1 = didExpire ? "React was blocked by main thread" : null;
            endMark("(Waiting for async callback... will force flush in " + expirationTime + " ms)", "(Waiting for async callback...)", warning$$1);
          }
        }
      }

      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$$1 = "An error was thrown inside this error boundary";
          endFiberMark(fiber, null, warning$$1);
        }
      }

      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$$1 = hasScheduledUpdateInCurrentPhase ? "Scheduled a cascading update" : null;
            endFiberMark(currentPhaseFiber, currentPhase, warning$$1);
          }

          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$$1 = null;

          if (interruptedBy !== null) {
            if (interruptedBy.tag === HostRoot) {
              warning$$1 = "A top-level update interrupted the previous render";
            } else {
              var componentName = getComponentName(interruptedBy) || "Unknown";
              warning$$1 = "An update to " + componentName + " interrupted the previous render";
            }
          } else if (commitCountInCurrentWorkLoop > 1) {
            warning$$1 = "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$$1);
        }
      }

      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$$1 = null;

          if (hasScheduledUpdateInCurrentCommit) {
            warning$$1 = "Lifecycle hook scheduled a cascading update";
          } else if (commitCountInCurrentWorkLoop > 0) {
            warning$$1 = "Caused by a cascading update in earlier commit";
          }

          hasScheduledUpdateInCurrentCommit = false;
          commitCountInCurrentWorkLoop++;
          isCommitting = false;
          labelsInCurrentCommit.clear();
          endMark("(Committing Changes)", "(Committing Changes)", warning$$1);
        }
      }

      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) {
          {
            warning(false, "Unexpected pop.");
          }
          return;
        }

        {
          if (fiber !== fiberStack[index]) {
            warning(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;
      }

      function checkThatStackIsEmpty() {
        {
          if (index !== -1) {
            warning(false, "Expected an empty stack. Something was not reset properly.");
          }
        }
      }

      function resetStackAfterFatalErrorInDev() {
        {
          index = -1;
          valueStack.length = 0;
          fiberStack.length = 0;
        }
      }

      var warnedAboutMissingGetChildContext = void 0;
      {
        warnedAboutMissingGetChildContext = {};
      }
      var contextStackCursor = createCursor(emptyObject);
      var didPerformWorkStackCursor = createCursor(false);
      var previousContext = emptyObject;

      function getUnmaskedContext(workInProgress) {
        var hasOwnContext = isContextProvider(workInProgress);

        if (hasOwnContext) {
          return previousContext;
        }

        return contextStackCursor.current;
      }

      function cacheContext(workInProgress, unmaskedContext, maskedContext) {
        var instance = workInProgress.stateNode;
        instance.__reactInternalMemoizedUnmaskedChildContext = unmaskedContext;
        instance.__reactInternalMemoizedMaskedChildContext = maskedContext;
      }

      function getMaskedContext(workInProgress, unmaskedContext) {
        var type = workInProgress.type;
        var contextTypes = type.contextTypes;

        if (!contextTypes) {
          return emptyObject;
        }

        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(workInProgress) || "Unknown";
          checkPropTypes(contextTypes, context, "context", name, ReactDebugCurrentFiber.getCurrentFiberStackAddendum);
        }

        if (instance) {
          cacheContext(workInProgress, unmaskedContext, context);
        }

        return context;
      }

      function hasContextChanged() {
        return didPerformWorkStackCursor.current;
      }

      function isContextConsumer(fiber) {
        return fiber.tag === ClassComponent && fiber.type.contextTypes != null;
      }

      function isContextProvider(fiber) {
        return fiber.tag === ClassComponent && fiber.type.childContextTypes != null;
      }

      function popContextProvider(fiber) {
        if (!isContextProvider(fiber)) {
          return;
        }

        pop(didPerformWorkStackCursor, fiber);
        pop(contextStackCursor, fiber);
      }

      function popTopLevelContextObject(fiber) {
        pop(didPerformWorkStackCursor, fiber);
        pop(contextStackCursor, fiber);
      }

      function pushTopLevelContextObject(fiber, context, didChange) {
        invariant(contextStackCursor.current === emptyObject, "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, parentContext) {
        var instance = fiber.stateNode;
        var childContextTypes = fiber.type.childContextTypes;

        if (typeof instance.getChildContext !== "function") {
          {
            var componentName = getComponentName(fiber) || "Unknown";

            if (!warnedAboutMissingGetChildContext[componentName]) {
              warnedAboutMissingGetChildContext[componentName] = true;
              warning(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;
        {
          ReactDebugCurrentFiber.setCurrentPhase("getChildContext");
        }
        startPhaseTimer(fiber, "getChildContext");
        childContext = instance.getChildContext();
        stopPhaseTimer();
        {
          ReactDebugCurrentFiber.setCurrentPhase(null);
        }

        for (var contextKey in childContext) {
          invariant(contextKey in childContextTypes, '%s.getChildContext(): key "%s" is not defined in childContextTypes.', getComponentName(fiber) || "Unknown", contextKey);
        }

        {
          var name = getComponentName(fiber) || "Unknown";
          checkPropTypes(childContextTypes, childContext, "child context", name, ReactDebugCurrentFiber.getCurrentFiberStackAddendum);
        }
        return _extends({}, parentContext, childContext);
      }

      function pushContextProvider(workInProgress) {
        if (!isContextProvider(workInProgress)) {
          return false;
        }

        var instance = workInProgress.stateNode;
        var memoizedMergedChildContext = instance && instance.__reactInternalMemoizedMergedChildContext || emptyObject;
        previousContext = contextStackCursor.current;
        push(contextStackCursor, memoizedMergedChildContext, workInProgress);
        push(didPerformWorkStackCursor, didPerformWorkStackCursor.current, workInProgress);
        return true;
      }

      function invalidateContextProvider(workInProgress, didChange) {
        var instance = workInProgress.stateNode;
        invariant(instance, "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, 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) {
        invariant(isFiberMounted(fiber) && fiber.tag === ClassComponent, "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;

        while (node.tag !== HostRoot) {
          if (isContextProvider(node)) {
            return node.stateNode.__reactInternalMemoizedMergedChildContext;
          }

          var parent = node.return;
          invariant(parent, "Found unexpected detached subtree parent. " + "This error is likely caused by a bug in React. Please file an issue.");
          node = parent;
        }

        return node.stateNode.context;
      }

      var MAX_SIGNED_31_BIT_INT = 1073741823;
      var NoWork = 0;
      var Sync = 1;
      var Never = MAX_SIGNED_31_BIT_INT;
      var UNIT_SIZE = 10;
      var MAGIC_NUMBER_OFFSET = 2;

      function msToExpirationTime(ms) {
        return (ms / UNIT_SIZE | 0) + MAGIC_NUMBER_OFFSET;
      }

      function expirationTimeToMs(expirationTime) {
        return (expirationTime - MAGIC_NUMBER_OFFSET) * UNIT_SIZE;
      }

      function ceiling(num, precision) {
        return ((num / precision | 0) + 1) * precision;
      }

      function computeExpirationBucket(currentTime, expirationInMs, bucketSizeMs) {
        return MAGIC_NUMBER_OFFSET + ceiling(currentTime - MAGIC_NUMBER_OFFSET + expirationInMs / UNIT_SIZE, bucketSizeMs / UNIT_SIZE);
      }

      var NoContext = 0;
      var AsyncMode = 1;
      var StrictMode = 2;
      var ProfileMode = 4;
      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.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.mode = mode;
        this.effectTag = NoEffect;
        this.nextEffect = null;
        this.firstEffect = null;
        this.lastEffect = null;
        this.expirationTime = NoWork;
        this.alternate = null;

        if (enableProfilerTimer) {
          this.actualDuration = 0;
          this.actualStartTime = 0;
          this.selfBaseTime = 0;
          this.treeBaseTime = 0;
        }

        {
          this._debugID = debugCounter++;
          this._debugSource = null;
          this._debugOwner = null;
          this._debugIsCurrentlyTiming = false;

          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) {
        return !!(Component.prototype && Component.prototype.isReactComponent);
      }

      function createWorkInProgress(current, pendingProps, expirationTime) {
        var workInProgress = current.alternate;

        if (workInProgress === null) {
          workInProgress = createFiber(current.tag, pendingProps, current.key, current.mode);
          workInProgress.type = current.type;
          workInProgress.stateNode = current.stateNode;
          {
            workInProgress._debugID = current._debugID;
            workInProgress._debugSource = current._debugSource;
            workInProgress._debugOwner = current._debugOwner;
          }
          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 = 0;
          }
        }

        workInProgress.expirationTime = expirationTime;
        workInProgress.child = current.child;
        workInProgress.memoizedProps = current.memoizedProps;
        workInProgress.memoizedState = current.memoizedState;
        workInProgress.updateQueue = current.updateQueue;
        workInProgress.sibling = current.sibling;
        workInProgress.index = current.index;
        workInProgress.ref = current.ref;

        if (enableProfilerTimer) {
          workInProgress.selfBaseTime = current.selfBaseTime;
          workInProgress.treeBaseTime = current.treeBaseTime;
        }

        return workInProgress;
      }

      function createHostRootFiber(isAsync) {
        var mode = isAsync ? AsyncMode | StrictMode : NoContext;
        return createFiber(HostRoot, null, null, mode);
      }

      function createFiberFromElement(element, mode, expirationTime) {
        var owner = null;
        {
          owner = element._owner;
        }
        var fiber = void 0;
        var type = element.type;
        var key = element.key;
        var pendingProps = element.props;
        var fiberTag = void 0;

        if (typeof type === "function") {
          fiberTag = shouldConstruct(type) ? ClassComponent : IndeterminateComponent;
        } else if (typeof type === "string") {
          fiberTag = HostComponent;
        } else {
          switch (type) {
            case REACT_FRAGMENT_TYPE:
              return createFiberFromFragment(pendingProps.children, mode, expirationTime, key);

            case REACT_ASYNC_MODE_TYPE:
              fiberTag = Mode;
              mode |= AsyncMode | StrictMode;
              break;

            case REACT_STRICT_MODE_TYPE:
              fiberTag = Mode;
              mode |= StrictMode;
              break;

            case REACT_PROFILER_TYPE:
              return createFiberFromProfiler(pendingProps, mode, expirationTime, key);

            case REACT_TIMEOUT_TYPE:
              fiberTag = TimeoutComponent;
              mode |= StrictMode;
              break;

            default:
              fiberTag = getFiberTagFromObjectType(type, owner);
              break;
          }
        }

        fiber = createFiber(fiberTag, pendingProps, key, mode);
        fiber.type = type;
        fiber.expirationTime = expirationTime;
        {
          fiber._debugSource = element._source;
          fiber._debugOwner = element._owner;
        }
        return fiber;
      }

      function getFiberTagFromObjectType(type, owner) {
        var $$typeof = typeof type === "object" && type !== null ? type.$$typeof : null;

        switch ($$typeof) {
          case REACT_PROVIDER_TYPE:
            return ContextProvider;

          case REACT_CONTEXT_TYPE:
            return ContextConsumer;

          case REACT_FORWARD_REF_TYPE:
            return ForwardRef;

          default:
            {
              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) : null;

                if (ownerName) {
                  info += "\n\nCheck the render method of `" + ownerName + "`.";
                }
              }
              invariant(false, "Element type is invalid: expected a string (for built-in " + "components) or a class/function (for composite components) " + "but got: %s.%s", type == null ? type : typeof type, info);
            }
        }
      }

      function createFiberFromFragment(elements, mode, expirationTime, key) {
        var fiber = createFiber(Fragment, elements, key, mode);
        fiber.expirationTime = expirationTime;
        return fiber;
      }

      function createFiberFromProfiler(pendingProps, mode, expirationTime, key) {
        {
          if (typeof pendingProps.id !== "string" || typeof pendingProps.onRender !== "function") {
            invariant(false, 'Profiler must specify an "id" string and "onRender" function as props');
          }
        }
        var fiber = createFiber(Profiler, pendingProps, key, mode | ProfileMode);
        fiber.type = REACT_PROFILER_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, NoContext);
        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, NoContext);
        }

        target.tag = source.tag;
        target.key = source.key;
        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.mode = source.mode;
        target.effectTag = source.effectTag;
        target.nextEffect = source.nextEffect;
        target.firstEffect = source.firstEffect;
        target.lastEffect = source.lastEffect;
        target.expirationTime = source.expirationTime;
        target.alternate = source.alternate;

        if (enableProfilerTimer) {
          target.actualDuration = source.actualDuration;
          target.actualStartTime = source.actualStartTime;
          target.selfBaseTime = source.selfBaseTime;
          target.treeBaseTime = source.treeBaseTime;
        }

        target._debugID = source._debugID;
        target._debugSource = source._debugSource;
        target._debugOwner = source._debugOwner;
        target._debugIsCurrentlyTiming = source._debugIsCurrentlyTiming;
        return target;
      }

      function createFiberRoot(containerInfo, isAsync, hydrate) {
        var uninitializedFiber = createHostRootFiber(isAsync);
        var root = {
          current: uninitializedFiber,
          containerInfo: containerInfo,
          pendingChildren: null,
          earliestPendingTime: NoWork,
          latestPendingTime: NoWork,
          earliestSuspendedTime: NoWork,
          latestSuspendedTime: NoWork,
          latestPingedTime: NoWork,
          didError: false,
          pendingCommitExpirationTime: NoWork,
          finishedWork: null,
          context: null,
          pendingContext: null,
          hydrate: hydrate,
          nextExpirationTimeToWorkOn: NoWork,
          expirationTime: NoWork,
          firstBatch: null,
          nextScheduledRoot: null
        };
        uninitializedFiber.stateNode = root;
        return root;
      }

      var onCommitFiberRoot = null;
      var onCommitFiberUnmount = null;
      var hasLoggedError = false;

      function catchErrors(fn) {
        return function (arg) {
          try {
            return fn(arg);
          } catch (err) {
            if (true && !hasLoggedError) {
              hasLoggedError = true;
              warning(false, "React DevTools encountered an error: %s", err);
            }
          }
        };
      }

      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) {
          {
            warning(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 = catchErrors(function (root) {
            return hook.onCommitFiberRoot(rendererID, root);
          });
          onCommitFiberUnmount = catchErrors(function (fiber) {
            return hook.onCommitFiberUnmount(rendererID, fiber);
          });
        } catch (err) {
          {
            warning(false, "React DevTools encountered an error: %s.", err);
          }
        }

        return true;
      }

      function onCommitRoot(root) {
        if (typeof onCommitFiberRoot === "function") {
          onCommitFiberRoot(root);
        }
      }

      function onCommitUnmount(fiber) {
        if (typeof onCommitFiberUnmount === "function") {
          onCommitFiberUnmount(fiber);
        }
      }

      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("`warning(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 = {
        discardPendingWarnings: function discardPendingWarnings() {},
        flushPendingDeprecationWarnings: function flushPendingDeprecationWarnings() {},
        flushPendingUnsafeLifecycleWarnings: function flushPendingUnsafeLifecycleWarnings() {},
        recordDeprecationWarnings: function recordDeprecationWarnings(fiber, instance) {},
        recordUnsafeLifecycleWarnings: function recordUnsafeLifecycleWarnings(fiber, instance) {},
        recordLegacyContextWarning: function recordLegacyContextWarning(fiber, instance) {},
        flushLegacyContextWarning: function flushLegacyContextWarning() {}
      };
      {
        var LIFECYCLE_SUGGESTIONS = {
          UNSAFE_componentWillMount: "componentDidMount",
          UNSAFE_componentWillReceiveProps: "static getDerivedStateFromProps",
          UNSAFE_componentWillUpdate: "componentDidUpdate"
        };
        var pendingComponentWillMountWarnings = [];
        var pendingComponentWillReceivePropsWarnings = [];
        var pendingComponentWillUpdateWarnings = [];
        var pendingUnsafeLifecycleWarnings = new Map();
        var pendingLegacyContextWarning = new Map();
        var didWarnAboutDeprecatedLifecycles = new Set();
        var didWarnAboutUnsafeLifecycles = new Set();
        var didWarnAboutLegacyContext = new Set();

        var setToSortedString = function setToSortedString(set) {
          var array = [];
          set.forEach(function (value) {
            array.push(value);
          });
          return array.sort().join(", ");
        };

        ReactStrictModeWarnings.discardPendingWarnings = function () {
          pendingComponentWillMountWarnings = [];
          pendingComponentWillReceivePropsWarnings = [];
          pendingComponentWillUpdateWarnings = [];
          pendingUnsafeLifecycleWarnings = new Map();
          pendingLegacyContextWarning = new Map();
        };

        ReactStrictModeWarnings.flushPendingUnsafeLifecycleWarnings = function () {
          pendingUnsafeLifecycleWarnings.forEach(function (lifecycleWarningsMap, strictRoot) {
            var lifecyclesWarningMesages = [];
            Object.keys(lifecycleWarningsMap).forEach(function (lifecycle) {
              var lifecycleWarnings = lifecycleWarningsMap[lifecycle];

              if (lifecycleWarnings.length > 0) {
                var componentNames = new Set();
                lifecycleWarnings.forEach(function (fiber) {
                  componentNames.add(getComponentName(fiber) || "Component");
                  didWarnAboutUnsafeLifecycles.add(fiber.type);
                });
                var formatted = lifecycle.replace("UNSAFE_", "");
                var suggestion = LIFECYCLE_SUGGESTIONS[lifecycle];
                var sortedComponentNames = setToSortedString(componentNames);
                lifecyclesWarningMesages.push(formatted + ": Please update the following components to use " + (suggestion + " instead: " + sortedComponentNames));
              }
            });

            if (lifecyclesWarningMesages.length > 0) {
              var strictRootComponentStack = getStackAddendumByWorkInProgressFiber(strictRoot);
              warning(false, "Unsafe lifecycle methods were found within a strict-mode tree:%s" + "\n\n%s" + "\n\nLearn more about this warning here:" + "\nhttps://fb.me/react-strict-mode-warnings", strictRootComponentStack, lifecyclesWarningMesages.join("\n\n"));
            }
          });
          pendingUnsafeLifecycleWarnings = new Map();
        };

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

        ReactStrictModeWarnings.flushPendingDeprecationWarnings = function () {
          if (pendingComponentWillMountWarnings.length > 0) {
            var uniqueNames = new Set();
            pendingComponentWillMountWarnings.forEach(function (fiber) {
              uniqueNames.add(getComponentName(fiber) || "Component");
              didWarnAboutDeprecatedLifecycles.add(fiber.type);
            });
            var sortedNames = setToSortedString(uniqueNames);
            lowPriorityWarning$1(false, "componentWillMount is deprecated and will be removed in the next major version. " + "Use componentDidMount instead. As a temporary workaround, " + "you can rename to UNSAFE_componentWillMount." + "\n\nPlease update the following components: %s" + "\n\nLearn more about this warning here:" + "\nhttps://fb.me/react-async-component-lifecycle-hooks", sortedNames);
            pendingComponentWillMountWarnings = [];
          }

          if (pendingComponentWillReceivePropsWarnings.length > 0) {
            var _uniqueNames = new Set();

            pendingComponentWillReceivePropsWarnings.forEach(function (fiber) {
              _uniqueNames.add(getComponentName(fiber) || "Component");

              didWarnAboutDeprecatedLifecycles.add(fiber.type);
            });

            var _sortedNames = setToSortedString(_uniqueNames);

            lowPriorityWarning$1(false, "componentWillReceiveProps is deprecated and will be removed in the next major version. " + "Use static getDerivedStateFromProps instead." + "\n\nPlease update the following components: %s" + "\n\nLearn more about this warning here:" + "\nhttps://fb.me/react-async-component-lifecycle-hooks", _sortedNames);
            pendingComponentWillReceivePropsWarnings = [];
          }

          if (pendingComponentWillUpdateWarnings.length > 0) {
            var _uniqueNames2 = new Set();

            pendingComponentWillUpdateWarnings.forEach(function (fiber) {
              _uniqueNames2.add(getComponentName(fiber) || "Component");

              didWarnAboutDeprecatedLifecycles.add(fiber.type);
            });

            var _sortedNames2 = setToSortedString(_uniqueNames2);

            lowPriorityWarning$1(false, "componentWillUpdate is deprecated and will be removed in the next major version. " + "Use componentDidUpdate instead. As a temporary workaround, " + "you can rename to UNSAFE_componentWillUpdate." + "\n\nPlease update the following components: %s" + "\n\nLearn more about this warning here:" + "\nhttps://fb.me/react-async-component-lifecycle-hooks", _sortedNames2);
            pendingComponentWillUpdateWarnings = [];
          }
        };

        ReactStrictModeWarnings.recordDeprecationWarnings = function (fiber, instance) {
          if (didWarnAboutDeprecatedLifecycles.has(fiber.type)) {
            return;
          }

          if (typeof instance.componentWillMount === "function" && instance.componentWillMount.__suppressDeprecationWarning !== true) {
            pendingComponentWillMountWarnings.push(fiber);
          }

          if (typeof instance.componentWillReceiveProps === "function" && instance.componentWillReceiveProps.__suppressDeprecationWarning !== true) {
            pendingComponentWillReceivePropsWarnings.push(fiber);
          }

          if (typeof instance.componentWillUpdate === "function" && instance.componentWillUpdate.__suppressDeprecationWarning !== true) {
            pendingComponentWillUpdateWarnings.push(fiber);
          }
        };

        ReactStrictModeWarnings.recordUnsafeLifecycleWarnings = function (fiber, instance) {
          var strictRoot = findStrictRoot(fiber);

          if (strictRoot === null) {
            warning(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 (didWarnAboutUnsafeLifecycles.has(fiber.type)) {
            return;
          }

          var warningsForRoot = void 0;

          if (!pendingUnsafeLifecycleWarnings.has(strictRoot)) {
            warningsForRoot = {
              UNSAFE_componentWillMount: [],
              UNSAFE_componentWillReceiveProps: [],
              UNSAFE_componentWillUpdate: []
            };
            pendingUnsafeLifecycleWarnings.set(strictRoot, warningsForRoot);
          } else {
            warningsForRoot = pendingUnsafeLifecycleWarnings.get(strictRoot);
          }

          var unsafeLifecycles = [];

          if (typeof instance.componentWillMount === "function" && instance.componentWillMount.__suppressDeprecationWarning !== true || typeof instance.UNSAFE_componentWillMount === "function") {
            unsafeLifecycles.push("UNSAFE_componentWillMount");
          }

          if (typeof instance.componentWillReceiveProps === "function" && instance.componentWillReceiveProps.__suppressDeprecationWarning !== true || typeof instance.UNSAFE_componentWillReceiveProps === "function") {
            unsafeLifecycles.push("UNSAFE_componentWillReceiveProps");
          }

          if (typeof instance.componentWillUpdate === "function" && instance.componentWillUpdate.__suppressDeprecationWarning !== true || typeof instance.UNSAFE_componentWillUpdate === "function") {
            unsafeLifecycles.push("UNSAFE_componentWillUpdate");
          }

          if (unsafeLifecycles.length > 0) {
            unsafeLifecycles.forEach(function (lifecycle) {
              warningsForRoot[lifecycle].push(fiber);
            });
          }
        };

        ReactStrictModeWarnings.recordLegacyContextWarning = function (fiber, instance) {
          var strictRoot = findStrictRoot(fiber);

          if (strictRoot === null) {
            warning(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) || "Component");
              didWarnAboutLegacyContext.add(fiber.type);
            });
            var sortedNames = setToSortedString(uniqueNames);
            var strictRootComponentStack = getStackAddendumByWorkInProgressFiber(strictRoot);
            warning(false, "Legacy context API has been detected within a strict-mode tree: %s" + "\n\nPlease update the following components: %s" + "\n\nLearn more about this warning here:" + "\nhttps://fb.me/react-strict-mode-warnings", strictRootComponentStack, sortedNames);
          });
        };
      }
      var ReactFiberInstrumentation = {
        debugTool: null
      };
      var ReactFiberInstrumentation_1 = ReactFiberInstrumentation;

      function markPendingPriorityLevel(root, expirationTime) {
        root.didError = false;
        var earliestPendingTime = root.earliestPendingTime;

        if (earliestPendingTime === NoWork) {
          root.earliestPendingTime = root.latestPendingTime = expirationTime;
        } else {
          if (earliestPendingTime > expirationTime) {
            root.earliestPendingTime = expirationTime;
          } else {
            var latestPendingTime = root.latestPendingTime;

            if (latestPendingTime < expirationTime) {
              root.latestPendingTime = expirationTime;
            }
          }
        }

        findNextPendingPriorityLevel(root);
      }

      function markCommittedPriorityLevels(root, currentTime, earliestRemainingTime) {
        root.didError = false;

        if (earliestRemainingTime === NoWork) {
          root.earliestPendingTime = NoWork;
          root.latestPendingTime = NoWork;
          root.earliestSuspendedTime = NoWork;
          root.latestSuspendedTime = NoWork;
          root.latestPingedTime = NoWork;
          findNextPendingPriorityLevel(root);
          return;
        }

        var latestPendingTime = root.latestPendingTime;

        if (latestPendingTime !== NoWork) {
          if (latestPendingTime < earliestRemainingTime) {
            root.earliestPendingTime = root.latestPendingTime = NoWork;
          } else {
            var earliestPendingTime = root.earliestPendingTime;

            if (earliestPendingTime < earliestRemainingTime) {
              root.earliestPendingTime = root.latestPendingTime;
            }
          }
        }

        var earliestSuspendedTime = root.earliestSuspendedTime;

        if (earliestSuspendedTime === NoWork) {
          markPendingPriorityLevel(root, earliestRemainingTime);
          findNextPendingPriorityLevel(root);
          return;
        }

        var latestSuspendedTime = root.latestSuspendedTime;

        if (earliestRemainingTime > latestSuspendedTime) {
          root.earliestSuspendedTime = NoWork;
          root.latestSuspendedTime = NoWork;
          root.latestPingedTime = NoWork;
          markPendingPriorityLevel(root, earliestRemainingTime);
          findNextPendingPriorityLevel(root);
          return;
        }

        if (earliestRemainingTime < earliestSuspendedTime) {
          markPendingPriorityLevel(root, earliestRemainingTime);
          findNextPendingPriorityLevel(root);
          return;
        }

        findNextPendingPriorityLevel(root);
      }

      function hasLowerPriorityWork(root, renderExpirationTime) {
        return renderExpirationTime !== root.latestPendingTime && renderExpirationTime !== root.latestSuspendedTime;
      }

      function markSuspendedPriorityLevel(root, suspendedTime, didError) {
        if (didError && !hasLowerPriorityWork(root, suspendedTime)) {
          root.didError = true;
          findNextPendingPriorityLevel(root);
          return;
        }

        var earliestPendingTime = root.earliestPendingTime;
        var latestPendingTime = root.latestPendingTime;

        if (earliestPendingTime === suspendedTime) {
          if (latestPendingTime === suspendedTime) {
            root.earliestPendingTime = root.latestPendingTime = NoWork;
          } else {
            root.earliestPendingTime = latestPendingTime;
          }
        } else if (latestPendingTime === suspendedTime) {
          root.latestPendingTime = earliestPendingTime;
        }

        var latestSuspendedTime = root.latestSuspendedTime;

        if (latestSuspendedTime === suspendedTime) {
          root.latestPingedTime = NoWork;
        }

        var earliestSuspendedTime = root.earliestSuspendedTime;

        if (earliestSuspendedTime === NoWork) {
          root.earliestSuspendedTime = root.latestSuspendedTime = suspendedTime;
        } else {
          if (earliestSuspendedTime > suspendedTime) {
            root.earliestSuspendedTime = suspendedTime;
          } else if (latestSuspendedTime < suspendedTime) {
            root.latestSuspendedTime = suspendedTime;
          }
        }

        findNextPendingPriorityLevel(root);
      }

      function markPingedPriorityLevel(root, pingedTime) {
        var latestSuspendedTime = root.latestSuspendedTime;

        if (latestSuspendedTime !== NoWork && latestSuspendedTime <= pingedTime) {
          var latestPingedTime = root.latestPingedTime;

          if (latestPingedTime === NoWork || latestPingedTime < pingedTime) {
            root.latestPingedTime = pingedTime;
          }
        }

        findNextPendingPriorityLevel(root);
      }

      function findNextPendingPriorityLevel(root) {
        var earliestSuspendedTime = root.earliestSuspendedTime;
        var earliestPendingTime = root.earliestPendingTime;
        var nextExpirationTimeToWorkOn = void 0;
        var expirationTime = void 0;

        if (earliestSuspendedTime === NoWork) {
          nextExpirationTimeToWorkOn = expirationTime = earliestPendingTime;
        } else if (earliestPendingTime !== NoWork) {
          nextExpirationTimeToWorkOn = earliestPendingTime;
          expirationTime = earliestSuspendedTime < earliestPendingTime ? earliestSuspendedTime : earliestPendingTime;
        } else {
          nextExpirationTimeToWorkOn = expirationTime = root.latestPingedTime;
        }

        if (root.didError) {
          expirationTime = Sync;
        }

        root.nextExpirationTimeToWorkOn = nextExpirationTimeToWorkOn;
        root.expirationTime = expirationTime;
      }

      var UpdateState = 0;
      var ReplaceState = 1;
      var ForceUpdate = 2;
      var CaptureUpdate = 3;
      var hasForceUpdate = false;
      var didWarnUpdateInsideUpdate = void 0;
      var currentlyProcessingQueue = void 0;
      var resetCurrentlyProcessingQueue = void 0;
      {
        didWarnUpdateInsideUpdate = false;
        currentlyProcessingQueue = null;

        resetCurrentlyProcessingQueue = function resetCurrentlyProcessingQueue() {
          currentlyProcessingQueue = null;
        };
      }

      function createUpdateQueue(baseState) {
        var queue = {
          expirationTime: NoWork,
          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 = {
          expirationTime: currentQueue.expirationTime,
          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) {
        return {
          expirationTime: expirationTime,
          tag: UpdateState,
          payload: null,
          callback: null,
          next: null,
          nextEffect: null
        };
      }

      function appendUpdateToQueue(queue, update, expirationTime) {
        if (queue.lastUpdate === null) {
          queue.firstUpdate = queue.lastUpdate = update;
        } else {
          queue.lastUpdate.next = update;
          queue.lastUpdate = update;
        }

        if (queue.expirationTime === NoWork || queue.expirationTime > expirationTime) {
          queue.expirationTime = expirationTime;
        }
      }

      function enqueueUpdate(fiber, update, expirationTime) {
        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, expirationTime);
        } else {
          if (queue1.lastUpdate === null || queue2.lastUpdate === null) {
            appendUpdateToQueue(queue1, update, expirationTime);
            appendUpdateToQueue(queue2, update, expirationTime);
          } else {
            appendUpdateToQueue(queue1, update, expirationTime);
            queue2.lastUpdate = update;
          }
        }

        {
          if (fiber.tag === ClassComponent && (currentlyProcessingQueue === queue1 || queue2 !== null && currentlyProcessingQueue === queue2) && !didWarnUpdateInsideUpdate) {
            warning(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, renderExpirationTime) {
        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;
        }

        if (workInProgressQueue.expirationTime === NoWork || workInProgressQueue.expirationTime > renderExpirationTime) {
          workInProgressQueue.expirationTime = renderExpirationTime;
        }
      }

      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") {
                {
                  if (debugRenderPhaseSideEffects || debugRenderPhaseSideEffectsForStrictMode && workInProgress.mode & StrictMode) {
                    _payload.call(instance, prevState, nextProps);
                  }
                }
                return _payload.call(instance, prevState, nextProps);
              }

              return _payload;
            }

          case CaptureUpdate:
            {
              workInProgress.effectTag = workInProgress.effectTag & ~ShouldCapture | DidCapture;
            }

          case UpdateState:
            {
              var _payload2 = update.payload;
              var partialState = void 0;

              if (typeof _payload2 === "function") {
                {
                  if (debugRenderPhaseSideEffects || debugRenderPhaseSideEffectsForStrictMode && workInProgress.mode & StrictMode) {
                    _payload2.call(instance, prevState, nextProps);
                  }
                }
                partialState = _payload2.call(instance, prevState, nextProps);
              } 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;

        if (queue.expirationTime === NoWork || queue.expirationTime > renderExpirationTime) {
          return;
        }

        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 === NoWork || newExpirationTime > updateExpirationTime) {
              newExpirationTime = updateExpirationTime;
            }
          } else {
            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 === NoWork || 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;
        queue.expirationTime = newExpirationTime;
        workInProgress.memoizedState = resultState;
        {
          currentlyProcessingQueue = null;
        }
      }

      function callCallback(callback, context) {
        invariant(typeof callback === "function", "Invalid argument passed as callback. Expected a function. Instead " + "received: %s", 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;
        }

        var effect = finishedQueue.firstEffect;
        finishedQueue.firstEffect = finishedQueue.lastEffect = null;

        while (effect !== null) {
          var _callback3 = effect.callback;

          if (_callback3 !== null) {
            effect.callback = null;
            callCallback(_callback3, instance);
          }

          effect = effect.nextEffect;
        }

        effect = finishedQueue.firstCapturedEffect;
        finishedQueue.firstCapturedEffect = finishedQueue.lastCapturedEffect = null;

        while (effect !== null) {
          var _callback4 = effect.callback;

          if (_callback4 !== null) {
            effect.callback = null;
            callCallback(_callback4, instance);
          }

          effect = effect.nextEffect;
        }
      }

      function createCapturedValue(value, source) {
        return {
          value: value,
          source: source,
          stack: getStackAddendumByWorkInProgressFiber(source)
        };
      }

      var providerCursor = createCursor(null);
      var valueCursor = createCursor(null);
      var changedBitsCursor = createCursor(0);
      var rendererSigil = void 0;
      {
        rendererSigil = {};
      }

      function pushProvider(providerFiber) {
        var context = providerFiber.type._context;

        if (isPrimaryRenderer) {
          push(changedBitsCursor, context._changedBits, providerFiber);
          push(valueCursor, context._currentValue, providerFiber);
          push(providerCursor, providerFiber, providerFiber);
          context._currentValue = providerFiber.pendingProps.value;
          context._changedBits = providerFiber.stateNode;
          {
            !(context._currentRenderer === undefined || context._currentRenderer === null || context._currentRenderer === rendererSigil) ? warning(false, "Detected multiple renderers concurrently rendering the " + "same context provider. This is currently unsupported.") : void 0;
            context._currentRenderer = rendererSigil;
          }
        } else {
          push(changedBitsCursor, context._changedBits2, providerFiber);
          push(valueCursor, context._currentValue2, providerFiber);
          push(providerCursor, providerFiber, providerFiber);
          context._currentValue2 = providerFiber.pendingProps.value;
          context._changedBits2 = providerFiber.stateNode;
          {
            !(context._currentRenderer2 === undefined || context._currentRenderer2 === null || context._currentRenderer2 === rendererSigil) ? warning(false, "Detected multiple renderers concurrently rendering the " + "same context provider. This is currently unsupported.") : void 0;
            context._currentRenderer2 = rendererSigil;
          }
        }
      }

      function popProvider(providerFiber) {
        var changedBits = changedBitsCursor.current;
        var currentValue = valueCursor.current;
        pop(providerCursor, providerFiber);
        pop(valueCursor, providerFiber);
        pop(changedBitsCursor, providerFiber);
        var context = providerFiber.type._context;

        if (isPrimaryRenderer) {
          context._currentValue = currentValue;
          context._changedBits = changedBits;
        } else {
          context._currentValue2 = currentValue;
          context._changedBits2 = changedBits;
        }
      }

      function getContextCurrentValue(context) {
        return isPrimaryRenderer ? context._currentValue : context._currentValue2;
      }

      function getContextChangedBits(context) {
        return isPrimaryRenderer ? context._changedBits : context._changedBits2;
      }

      var NO_CONTEXT = {};
      var contextStackCursor$1 = createCursor(NO_CONTEXT);
      var contextFiberStackCursor = createCursor(NO_CONTEXT);
      var rootInstanceStackCursor = createCursor(NO_CONTEXT);

      function requiredContext(c) {
        invariant(c !== NO_CONTEXT, "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 commitTime = 0;

      function getCommitTime() {
        return commitTime;
      }

      function recordCommitTime() {
        if (!enableProfilerTimer) {
          return;
        }

        commitTime = now();
      }

      var fiberStack$1 = void 0;
      {
        fiberStack$1 = [];
      }
      var timerPausedAt = 0;
      var totalElapsedPauseTime = 0;

      function checkActualRenderTimeStackEmpty() {
        if (!enableProfilerTimer) {
          return;
        }

        {
          !(fiberStack$1.length === 0) ? warning(false, "Expected an empty stack. Something was not reset properly.") : void 0;
        }
      }

      function markActualRenderTimeStarted(fiber) {
        if (!enableProfilerTimer) {
          return;
        }

        {
          fiberStack$1.push(fiber);
        }
        fiber.actualDuration = now() - fiber.actualDuration - totalElapsedPauseTime;
        fiber.actualStartTime = now();
      }

      function pauseActualRenderTimerIfRunning() {
        if (!enableProfilerTimer) {
          return;
        }

        if (timerPausedAt === 0) {
          timerPausedAt = now();
        }
      }

      function recordElapsedActualRenderTime(fiber) {
        if (!enableProfilerTimer) {
          return;
        }

        {
          !(fiber === fiberStack$1.pop()) ? warning(false, "Unexpected Fiber (%s) popped.", getComponentName(fiber)) : void 0;
        }
        fiber.actualDuration = now() - totalElapsedPauseTime - fiber.actualDuration;
      }

      function resetActualRenderTimer() {
        if (!enableProfilerTimer) {
          return;
        }

        totalElapsedPauseTime = 0;
      }

      function resumeActualRenderTimerIfPaused() {
        if (!enableProfilerTimer) {
          return;
        }

        if (timerPausedAt > 0) {
          totalElapsedPauseTime += now() - timerPausedAt;
          timerPausedAt = 0;
        }
      }

      var baseStartTime = -1;

      function recordElapsedBaseRenderTimeIfRunning(fiber) {
        if (!enableProfilerTimer) {
          return;
        }

        if (baseStartTime !== -1) {
          fiber.selfBaseTime = now() - baseStartTime;
        }
      }

      function startBaseRenderTimer() {
        if (!enableProfilerTimer) {
          return;
        }

        {
          if (baseStartTime !== -1) {
            warning(false, "Cannot start base timer that is already running. " + "This error is likely caused by a bug in React. " + "Please file an issue.");
          }
        }
        baseStartTime = now();
      }

      function stopBaseRenderTimerIfRunning() {
        if (!enableProfilerTimer) {
          return;
        }

        baseStartTime = -1;
      }

      var hasOwnProperty = Object.prototype.hasOwnProperty;

      function is(x, y) {
        if (x === y) {
          return x !== 0 || y !== 0 || 1 / x === 1 / y;
        } else {
          return x !== x && y !== y;
        }
      }

      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 fakeInternalInstance = {};
      var isArray = Array.isArray;
      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;
      {
        didWarnAboutStateAssignmentForComponent = new Set();
        didWarnAboutUninitializedState = new Set();
        didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate = new Set();
        didWarnAboutLegacyLifecyclesAndDerivedState = new Set();
        didWarnAboutUndefinedDerivedState = 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);
            warning(false, "%s(...): Expected the last optional `callback` argument to be a " + "function. Instead received: %s.", callerName, callback);
          }
        };

        warnOnUndefinedDerivedState = function warnOnUndefinedDerivedState(workInProgress, partialState) {
          if (partialState === undefined) {
            var componentName = getComponentName(workInProgress) || "Component";

            if (!didWarnAboutUndefinedDerivedState.has(componentName)) {
              didWarnAboutUndefinedDerivedState.add(componentName);
              warning(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() {
            invariant(false, "_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, getDerivedStateFromProps, nextProps) {
        var prevState = workInProgress.memoizedState;
        {
          if (debugRenderPhaseSideEffects || debugRenderPhaseSideEffectsForStrictMode && workInProgress.mode & StrictMode) {
            getDerivedStateFromProps(nextProps, prevState);
          }
        }
        var partialState = getDerivedStateFromProps(nextProps, prevState);
        {
          warnOnUndefinedDerivedState(workInProgress, partialState);
        }
        var memoizedState = partialState === null || partialState === undefined ? prevState : _extends({}, prevState, partialState);
        workInProgress.memoizedState = memoizedState;
        var updateQueue = workInProgress.updateQueue;

        if (updateQueue !== null && updateQueue.expirationTime === NoWork) {
          updateQueue.baseState = memoizedState;
        }
      }

      var classComponentUpdater = {
        isMounted: isMounted,
        enqueueSetState: function enqueueSetState(inst, payload, callback) {
          var fiber = get$1(inst);
          var currentTime = recalculateCurrentTime();
          var expirationTime = computeExpirationForFiber(currentTime, fiber);
          var update = createUpdate(expirationTime);
          update.payload = payload;

          if (callback !== undefined && callback !== null) {
            {
              warnOnInvalidCallback(callback, "setState");
            }
            update.callback = callback;
          }

          enqueueUpdate(fiber, update, expirationTime);
          scheduleWork(fiber, expirationTime);
        },
        enqueueReplaceState: function enqueueReplaceState(inst, payload, callback) {
          var fiber = get$1(inst);
          var currentTime = recalculateCurrentTime();
          var expirationTime = computeExpirationForFiber(currentTime, fiber);
          var update = createUpdate(expirationTime);
          update.tag = ReplaceState;
          update.payload = payload;

          if (callback !== undefined && callback !== null) {
            {
              warnOnInvalidCallback(callback, "replaceState");
            }
            update.callback = callback;
          }

          enqueueUpdate(fiber, update, expirationTime);
          scheduleWork(fiber, expirationTime);
        },
        enqueueForceUpdate: function enqueueForceUpdate(inst, callback) {
          var fiber = get$1(inst);
          var currentTime = recalculateCurrentTime();
          var expirationTime = computeExpirationForFiber(currentTime, fiber);
          var update = createUpdate(expirationTime);
          update.tag = ForceUpdate;

          if (callback !== undefined && callback !== null) {
            {
              warnOnInvalidCallback(callback, "forceUpdate");
            }
            update.callback = callback;
          }

          enqueueUpdate(fiber, update, expirationTime);
          scheduleWork(fiber, expirationTime);
        }
      };

      function checkShouldComponentUpdate(workInProgress, oldProps, newProps, oldState, newState, newContext) {
        var instance = workInProgress.stateNode;
        var ctor = workInProgress.type;

        if (typeof instance.shouldComponentUpdate === "function") {
          startPhaseTimer(workInProgress, "shouldComponentUpdate");
          var shouldUpdate = instance.shouldComponentUpdate(newProps, newState, newContext);
          stopPhaseTimer();
          {
            !(shouldUpdate !== undefined) ? warning(false, "%s.shouldComponentUpdate(): Returned undefined instead of a " + "boolean value. Make sure to return true or false.", getComponentName(workInProgress) || "Component") : void 0;
          }
          return shouldUpdate;
        }

        if (ctor.prototype && ctor.prototype.isPureReactComponent) {
          return !shallowEqual(oldProps, newProps) || !shallowEqual(oldState, newState);
        }

        return true;
      }

      function checkClassInstance(workInProgress) {
        var instance = workInProgress.stateNode;
        var type = workInProgress.type;
        {
          var name = getComponentName(workInProgress) || "Component";
          var renderPresent = instance.render;

          if (!renderPresent) {
            if (type.prototype && typeof type.prototype.render === "function") {
              warning(false, "%s(...): No `render` method found on the returned component " + "instance: did you accidentally return an object from the constructor?", name);
            } else {
              warning(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 ? warning(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 ? warning(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 ? warning(false, "propTypes was defined as an instance property on %s. Use a static " + "property to define propTypes instead.", name) : void 0;
          var noInstanceContextTypes = !instance.contextTypes;
          !noInstanceContextTypes ? warning(false, "contextTypes was defined as an instance property on %s. Use a static " + "property to define contextTypes instead.", name) : void 0;
          var noComponentShouldUpdate = typeof instance.componentShouldUpdate !== "function";
          !noComponentShouldUpdate ? warning(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 (type.prototype && type.prototype.isPureReactComponent && typeof instance.shouldComponentUpdate !== "undefined") {
            warning(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(workInProgress) || "A pure component");
          }

          var noComponentDidUnmount = typeof instance.componentDidUnmount !== "function";
          !noComponentDidUnmount ? warning(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 ? warning(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 ? warning(false, "%s has a method called " + "componentWillRecieveProps(). Did you mean componentWillReceiveProps()?", name) : void 0;
          var noUnsafeComponentWillRecieveProps = typeof instance.UNSAFE_componentWillRecieveProps !== "function";
          !noUnsafeComponentWillRecieveProps ? warning(false, "%s has a method called " + "UNSAFE_componentWillRecieveProps(). Did you mean UNSAFE_componentWillReceiveProps()?", name) : void 0;
          var hasMutatedProps = instance.props !== workInProgress.pendingProps;
          !(instance.props === undefined || !hasMutatedProps) ? warning(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 ? warning(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(type)) {
            didWarnAboutGetSnapshotBeforeUpdateWithoutDidUpdate.add(type);
            warning(false, "%s: getSnapshotBeforeUpdate() should be used with componentDidUpdate(). " + "This component defines getSnapshotBeforeUpdate() only.", getComponentName(workInProgress));
          }

          var noInstanceGetDerivedStateFromProps = typeof instance.getDerivedStateFromProps !== "function";
          !noInstanceGetDerivedStateFromProps ? warning(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.getDerivedStateFromCatch !== "function";
          !noInstanceGetDerivedStateFromCatch ? warning(false, "%s: getDerivedStateFromCatch() is defined as an instance method " + "and will be ignored. Instead, declare it as a static method.", name) : void 0;
          var noStaticGetSnapshotBeforeUpdate = typeof type.getSnapshotBeforeUpdate !== "function";
          !noStaticGetSnapshotBeforeUpdate ? warning(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(_state))) {
            warning(false, "%s.state: must be set to an object or null", name);
          }

          if (typeof instance.getChildContext === "function") {
            !(typeof type.childContextTypes === "object") ? warning(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, props, renderExpirationTime) {
        var ctor = workInProgress.type;
        var unmaskedContext = getUnmaskedContext(workInProgress);
        var needsContext = isContextConsumer(workInProgress);
        var context = needsContext ? getMaskedContext(workInProgress, unmaskedContext) : emptyObject;
        {
          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(workInProgress) || "Component";

            if (!didWarnAboutUninitializedState.has(componentName)) {
              didWarnAboutUninitializedState.add(componentName);
              warning(false, "%s: Did not properly initialize state during construction. " + "Expected state to be an object, but it was %s.", componentName, instance.state === null ? "null" : "undefined");
            }
          }

          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(workInProgress) || "Component";

              var newApiName = typeof ctor.getDerivedStateFromProps === "function" ? "getDerivedStateFromProps()" : "getSnapshotBeforeUpdate()";

              if (!didWarnAboutLegacyLifecyclesAndDerivedState.has(_componentName)) {
                didWarnAboutLegacyLifecyclesAndDerivedState.add(_componentName);
                warning(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 (needsContext) {
          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) {
          {
            warning(false, "%s.componentWillMount(): Assigning directly to this.state is " + "deprecated (except inside a component's " + "constructor). Use setState instead.", getComponentName(workInProgress) || "Component");
          }
          classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
        }
      }

      function callComponentWillReceiveProps(workInProgress, instance, newProps, newContext) {
        var oldState = instance.state;
        startPhaseTimer(workInProgress, "componentWillReceiveProps");

        if (typeof instance.componentWillReceiveProps === "function") {
          instance.componentWillReceiveProps(newProps, newContext);
        }

        if (typeof instance.UNSAFE_componentWillReceiveProps === "function") {
          instance.UNSAFE_componentWillReceiveProps(newProps, newContext);
        }

        stopPhaseTimer();

        if (instance.state !== oldState) {
          {
            var componentName = getComponentName(workInProgress) || "Component";

            if (!didWarnAboutStateAssignmentForComponent.has(componentName)) {
              didWarnAboutStateAssignmentForComponent.add(componentName);
              warning(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, renderExpirationTime) {
        var ctor = workInProgress.type;
        {
          checkClassInstance(workInProgress);
        }
        var instance = workInProgress.stateNode;
        var props = workInProgress.pendingProps;
        var unmaskedContext = getUnmaskedContext(workInProgress);
        instance.props = props;
        instance.state = workInProgress.memoizedState;
        instance.refs = emptyObject;
        instance.context = getMaskedContext(workInProgress, unmaskedContext);
        {
          if (workInProgress.mode & StrictMode) {
            ReactStrictModeWarnings.recordUnsafeLifecycleWarnings(workInProgress, instance);
            ReactStrictModeWarnings.recordLegacyContextWarning(workInProgress, instance);
          }

          if (warnAboutDeprecatedLifecycles) {
            ReactStrictModeWarnings.recordDeprecationWarnings(workInProgress, instance);
          }
        }
        var updateQueue = workInProgress.updateQueue;

        if (updateQueue !== null) {
          processUpdateQueue(workInProgress, updateQueue, props, instance, renderExpirationTime);
          instance.state = workInProgress.memoizedState;
        }

        var getDerivedStateFromProps = workInProgress.type.getDerivedStateFromProps;

        if (typeof getDerivedStateFromProps === "function") {
          applyDerivedStateFromProps(workInProgress, getDerivedStateFromProps, props);
          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, props, instance, renderExpirationTime);
            instance.state = workInProgress.memoizedState;
          }
        }

        if (typeof instance.componentDidMount === "function") {
          workInProgress.effectTag |= Update;
        }
      }

      function resumeMountClassInstance(workInProgress, renderExpirationTime) {
        var ctor = workInProgress.type;
        var instance = workInProgress.stateNode;
        var oldProps = workInProgress.memoizedProps;
        var newProps = workInProgress.pendingProps;
        instance.props = oldProps;
        var oldContext = instance.context;
        var newUnmaskedContext = getUnmaskedContext(workInProgress);
        var newContext = getMaskedContext(workInProgress, newUnmaskedContext);
        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 !== newContext) {
            callComponentWillReceiveProps(workInProgress, instance, newProps, newContext);
          }
        }

        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, getDerivedStateFromProps, newProps);
          newState = workInProgress.memoizedState;
        }

        var shouldUpdate = checkHasForceUpdateAfterProcessing() || checkShouldComponentUpdate(workInProgress, oldProps, newProps, oldState, newState, newContext);

        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 = newContext;
        return shouldUpdate;
      }

      function updateClassInstance(current, workInProgress, renderExpirationTime) {
        var ctor = workInProgress.type;
        var instance = workInProgress.stateNode;
        var oldProps = workInProgress.memoizedProps;
        var newProps = workInProgress.pendingProps;
        instance.props = oldProps;
        var oldContext = instance.context;
        var newUnmaskedContext = getUnmaskedContext(workInProgress);
        var newContext = getMaskedContext(workInProgress, newUnmaskedContext);
        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 !== newContext) {
            callComponentWillReceiveProps(workInProgress, instance, newProps, newContext);
          }
        }

        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, getDerivedStateFromProps, newProps);
          newState = workInProgress.memoizedState;
        }

        var shouldUpdate = checkHasForceUpdateAfterProcessing() || checkShouldComponentUpdate(workInProgress, oldProps, newProps, oldState, newState, newContext);

        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, newContext);
            }

            if (typeof instance.UNSAFE_componentWillUpdate === "function") {
              instance.UNSAFE_componentWillUpdate(newProps, newState, newContext);
            }

            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 = newContext;
        return shouldUpdate;
      }

      var getCurrentFiberStackAddendum$2 = ReactDebugCurrentFiber.getCurrentFiberStackAddendum;
      var didWarnAboutMaps = void 0;
      var didWarnAboutStringRefInStrictMode = void 0;
      var ownerHasKeyUseWarning = void 0;
      var ownerHasFunctionTypeWarning = void 0;

      var warnForMissingKey = function warnForMissingKey(child) {};

      {
        didWarnAboutMaps = false;
        didWarnAboutStringRefInStrictMode = {};
        ownerHasKeyUseWarning = {};
        ownerHasFunctionTypeWarning = {};

        warnForMissingKey = function warnForMissingKey(child) {
          if (child === null || typeof child !== "object") {
            return;
          }

          if (!child._store || child._store.validated || child.key != null) {
            return;
          }

          invariant(typeof child._store === "object", "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 an array or iterator should have a unique " + '"key" prop. See https://fb.me/react-warning-keys for ' + "more information." + (getCurrentFiberStackAddendum$2() || "");

          if (ownerHasKeyUseWarning[currentComponentErrorInfo]) {
            return;
          }

          ownerHasKeyUseWarning[currentComponentErrorInfo] = true;
          warning(false, "Each child in an array or iterator should have a unique " + '"key" prop. See https://fb.me/react-warning-keys for ' + "more information.%s", getCurrentFiberStackAddendum$2());
        };
      }
      var isArray$1 = Array.isArray;

      function coerceRef(returnFiber, current, element) {
        var mixedRef = element.ref;

        if (mixedRef !== null && typeof mixedRef !== "function" && typeof mixedRef !== "object") {
          {
            if (returnFiber.mode & StrictMode) {
              var componentName = getComponentName(returnFiber) || "Component";

              if (!didWarnAboutStringRefInStrictMode[componentName]) {
                warning(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 createRef() instead." + "\n%s" + "\n\nLearn more about using refs safely here:" + "\nhttps://fb.me/react-strict-mode-string-ref", mixedRef, getStackAddendumByWorkInProgressFiber(returnFiber));
                didWarnAboutStringRefInStrictMode[componentName] = true;
              }
            }
          }

          if (element._owner) {
            var owner = element._owner;
            var inst = void 0;

            if (owner) {
              var ownerFiber = owner;
              invariant(ownerFiber.tag === ClassComponent, "Stateless function components cannot have refs.");
              inst = ownerFiber.stateNode;
            }

            invariant(inst, "Missing owner for string ref %s. This error is likely caused by a " + "bug in React. Please file an issue.", mixedRef);
            var stringRef = "" + mixedRef;

            if (current !== null && current.ref !== null && typeof current.ref === "function" && current.ref._stringRef === stringRef) {
              return current.ref;
            }

            var ref = function ref(value) {
              var refs = inst.refs === emptyObject ? inst.refs = {} : inst.refs;

              if (value === null) {
                delete refs[stringRef];
              } else {
                refs[stringRef] = value;
              }
            };

            ref._stringRef = stringRef;
            return ref;
          } else {
            invariant(typeof mixedRef === "string", "Expected ref to be a function or a string.");
            invariant(element._owner, "Element ref was specified as a string (%s) but no owner was set. This could happen for one of" + " the following reasons:\n" + "1. You may be adding a ref to a functional component\n" + "2. You may be adding a ref to a component that was not created inside a component's render method\n" + "3. You have multiple copies of React loaded\n" + "See https://fb.me/react-refs-must-have-owner for more information.", mixedRef);
          }
        }

        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." + (getCurrentFiberStackAddendum$2() || "");
          }
          invariant(false, "Objects are not valid as a React child (found: %s).%s", 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." + (getCurrentFiberStackAddendum$2() || "");

        if (ownerHasFunctionTypeWarning[currentComponentErrorInfo]) {
          return;
        }

        ownerHasFunctionTypeWarning[currentComponentErrorInfo] = true;
        warning(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.%s", getCurrentFiberStackAddendum$2() || "");
      }

      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 = newFiber.alternate;

          if (current !== null) {
            var oldIndex = current.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, textContent, expirationTime) {
          if (current === null || current.tag !== HostText) {
            var created = createFiberFromText(textContent, returnFiber.mode, expirationTime);
            created.return = returnFiber;
            return created;
          } else {
            var existing = useFiber(current, textContent, expirationTime);
            existing.return = returnFiber;
            return existing;
          }
        }

        function updateElement(returnFiber, current, element, expirationTime) {
          if (current !== null && current.type === element.type) {
            var existing = useFiber(current, element.props, expirationTime);
            existing.ref = coerceRef(returnFiber, current, 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, element);
            created.return = returnFiber;
            return created;
          }
        }

        function updatePortal(returnFiber, current, portal, expirationTime) {
          if (current === null || current.tag !== HostPortal || current.stateNode.containerInfo !== portal.containerInfo || current.stateNode.implementation !== portal.implementation) {
            var created = createFiberFromPortal(portal, returnFiber.mode, expirationTime);
            created.return = returnFiber;
            return created;
          } else {
            var existing = useFiber(current, portal.children || [], expirationTime);
            existing.return = returnFiber;
            return existing;
          }
        }

        function updateFragment(returnFiber, current, fragment, expirationTime, key) {
          if (current === null || current.tag !== Fragment) {
            var created = createFiberFromFragment(fragment, returnFiber.mode, expirationTime, key);
            created.return = returnFiber;
            return created;
          } else {
            var existing = useFiber(current, 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$1(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$1(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$1(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(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.%s", key, getCurrentFiberStackAddendum$2());
                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) {
                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) {
              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);
          invariant(typeof iteratorFn === "function", "An object is not an iterable. This error is likely caused by a bug in " + "React. Please file an issue.");
          {
            if (newChildrenIterable.entries === iteratorFn) {
              !didWarnAboutMaps ? warning(false, "Using Maps as children is unsupported and will likely yield " + "unexpected results. Convert it to a sequence/iterable of keyed " + "ReactElements instead.%s", getCurrentFiberStackAddendum$2()) : 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);
          invariant(newChildren != null, "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) {
                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.type === element.type) {
                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$1(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 FunctionalComponent:
                {
                  var Component = returnFiber.type;
                  invariant(false, "%s(...): Nothing was returned from render. This usually means a " + "return statement is missing. Or, to render nothing, " + "return null.", Component.displayName || Component.name || "Component");
                }
            }
          }

          return deleteRemainingChildren(returnFiber, currentFirstChild);
        }

        return reconcileChildFibers;
      }

      var reconcileChildFibers = ChildReconciler(true);
      var mountChildFibers = ChildReconciler(false);

      function cloneChildFibers(current, workInProgress) {
        invariant(current === null || workInProgress.child === current.child, "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;
      }

      var hydrationParentFiber = null;
      var nextHydratableInstance = null;
      var isHydrating = false;

      function enterHydrationState(fiber) {
        if (!supportsHydration) {
          return false;
        }

        var parentInstance = fiber.stateNode.containerInfo;
        nextHydratableInstance = getFirstHydratableChild(parentInstance);
        hydrationParentFiber = 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;
                }

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

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

          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) {
          invariant(false, "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) {
          invariant(false, "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 popToNextHostParent(fiber) {
        var parent = fiber.return;

        while (parent !== null && parent.tag !== HostComponent && parent.tag !== HostRoot) {
          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 getCurrentFiberStackAddendum$1 = ReactDebugCurrentFiber.getCurrentFiberStackAddendum;
      var didWarnAboutBadClass = void 0;
      var didWarnAboutGetDerivedStateOnFunctionalComponent = void 0;
      var didWarnAboutStatelessRefs = void 0;
      {
        didWarnAboutBadClass = {};
        didWarnAboutGetDerivedStateOnFunctionalComponent = {};
        didWarnAboutStatelessRefs = {};
      }

      function reconcileChildren(current, workInProgress, nextChildren) {
        reconcileChildrenAtExpirationTime(current, workInProgress, nextChildren, workInProgress.expirationTime);
      }

      function reconcileChildrenAtExpirationTime(current, workInProgress, nextChildren, renderExpirationTime) {
        if (current === null) {
          workInProgress.child = mountChildFibers(workInProgress, null, nextChildren, renderExpirationTime);
        } else {
          workInProgress.child = reconcileChildFibers(workInProgress, current.child, nextChildren, renderExpirationTime);
        }
      }

      function updateForwardRef(current, workInProgress) {
        var render = workInProgress.type.render;
        var nextProps = workInProgress.pendingProps;
        var ref = workInProgress.ref;

        if (hasContextChanged()) {} else if (workInProgress.memoizedProps === nextProps) {
          var currentRef = current !== null ? current.ref : null;

          if (ref === currentRef) {
            return bailoutOnAlreadyFinishedWork(current, workInProgress);
          }
        }

        var nextChildren = void 0;
        {
          ReactCurrentOwner.current = workInProgress;
          ReactDebugCurrentFiber.setCurrentPhase("render");
          nextChildren = render(nextProps, ref);
          ReactDebugCurrentFiber.setCurrentPhase(null);
        }
        reconcileChildren(current, workInProgress, nextChildren);
        memoizeProps(workInProgress, nextProps);
        return workInProgress.child;
      }

      function updateFragment(current, workInProgress) {
        var nextChildren = workInProgress.pendingProps;

        if (hasContextChanged()) {} else if (workInProgress.memoizedProps === nextChildren) {
          return bailoutOnAlreadyFinishedWork(current, workInProgress);
        }

        reconcileChildren(current, workInProgress, nextChildren);
        memoizeProps(workInProgress, nextChildren);
        return workInProgress.child;
      }

      function updateMode(current, workInProgress) {
        var nextChildren = workInProgress.pendingProps.children;

        if (hasContextChanged()) {} else if (nextChildren === null || workInProgress.memoizedProps === nextChildren) {
          return bailoutOnAlreadyFinishedWork(current, workInProgress);
        }

        reconcileChildren(current, workInProgress, nextChildren);
        memoizeProps(workInProgress, nextChildren);
        return workInProgress.child;
      }

      function updateProfiler(current, workInProgress) {
        var nextProps = workInProgress.pendingProps;

        if (enableProfilerTimer) {
          workInProgress.effectTag |= Update;
        }

        if (workInProgress.memoizedProps === nextProps) {
          return bailoutOnAlreadyFinishedWork(current, workInProgress);
        }

        var nextChildren = nextProps.children;
        reconcileChildren(current, workInProgress, nextChildren);
        memoizeProps(workInProgress, nextProps);
        return workInProgress.child;
      }

      function markRef(current, workInProgress) {
        var ref = workInProgress.ref;

        if (current === null && ref !== null || current !== null && current.ref !== ref) {
          workInProgress.effectTag |= Ref;
        }
      }

      function updateFunctionalComponent(current, workInProgress) {
        var fn = workInProgress.type;
        var nextProps = workInProgress.pendingProps;

        if (hasContextChanged()) {} else {
          if (workInProgress.memoizedProps === nextProps) {
            return bailoutOnAlreadyFinishedWork(current, workInProgress);
          }
        }

        var unmaskedContext = getUnmaskedContext(workInProgress);
        var context = getMaskedContext(workInProgress, unmaskedContext);
        var nextChildren = void 0;
        {
          ReactCurrentOwner.current = workInProgress;
          ReactDebugCurrentFiber.setCurrentPhase("render");
          nextChildren = fn(nextProps, context);
          ReactDebugCurrentFiber.setCurrentPhase(null);
        }
        workInProgress.effectTag |= PerformedWork;
        reconcileChildren(current, workInProgress, nextChildren);
        memoizeProps(workInProgress, nextProps);
        return workInProgress.child;
      }

      function updateClassComponent(current, workInProgress, renderExpirationTime) {
        var hasContext = pushContextProvider(workInProgress);
        var shouldUpdate = void 0;

        if (current === null) {
          if (workInProgress.stateNode === null) {
            constructClassInstance(workInProgress, workInProgress.pendingProps, renderExpirationTime);
            mountClassInstance(workInProgress, renderExpirationTime);
            shouldUpdate = true;
          } else {
            shouldUpdate = resumeMountClassInstance(workInProgress, renderExpirationTime);
          }
        } else {
          shouldUpdate = updateClassInstance(current, workInProgress, renderExpirationTime);
        }

        return finishClassComponent(current, workInProgress, shouldUpdate, hasContext, renderExpirationTime);
      }

      function finishClassComponent(current, workInProgress, shouldUpdate, hasContext, renderExpirationTime) {
        markRef(current, workInProgress);
        var didCaptureError = (workInProgress.effectTag & DidCapture) !== NoEffect;

        if (!shouldUpdate && !didCaptureError) {
          if (hasContext) {
            invalidateContextProvider(workInProgress, false);
          }

          return bailoutOnAlreadyFinishedWork(current, workInProgress);
        }

        var ctor = workInProgress.type;
        var instance = workInProgress.stateNode;
        ReactCurrentOwner.current = workInProgress;
        var nextChildren = void 0;

        if (didCaptureError && (!enableGetDerivedStateFromCatch || typeof ctor.getDerivedStateFromCatch !== "function")) {
          nextChildren = null;

          if (enableProfilerTimer) {
            stopBaseRenderTimerIfRunning();
          }
        } else {
          {
            ReactDebugCurrentFiber.setCurrentPhase("render");
            nextChildren = instance.render();

            if (debugRenderPhaseSideEffects || debugRenderPhaseSideEffectsForStrictMode && workInProgress.mode & StrictMode) {
              instance.render();
            }

            ReactDebugCurrentFiber.setCurrentPhase(null);
          }
        }

        workInProgress.effectTag |= PerformedWork;

        if (didCaptureError) {
          reconcileChildrenAtExpirationTime(current, workInProgress, null, renderExpirationTime);
          workInProgress.child = null;
        }

        reconcileChildrenAtExpirationTime(current, workInProgress, nextChildren, renderExpirationTime);
        memoizeState(workInProgress, instance.state);
        memoizeProps(workInProgress, instance.props);

        if (hasContext) {
          invalidateContextProvider(workInProgress, 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, workInProgress, renderExpirationTime) {
        pushHostRootContext(workInProgress);
        var updateQueue = workInProgress.updateQueue;

        if (updateQueue !== null) {
          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, workInProgress);
          }

          var root = workInProgress.stateNode;

          if ((current === null || current.child === null) && root.hydrate && enterHydrationState(workInProgress)) {
            workInProgress.effectTag |= Placement;
            workInProgress.child = mountChildFibers(workInProgress, null, nextChildren, renderExpirationTime);
          } else {
            resetHydrationState();
            reconcileChildren(current, workInProgress, nextChildren);
          }

          return workInProgress.child;
        }

        resetHydrationState();
        return bailoutOnAlreadyFinishedWork(current, workInProgress);
      }

      function updateHostComponent(current, workInProgress, renderExpirationTime) {
        pushHostContext(workInProgress);

        if (current === null) {
          tryToClaimNextHydratableInstance(workInProgress);
        }

        var type = workInProgress.type;
        var memoizedProps = workInProgress.memoizedProps;
        var nextProps = workInProgress.pendingProps;
        var prevProps = current !== null ? current.memoizedProps : null;

        if (hasContextChanged()) {} else if (memoizedProps === nextProps) {
          var isHidden = workInProgress.mode & AsyncMode && shouldDeprioritizeSubtree(type, nextProps);

          if (isHidden) {
            workInProgress.expirationTime = Never;
          }

          if (!isHidden || renderExpirationTime !== Never) {
            return bailoutOnAlreadyFinishedWork(current, workInProgress);
          }
        }

        var nextChildren = nextProps.children;
        var isDirectTextChild = shouldSetTextContent(type, nextProps);

        if (isDirectTextChild) {
          nextChildren = null;
        } else if (prevProps && shouldSetTextContent(type, prevProps)) {
          workInProgress.effectTag |= ContentReset;
        }

        markRef(current, workInProgress);

        if (renderExpirationTime !== Never && workInProgress.mode & AsyncMode && shouldDeprioritizeSubtree(type, nextProps)) {
          workInProgress.expirationTime = Never;
          workInProgress.memoizedProps = nextProps;
          return null;
        }

        reconcileChildren(current, workInProgress, nextChildren);
        memoizeProps(workInProgress, nextProps);
        return workInProgress.child;
      }

      function updateHostText(current, workInProgress) {
        if (current === null) {
          tryToClaimNextHydratableInstance(workInProgress);
        }

        var nextProps = workInProgress.pendingProps;
        memoizeProps(workInProgress, nextProps);
        return null;
      }

      function mountIndeterminateComponent(current, workInProgress, renderExpirationTime) {
        invariant(current === null, "An indeterminate component should never have mounted. This error is " + "likely caused by a bug in React. Please file an issue.");
        var fn = workInProgress.type;
        var props = workInProgress.pendingProps;
        var unmaskedContext = getUnmaskedContext(workInProgress);
        var context = getMaskedContext(workInProgress, unmaskedContext);
        var value = void 0;
        {
          if (fn.prototype && typeof fn.prototype.render === "function") {
            var componentName = getComponentName(workInProgress) || "Unknown";

            if (!didWarnAboutBadClass[componentName]) {
              warning(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.current = workInProgress;
          value = fn(props, context);
        }
        workInProgress.effectTag |= PerformedWork;

        if (typeof value === "object" && value !== null && typeof value.render === "function" && value.$$typeof === undefined) {
          var Component = workInProgress.type;
          workInProgress.tag = ClassComponent;
          workInProgress.memoizedState = value.state !== null && value.state !== undefined ? value.state : null;
          var getDerivedStateFromProps = Component.getDerivedStateFromProps;

          if (typeof getDerivedStateFromProps === "function") {
            applyDerivedStateFromProps(workInProgress, getDerivedStateFromProps, props);
          }

          var hasContext = pushContextProvider(workInProgress);
          adoptClassInstance(workInProgress, value);
          mountClassInstance(workInProgress, renderExpirationTime);
          return finishClassComponent(current, workInProgress, true, hasContext, renderExpirationTime);
        } else {
          workInProgress.tag = FunctionalComponent;
          {
            var _Component = workInProgress.type;

            if (_Component) {
              !!_Component.childContextTypes ? warning(false, "%s(...): childContextTypes cannot be defined on a functional component.", _Component.displayName || _Component.name || "Component") : void 0;
            }

            if (workInProgress.ref !== null) {
              var info = "";
              var ownerName = ReactDebugCurrentFiber.getCurrentFiberOwnerName();

              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 (!didWarnAboutStatelessRefs[warningKey]) {
                didWarnAboutStatelessRefs[warningKey] = true;
                warning(false, "Stateless function components cannot be given refs. " + "Attempts to access this ref will fail.%s%s", info, ReactDebugCurrentFiber.getCurrentFiberStackAddendum());
              }
            }

            if (typeof fn.getDerivedStateFromProps === "function") {
              var _componentName = getComponentName(workInProgress) || "Unknown";

              if (!didWarnAboutGetDerivedStateOnFunctionalComponent[_componentName]) {
                warning(false, "%s: Stateless functional components do not support getDerivedStateFromProps.", _componentName);
                didWarnAboutGetDerivedStateOnFunctionalComponent[_componentName] = true;
              }
            }
          }
          reconcileChildren(current, workInProgress, value);
          memoizeProps(workInProgress, props);
          return workInProgress.child;
        }
      }

      function updateTimeoutComponent(current, workInProgress, renderExpirationTime) {
        if (enableSuspense) {
          var nextProps = workInProgress.pendingProps;
          var prevProps = workInProgress.memoizedProps;
          var prevDidTimeout = workInProgress.memoizedState;
          var alreadyCaptured = (workInProgress.effectTag & DidCapture) === NoEffect;
          var nextDidTimeout = !alreadyCaptured;

          if (hasContextChanged()) {} else if (nextProps === prevProps && nextDidTimeout === prevDidTimeout) {
            return bailoutOnAlreadyFinishedWork(current, workInProgress);
          }

          var render = nextProps.children;
          var nextChildren = render(nextDidTimeout);
          workInProgress.memoizedProps = nextProps;
          workInProgress.memoizedState = nextDidTimeout;
          reconcileChildren(current, workInProgress, nextChildren);
          return workInProgress.child;
        } else {
          return null;
        }
      }

      function updatePortalComponent(current, workInProgress, renderExpirationTime) {
        pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
        var nextChildren = workInProgress.pendingProps;

        if (hasContextChanged()) {} else if (workInProgress.memoizedProps === nextChildren) {
          return bailoutOnAlreadyFinishedWork(current, workInProgress);
        }

        if (current === null) {
          workInProgress.child = reconcileChildFibers(workInProgress, null, nextChildren, renderExpirationTime);
          memoizeProps(workInProgress, nextChildren);
        } else {
          reconcileChildren(current, workInProgress, nextChildren);
          memoizeProps(workInProgress, nextChildren);
        }

        return workInProgress.child;
      }

      function propagateContextChange(workInProgress, context, changedBits, renderExpirationTime) {
        var fiber = workInProgress.child;

        if (fiber !== null) {
          fiber.return = workInProgress;
        }

        while (fiber !== null) {
          var nextFiber = void 0;

          switch (fiber.tag) {
            case ContextConsumer:
              var observedBits = fiber.stateNode | 0;

              if (fiber.type === context && (observedBits & changedBits) !== 0) {
                var node = fiber;

                while (node !== null) {
                  var alternate = node.alternate;

                  if (node.expirationTime === NoWork || node.expirationTime > renderExpirationTime) {
                    node.expirationTime = renderExpirationTime;

                    if (alternate !== null && (alternate.expirationTime === NoWork || alternate.expirationTime > renderExpirationTime)) {
                      alternate.expirationTime = renderExpirationTime;
                    }
                  } else if (alternate !== null && (alternate.expirationTime === NoWork || alternate.expirationTime > renderExpirationTime)) {
                    alternate.expirationTime = renderExpirationTime;
                  } else {
                    break;
                  }

                  node = node.return;
                }

                nextFiber = null;
              } else {
                nextFiber = fiber.child;
              }

              break;

            case ContextProvider:
              nextFiber = fiber.type === workInProgress.type ? null : fiber.child;
              break;

            default:
              nextFiber = fiber.child;
              break;
          }

          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 updateContextProvider(current, workInProgress, renderExpirationTime) {
        var providerType = workInProgress.type;
        var context = providerType._context;
        var newProps = workInProgress.pendingProps;
        var oldProps = workInProgress.memoizedProps;
        var canBailOnProps = true;

        if (hasContextChanged()) {
          canBailOnProps = false;
        } else if (oldProps === newProps) {
          workInProgress.stateNode = 0;
          pushProvider(workInProgress);
          return bailoutOnAlreadyFinishedWork(current, workInProgress);
        }

        var newValue = newProps.value;
        workInProgress.memoizedProps = newProps;
        {
          var providerPropTypes = workInProgress.type.propTypes;

          if (providerPropTypes) {
            checkPropTypes(providerPropTypes, newProps, "prop", "Context.Provider", getCurrentFiberStackAddendum$1);
          }
        }
        var changedBits = void 0;

        if (oldProps === null) {
          changedBits = MAX_SIGNED_31_BIT_INT;
        } else {
          if (oldProps.value === newProps.value) {
            if (oldProps.children === newProps.children && canBailOnProps) {
              workInProgress.stateNode = 0;
              pushProvider(workInProgress);
              return bailoutOnAlreadyFinishedWork(current, workInProgress);
            }

            changedBits = 0;
          } else {
            var oldValue = oldProps.value;

            if (oldValue === newValue && (oldValue !== 0 || 1 / oldValue === 1 / newValue) || oldValue !== oldValue && newValue !== newValue) {
                if (oldProps.children === newProps.children && canBailOnProps) {
                  workInProgress.stateNode = 0;
                  pushProvider(workInProgress);
                  return bailoutOnAlreadyFinishedWork(current, workInProgress);
                }

                changedBits = 0;
              } else {
              changedBits = typeof context._calculateChangedBits === "function" ? context._calculateChangedBits(oldValue, newValue) : MAX_SIGNED_31_BIT_INT;
              {
                !((changedBits & MAX_SIGNED_31_BIT_INT) === changedBits) ? warning(false, "calculateChangedBits: Expected the return value to be a " + "31-bit integer. Instead received: %s", changedBits) : void 0;
              }
              changedBits |= 0;

              if (changedBits === 0) {
                if (oldProps.children === newProps.children && canBailOnProps) {
                  workInProgress.stateNode = 0;
                  pushProvider(workInProgress);
                  return bailoutOnAlreadyFinishedWork(current, workInProgress);
                }
              } else {
                propagateContextChange(workInProgress, context, changedBits, renderExpirationTime);
              }
            }
          }
        }

        workInProgress.stateNode = changedBits;
        pushProvider(workInProgress);
        var newChildren = newProps.children;
        reconcileChildren(current, workInProgress, newChildren);
        return workInProgress.child;
      }

      function updateContextConsumer(current, workInProgress, renderExpirationTime) {
        var context = workInProgress.type;
        var newProps = workInProgress.pendingProps;
        var oldProps = workInProgress.memoizedProps;
        var newValue = getContextCurrentValue(context);
        var changedBits = getContextChangedBits(context);

        if (hasContextChanged()) {} else if (changedBits === 0 && oldProps === newProps) {
          return bailoutOnAlreadyFinishedWork(current, workInProgress);
        }

        workInProgress.memoizedProps = newProps;
        var observedBits = newProps.unstable_observedBits;

        if (observedBits === undefined || observedBits === null) {
          observedBits = MAX_SIGNED_31_BIT_INT;
        }

        workInProgress.stateNode = observedBits;

        if ((changedBits & observedBits) !== 0) {
          propagateContextChange(workInProgress, context, changedBits, renderExpirationTime);
        } else if (oldProps === newProps) {
          return bailoutOnAlreadyFinishedWork(current, workInProgress);
        }

        var render = newProps.children;
        {
          !(typeof render === "function") ? warning(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;
        }
        var newChildren = void 0;
        {
          ReactCurrentOwner.current = workInProgress;
          ReactDebugCurrentFiber.setCurrentPhase("render");
          newChildren = render(newValue);
          ReactDebugCurrentFiber.setCurrentPhase(null);
        }
        workInProgress.effectTag |= PerformedWork;
        reconcileChildren(current, workInProgress, newChildren);
        return workInProgress.child;
      }

      function bailoutOnAlreadyFinishedWork(current, workInProgress) {
        cancelWorkTimer(workInProgress);

        if (enableProfilerTimer) {
          stopBaseRenderTimerIfRunning();
        }

        cloneChildFibers(current, workInProgress);
        return workInProgress.child;
      }

      function bailoutOnLowPriority(current, workInProgress) {
        cancelWorkTimer(workInProgress);

        if (enableProfilerTimer) {
          stopBaseRenderTimerIfRunning();
        }

        switch (workInProgress.tag) {
          case HostRoot:
            pushHostRootContext(workInProgress);
            break;

          case ClassComponent:
            pushContextProvider(workInProgress);
            break;

          case HostPortal:
            pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
            break;

          case ContextProvider:
            pushProvider(workInProgress);
            break;
        }

        return null;
      }

      function memoizeProps(workInProgress, nextProps) {
        workInProgress.memoizedProps = nextProps;
      }

      function memoizeState(workInProgress, nextState) {
        workInProgress.memoizedState = nextState;
      }

      function beginWork(current, workInProgress, renderExpirationTime) {
        if (enableProfilerTimer) {
          if (workInProgress.mode & ProfileMode) {
            markActualRenderTimeStarted(workInProgress);
          }
        }

        if (workInProgress.expirationTime === NoWork || workInProgress.expirationTime > renderExpirationTime) {
          return bailoutOnLowPriority(current, workInProgress);
        }

        switch (workInProgress.tag) {
          case IndeterminateComponent:
            return mountIndeterminateComponent(current, workInProgress, renderExpirationTime);

          case FunctionalComponent:
            return updateFunctionalComponent(current, workInProgress);

          case ClassComponent:
            return updateClassComponent(current, workInProgress, renderExpirationTime);

          case HostRoot:
            return updateHostRoot(current, workInProgress, renderExpirationTime);

          case HostComponent:
            return updateHostComponent(current, workInProgress, renderExpirationTime);

          case HostText:
            return updateHostText(current, workInProgress);

          case TimeoutComponent:
            return updateTimeoutComponent(current, workInProgress, renderExpirationTime);

          case HostPortal:
            return updatePortalComponent(current, workInProgress, renderExpirationTime);

          case ForwardRef:
            return updateForwardRef(current, workInProgress);

          case Fragment:
            return updateFragment(current, workInProgress);

          case Mode:
            return updateMode(current, workInProgress);

          case Profiler:
            return updateProfiler(current, workInProgress);

          case ContextProvider:
            return updateContextProvider(current, workInProgress, renderExpirationTime);

          case ContextConsumer:
            return updateContextConsumer(current, workInProgress, renderExpirationTime);

          default:
            invariant(false, "Unknown unit of work tag. This error is likely caused by a bug in " + "React. Please file an issue.");
        }
      }

      function markUpdate(workInProgress) {
        workInProgress.effectTag |= Update;
      }

      function markRef$1(workInProgress) {
        workInProgress.effectTag |= Ref;
      }

      function appendAllChildren(parent, workInProgress) {
        var node = workInProgress.child;

        while (node !== null) {
          if (node.tag === HostComponent || node.tag === HostText) {
            appendInitialChild(parent, node.stateNode);
          } 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;
        }
      }

      var updateHostContainer = void 0;
      var updateHostComponent$1 = void 0;
      var updateHostText$1 = void 0;

      if (supportsMutation) {
        updateHostContainer = function updateHostContainer(workInProgress) {};

        updateHostComponent$1 = function updateHostComponent$1(current, workInProgress, updatePayload, 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) {
        var appendAllChildrenToContainer = function appendAllChildrenToContainer(containerChildSet, workInProgress) {
          var node = workInProgress.child;

          while (node !== null) {
            if (node.tag === HostComponent || node.tag === HostText) {
              appendChildToContainerChildSet(containerChildSet, node.stateNode);
            } 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) {
          var portalOrRoot = workInProgress.stateNode;
          var childrenUnchanged = workInProgress.firstEffect === null;

          if (childrenUnchanged) {} else {
            var container = portalOrRoot.containerInfo;
            var newChildSet = createContainerChildSet(container);
            appendAllChildrenToContainer(newChildSet, workInProgress);
            portalOrRoot.pendingChildren = newChildSet;
            markUpdate(workInProgress);
            finalizeContainerChildren(container, newChildSet);
          }
        };

        updateHostComponent$1 = function updateHostComponent$1(current, workInProgress, updatePayload, type, oldProps, newProps, rootContainerInstance, currentHostContext) {
          var childrenUnchanged = workInProgress.firstEffect === null;
          var currentInstance = current.stateNode;

          if (childrenUnchanged && updatePayload === null) {
            workInProgress.stateNode = currentInstance;
          } else {
            var recyclableInstance = workInProgress.stateNode;
            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);
            }
          }
        };

        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, updatePayload, type, oldProps, newProps, rootContainerInstance, currentHostContext) {};

        updateHostText$1 = function updateHostText$1(current, workInProgress, oldText, newText) {};
      }

      function completeWork(current, workInProgress, renderExpirationTime) {
        var newProps = workInProgress.pendingProps;

        if (enableProfilerTimer) {
          if (workInProgress.mode & ProfileMode) {
            recordElapsedActualRenderTime(workInProgress);
          }
        }

        switch (workInProgress.tag) {
          case FunctionalComponent:
            return null;

          case ClassComponent:
            {
              popContextProvider(workInProgress);
              return null;
            }

          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);
              return null;
            }

          case HostComponent:
            {
              popHostContext(workInProgress);
              var rootContainerInstance = getRootHostContainer();
              var type = workInProgress.type;

              if (current !== null && workInProgress.stateNode != null) {
                var oldProps = current.memoizedProps;
                var instance = workInProgress.stateNode;
                var currentHostContext = getHostContext();
                var updatePayload = prepareUpdate(instance, type, oldProps, newProps, rootContainerInstance, currentHostContext);
                updateHostComponent$1(current, workInProgress, updatePayload, type, oldProps, newProps, rootContainerInstance, currentHostContext);

                if (current.ref !== workInProgress.ref) {
                  markRef$1(workInProgress);
                }
              } else {
                if (!newProps) {
                  invariant(workInProgress.stateNode !== null, "We must have new props for new mounts. This error is likely " + "caused by a bug in React. Please file an issue.");
                  return null;
                }

                var _currentHostContext = getHostContext();

                var wasHydrated = popHydrationState(workInProgress);

                if (wasHydrated) {
                  if (prepareToHydrateHostInstance(workInProgress, rootContainerInstance, _currentHostContext)) {
                    markUpdate(workInProgress);
                  }
                } else {
                  var _instance = createInstance(type, newProps, rootContainerInstance, _currentHostContext, workInProgress);

                  appendAllChildren(_instance, workInProgress);

                  if (finalizeInitialChildren(_instance, type, newProps, rootContainerInstance, _currentHostContext)) {
                    markUpdate(workInProgress);
                  }

                  workInProgress.stateNode = _instance;
                }

                if (workInProgress.ref !== null) {
                  markRef$1(workInProgress);
                }
              }

              return null;
            }

          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") {
                  invariant(workInProgress.stateNode !== null, "We must have new props for new mounts. This error is likely " + "caused by a bug in React. Please file an issue.");
                  return null;
                }

                var _rootContainerInstance = getRootHostContainer();

                var _currentHostContext2 = getHostContext();

                var _wasHydrated = popHydrationState(workInProgress);

                if (_wasHydrated) {
                  if (prepareToHydrateHostTextInstance(workInProgress)) {
                    markUpdate(workInProgress);
                  }
                } else {
                  workInProgress.stateNode = createTextInstance(newText, _rootContainerInstance, _currentHostContext2, workInProgress);
                }
              }

              return null;
            }

          case ForwardRef:
            return null;

          case TimeoutComponent:
            return null;

          case Fragment:
            return null;

          case Mode:
            return null;

          case Profiler:
            return null;

          case HostPortal:
            popHostContainer(workInProgress);
            updateHostContainer(workInProgress);
            return null;

          case ContextProvider:
            popProvider(workInProgress);
            return null;

          case ContextConsumer:
            return null;

          case IndeterminateComponent:
            invariant(false, "An indeterminate component should have become determinate before " + "completing. This error is likely caused by a bug in React. Please " + "file an issue.");

          default:
            invariant(false, "Unknown unit of work tag. This error is likely caused by a bug in " + "React. Please file an issue.");
        }
      }

      function showErrorDialog(capturedError) {
        var componentStack = capturedError.componentStack,
            error = capturedError.error;
        var errorToHandle = void 0;

        if (error instanceof Error) {
          var message = error.message,
              name = error.name;
          var summary = message ? name + ": " + message : name;
          errorToHandle = error;

          try {
            errorToHandle.message = summary + "\n\nThis error is located at:" + componentStack;
          } catch (e) {}
        } else if (typeof error === "string") {
          errorToHandle = new Error(error + "\n\nThis error is located at:" + componentStack);
        } else {
          errorToHandle = new Error("Unspecified error at:" + componentStack);
        }

        ExceptionsManager.handleException(errorToHandle, false);
        return false;
      }

      function logCapturedError(capturedError) {
        var logError = showErrorDialog(capturedError);

        if (logError === false) {
          return;
        }

        var error = capturedError.error;
        var suppressLogging = error && error.suppressReactErrorLogging;

        if (suppressLogging) {
          return;
        }

        {
          var componentName = capturedError.componentName,
              componentStack = capturedError.componentStack,
              errorBoundaryName = capturedError.errorBoundaryName,
              errorBoundaryFound = capturedError.errorBoundaryFound,
              willRetry = capturedError.willRetry;
          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 invokeGuardedCallback$3 = ReactErrorUtils.invokeGuardedCallback;
      var hasCaughtError$1 = ReactErrorUtils.hasCaughtError;
      var clearCaughtError$1 = ReactErrorUtils.clearCaughtError;
      var didWarnAboutUndefinedSnapshotBeforeUpdate = null;
      {
        didWarnAboutUndefinedSnapshotBeforeUpdate = new Set();
      }

      function logError(boundary, errorInfo) {
        var source = errorInfo.source;
        var stack = errorInfo.stack;

        if (stack === null && source !== null) {
          stack = getStackAddendumByWorkInProgressFiber(source);
        }

        var capturedError = {
          componentName: source !== null ? getComponentName(source) : 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);
          capturedError.errorBoundaryFound = true;
          capturedError.willRetry = true;
        }

        try {
          logCapturedError(capturedError);
        } catch (e) {
          var suppressLogging = e && e.suppressReactErrorLogging;

          if (!suppressLogging) {
            console.error(e);
          }
        }
      }

      var callComponentWillUnmountWithTimer = function callComponentWillUnmountWithTimer(current, instance) {
        startPhaseTimer(current, "componentWillUnmount");
        instance.props = current.memoizedProps;
        instance.state = current.memoizedState;
        instance.componentWillUnmount();
        stopPhaseTimer();
      };

      function safelyCallComponentWillUnmount(current, instance) {
        {
          invokeGuardedCallback$3(null, callComponentWillUnmountWithTimer, null, current, instance);

          if (hasCaughtError$1()) {
            var unmountError = clearCaughtError$1();
            captureCommitPhaseError(current, unmountError);
          }
        }
      }

      function safelyDetachRef(current) {
        var ref = current.ref;

        if (ref !== null) {
          if (typeof ref === "function") {
            {
              invokeGuardedCallback$3(null, ref, null, null);

              if (hasCaughtError$1()) {
                var refError = clearCaughtError$1();
                captureCommitPhaseError(current, refError);
              }
            }
          } else {
            ref.current = null;
          }
        }
      }

      function commitBeforeMutationLifeCycles(current, finishedWork) {
        switch (finishedWork.tag) {
          case ClassComponent:
            {
              if (finishedWork.effectTag & Snapshot) {
                if (current !== null) {
                  var prevProps = current.memoizedProps;
                  var prevState = current.memoizedState;
                  startPhaseTimer(finishedWork, "getSnapshotBeforeUpdate");
                  var instance = finishedWork.stateNode;
                  instance.props = finishedWork.memoizedProps;
                  instance.state = finishedWork.memoizedState;
                  var snapshot = instance.getSnapshotBeforeUpdate(prevProps, prevState);
                  {
                    var didWarnSet = didWarnAboutUndefinedSnapshotBeforeUpdate;

                    if (snapshot === undefined && !didWarnSet.has(finishedWork.type)) {
                      didWarnSet.add(finishedWork.type);
                      warning(false, "%s.getSnapshotBeforeUpdate(): A snapshot value (or null) " + "must be returned. You have returned undefined.", getComponentName(finishedWork));
                    }
                  }
                  instance.__reactInternalSnapshotBeforeUpdate = snapshot;
                  stopPhaseTimer();
                }
              }

              return;
            }

          case HostRoot:
          case HostComponent:
          case HostText:
          case HostPortal:
            return;

          default:
            {
              invariant(false, "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 commitLifeCycles(finishedRoot, current, finishedWork, currentTime, committedExpirationTime) {
        switch (finishedWork.tag) {
          case ClassComponent:
            {
              var instance = finishedWork.stateNode;

              if (finishedWork.effectTag & Update) {
                if (current === null) {
                  startPhaseTimer(finishedWork, "componentDidMount");
                  instance.props = finishedWork.memoizedProps;
                  instance.state = finishedWork.memoizedState;
                  instance.componentDidMount();
                  stopPhaseTimer();
                } else {
                  var prevProps = current.memoizedProps;
                  var prevState = current.memoizedState;
                  startPhaseTimer(finishedWork, "componentDidUpdate");
                  instance.props = finishedWork.memoizedProps;
                  instance.state = finishedWork.memoizedState;
                  instance.componentDidUpdate(prevProps, prevState, instance.__reactInternalSnapshotBeforeUpdate);
                  stopPhaseTimer();
                }
              }

              var updateQueue = finishedWork.updateQueue;

              if (updateQueue !== null) {
                instance.props = finishedWork.memoizedProps;
                instance.state = finishedWork.memoizedState;
                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 === 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:
            {
              return;
            }

          case TimeoutComponent:
            {
              return;
            }

          default:
            {
              invariant(false, "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 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")) {
                warning(false, "Unexpected ref object provided for %s. " + "Use either a ref-setter function or React.createRef().%s", getComponentName(finishedWork), getStackAddendumByWorkInProgressFiber(finishedWork));
              }
            }
            ref.current = instanceToUse;
          }
        }
      }

      function commitDetachRef(current) {
        var currentRef = current.ref;

        if (currentRef !== null) {
          if (typeof currentRef === "function") {
            currentRef(null);
          } else {
            currentRef.current = null;
          }
        }
      }

      function commitUnmount(current) {
        if (typeof onCommitUnmount === "function") {
          onCommitUnmount(current);
        }

        switch (current.tag) {
          case ClassComponent:
            {
              safelyDetachRef(current);
              var instance = current.stateNode;

              if (typeof instance.componentWillUnmount === "function") {
                safelyCallComponentWillUnmount(current, instance);
              }

              return;
            }

          case HostComponent:
            {
              safelyDetachRef(current);
              return;
            }

          case HostPortal:
            {
              if (supportsMutation) {
                unmountHostComponents(current);
              } else if (supportsPersistence) {
                emptyPortalContainer(current);
              }

              return;
            }
        }
      }

      function commitNestedUnmounts(root) {
        var node = root;

        while (true) {
          commitUnmount(node);

          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) {
        current.return = null;
        current.child = null;

        if (current.alternate) {
          current.alternate.child = null;
          current.alternate.return = null;
        }
      }

      function emptyPortalContainer(current) {
        if (!supportsPersistence) {
          return;
        }

        var portal = current.stateNode;
        var containerInfo = portal.containerInfo;
        var emptyChildSet = createContainerChildSet(containerInfo);
      }

      function commitContainer(finishedWork) {
        if (!supportsPersistence) {
          return;
        }

        switch (finishedWork.tag) {
          case ClassComponent:
            {
              return;
            }

          case HostComponent:
            {
              return;
            }

          case HostText:
            {
              return;
            }

          case HostRoot:
          case HostPortal:
            {
              var portalOrRoot = finishedWork.stateNode;
              var containerInfo = portalOrRoot.containerInfo,
                  _pendingChildren = portalOrRoot.pendingChildren;
              return;
            }

          default:
            {
              invariant(false, "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;
        }

        invariant(false, "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) {
            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;

        switch (parentFiber.tag) {
          case HostComponent:
            parent = parentFiber.stateNode;
            isContainer = false;
            break;

          case HostRoot:
            parent = parentFiber.stateNode.containerInfo;
            isContainer = true;
            break;

          case HostPortal:
            parent = parentFiber.stateNode.containerInfo;
            isContainer = true;
            break;

          default:
            invariant(false, "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) {
          if (node.tag === HostComponent || node.tag === HostText) {
            if (before) {
              if (isContainer) {
                insertInContainerBefore(parent, node.stateNode, before);
              } else {
                insertBefore(parent, node.stateNode, before);
              }
            } else {
              if (isContainer) {
                appendChildToContainer(parent, node.stateNode);
              } else {
                appendChild$1(parent, node.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) {
        var node = current;
        var currentParentIsValid = false;
        var currentParent = void 0;
        var currentParentIsContainer = void 0;

        while (true) {
          if (!currentParentIsValid) {
            var parent = node.return;

            findParent: while (true) {
              invariant(parent !== null, "Expected to find a host parent. This error is likely caused by " + "a bug in React. Please file an issue.");

              switch (parent.tag) {
                case HostComponent:
                  currentParent = parent.stateNode;
                  currentParentIsContainer = false;
                  break findParent;

                case HostRoot:
                  currentParent = parent.stateNode.containerInfo;
                  currentParentIsContainer = true;
                  break findParent;

                case HostPortal:
                  currentParent = parent.stateNode.containerInfo;
                  currentParentIsContainer = true;
                  break findParent;
              }

              parent = parent.return;
            }

            currentParentIsValid = true;
          }

          if (node.tag === HostComponent || node.tag === HostText) {
            commitNestedUnmounts(node);

            if (currentParentIsContainer) {
              removeChildFromContainer(currentParent, node.stateNode);
            } else {
              removeChild(currentParent, node.stateNode);
            }
          } else if (node.tag === HostPortal) {
            currentParent = node.stateNode.containerInfo;

            if (node.child !== null) {
              node.child.return = node;
              node = node.child;
              continue;
            }
          } else {
            commitUnmount(node);

            if (node.child !== null) {
              node.child.return = node;
              node = node.child;
              continue;
            }
          }

          if (node === current) {
            return;
          }

          while (node.sibling === null) {
            if (node.return === null || node.return === current) {
              return;
            }

            node = node.return;

            if (node.tag === HostPortal) {
              currentParentIsValid = false;
            }
          }

          node.sibling.return = node.return;
          node = node.sibling;
        }
      }

      function commitDeletion(current) {
        if (supportsMutation) {
          unmountHostComponents(current);
        } else {
          commitNestedUnmounts(current);
        }

        detachFiber(current);
      }

      function commitWork(current, finishedWork) {
        if (!supportsMutation) {
          commitContainer(finishedWork);
          return;
        }

        switch (finishedWork.tag) {
          case ClassComponent:
            {
              return;
            }

          case HostComponent:
            {
              var instance = finishedWork.stateNode;

              if (instance != null) {
                var newProps = finishedWork.memoizedProps;
                var oldProps = current !== null ? current.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:
            {
              invariant(finishedWork.stateNode !== null, "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 !== null ? current.memoizedProps : newText;
              commitTextUpdate(textInstance, oldText, newText);
              return;
            }

          case HostRoot:
            {
              return;
            }

          case Profiler:
            {
              if (enableProfilerTimer) {
                var onRender = finishedWork.memoizedProps.onRender;
                onRender(finishedWork.memoizedProps.id, current === null ? "mount" : "update", finishedWork.actualDuration, finishedWork.treeBaseTime, finishedWork.actualStartTime, getCommitTime());
              }

              return;
            }

          case TimeoutComponent:
            {
              return;
            }

          default:
            {
              invariant(false, "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 commitResetTextContent(current) {
        if (!supportsMutation) {
          return;
        }

        resetTextContent(current.stateNode);
      }

      function createRootErrorUpdate(fiber, errorInfo, expirationTime) {
        var update = createUpdate(expirationTime);
        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);
        update.tag = CaptureUpdate;
        var getDerivedStateFromCatch = fiber.type.getDerivedStateFromCatch;

        if (enableGetDerivedStateFromCatch && typeof getDerivedStateFromCatch === "function") {
          var error = errorInfo.value;

          update.payload = function () {
            return getDerivedStateFromCatch(error);
          };
        }

        var inst = fiber.stateNode;

        if (inst !== null && typeof inst.componentDidCatch === "function") {
          update.callback = function callback() {
            if (!enableGetDerivedStateFromCatch || getDerivedStateFromCatch !== "function") {
              markLegacyErrorBoundaryAsFailed(this);
            }

            var error = errorInfo.value;
            var stack = errorInfo.stack;
            logError(fiber, errorInfo);
            this.componentDidCatch(error, {
              componentStack: stack !== null ? stack : ""
            });
          };
        }

        return update;
      }

      function schedulePing(finishedWork) {
        var currentTime = recalculateCurrentTime();
        var expirationTime = computeExpirationForFiber(currentTime, finishedWork);
        var recoveryUpdate = createUpdate(expirationTime);
        enqueueUpdate(finishedWork, recoveryUpdate, expirationTime);
        scheduleWork(finishedWork, expirationTime);
      }

      function throwException(root, returnFiber, sourceFiber, value, renderExpirationTime, currentTimeMs) {
        sourceFiber.effectTag |= Incomplete;
        sourceFiber.firstEffect = sourceFiber.lastEffect = null;

        if (enableSuspense && value !== null && typeof value === "object" && typeof value.then === "function") {
          var thenable = value;
          var expirationTimeMs = expirationTimeToMs(renderExpirationTime);
          var startTimeMs = expirationTimeMs - 5000;
          var elapsedMs = currentTimeMs - startTimeMs;

          if (elapsedMs < 0) {
            elapsedMs = 0;
          }

          var remainingTimeMs = expirationTimeMs - currentTimeMs;
          var _workInProgress = returnFiber;
          var earliestTimeoutMs = -1;

          searchForEarliestTimeout: do {
            if (_workInProgress.tag === TimeoutComponent) {
              var current = _workInProgress.alternate;

              if (current !== null && current.memoizedState === true) {
                earliestTimeoutMs = 0;
                break searchForEarliestTimeout;
              }

              var timeoutPropMs = _workInProgress.pendingProps.ms;

              if (typeof timeoutPropMs === "number") {
                if (timeoutPropMs <= 0) {
                  earliestTimeoutMs = 0;
                  break searchForEarliestTimeout;
                } else if (earliestTimeoutMs === -1 || timeoutPropMs < earliestTimeoutMs) {
                  earliestTimeoutMs = timeoutPropMs;
                }
              } else if (earliestTimeoutMs === -1) {
                earliestTimeoutMs = remainingTimeMs;
              }
            }

            _workInProgress = _workInProgress.return;
          } while (_workInProgress !== null);

          var msUntilTimeout = earliestTimeoutMs - elapsedMs;

          if (renderExpirationTime === Never || msUntilTimeout > 0) {
            markTimeout(root, thenable, msUntilTimeout, renderExpirationTime);

            var onResolveOrReject = function onResolveOrReject() {
              retrySuspendedRoot(root, renderExpirationTime);
            };

            thenable.then(onResolveOrReject, onResolveOrReject);
            return;
          } else {
            _workInProgress = returnFiber;

            do {
              switch (_workInProgress.tag) {
                case HostRoot:
                  {
                    var message = renderExpirationTime === Sync ? "A synchronous update was suspended, but no fallback UI " + "was provided." : "An update was suspended for longer than the timeout, " + "but no fallback UI was provided.";
                    value = new Error(message);
                    break;
                  }

                case TimeoutComponent:
                  {
                    if ((_workInProgress.effectTag & DidCapture) === NoEffect) {
                      _workInProgress.effectTag |= ShouldCapture;

                      var _onResolveOrReject = schedulePing.bind(null, _workInProgress);

                      thenable.then(_onResolveOrReject, _onResolveOrReject);
                      return;
                    }

                    break;
                  }
              }

              _workInProgress = _workInProgress.return;
            } while (_workInProgress !== null);
          }
        } else {
          markError(root);

          if (!root.didError && renderExpirationTime !== Sync || hasLowerPriorityWork(root, renderExpirationTime)) {
            return;
          }
        }

        value = createCapturedValue(value, sourceFiber);
        var workInProgress = returnFiber;

        do {
          switch (workInProgress.tag) {
            case HostRoot:
              {
                var _errorInfo = value;
                workInProgress.effectTag |= ShouldCapture;
                var update = createRootErrorUpdate(workInProgress, _errorInfo, renderExpirationTime);
                enqueueCapturedUpdate(workInProgress, update, renderExpirationTime);
                return;
              }

            case ClassComponent:
              var errorInfo = value;
              var ctor = workInProgress.type;
              var instance = workInProgress.stateNode;

              if ((workInProgress.effectTag & DidCapture) === NoEffect && (typeof ctor.getDerivedStateFromCatch === "function" && enableGetDerivedStateFromCatch || instance !== null && typeof instance.componentDidCatch === "function" && !isAlreadyFailedLegacyErrorBoundary(instance))) {
                workInProgress.effectTag |= ShouldCapture;

                var _update = createClassErrorUpdate(workInProgress, errorInfo, renderExpirationTime);

                enqueueCapturedUpdate(workInProgress, _update, renderExpirationTime);
                return;
              }

              break;

            default:
              break;
          }

          workInProgress = workInProgress.return;
        } while (workInProgress !== null);
      }

      function unwindWork(workInProgress, renderExpirationTime) {
        if (enableProfilerTimer) {
          if (workInProgress.mode & ProfileMode) {
            recordElapsedActualRenderTime(workInProgress);
          }
        }

        switch (workInProgress.tag) {
          case ClassComponent:
            {
              popContextProvider(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;

              if (_effectTag & ShouldCapture) {
                workInProgress.effectTag = _effectTag & ~ShouldCapture | DidCapture;
                return workInProgress;
              }

              return null;
            }

          case HostComponent:
            {
              popHostContext(workInProgress);
              return null;
            }

          case TimeoutComponent:
            {
              var _effectTag2 = workInProgress.effectTag;

              if (_effectTag2 & ShouldCapture) {
                workInProgress.effectTag = _effectTag2 & ~ShouldCapture | DidCapture;
                return workInProgress;
              }

              return null;
            }

          case HostPortal:
            popHostContainer(workInProgress);
            return null;

          case ContextProvider:
            popProvider(workInProgress);
            return null;

          default:
            return null;
        }
      }

      function unwindInterruptedWork(interruptedWork) {
        if (enableProfilerTimer) {
          if (interruptedWork.mode & ProfileMode) {
            resumeActualRenderTimerIfPaused();
            recordElapsedActualRenderTime(interruptedWork);
          }
        }

        switch (interruptedWork.tag) {
          case ClassComponent:
            {
              popContextProvider(interruptedWork);
              break;
            }

          case HostRoot:
            {
              popHostContainer(interruptedWork);
              popTopLevelContextObject(interruptedWork);
              break;
            }

          case HostComponent:
            {
              popHostContext(interruptedWork);
              break;
            }

          case HostPortal:
            popHostContainer(interruptedWork);
            break;

          case ContextProvider:
            popProvider(interruptedWork);
            break;

          default:
            break;
        }
      }

      var invokeGuardedCallback$2 = ReactErrorUtils.invokeGuardedCallback;
      var hasCaughtError = ReactErrorUtils.hasCaughtError;
      var clearCaughtError = ReactErrorUtils.clearCaughtError;
      var didWarnAboutStateTransition = void 0;
      var didWarnSetStateChildContext = void 0;
      var warnAboutUpdateOnUnmounted = void 0;
      var warnAboutInvalidUpdates = void 0;
      {
        didWarnAboutStateTransition = false;
        didWarnSetStateChildContext = false;
        var didWarnStateUpdateForUnmountedComponent = {};

        warnAboutUpdateOnUnmounted = function warnAboutUpdateOnUnmounted(fiber) {
          var componentName = getComponentName(fiber) || "ReactClass";

          if (didWarnStateUpdateForUnmountedComponent[componentName]) {
            return;
          }

          warning(false, "Can't call setState (or forceUpdate) 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 the " + "componentWillUnmount method.%s", getStackAddendumByWorkInProgressFiber(fiber));
          didWarnStateUpdateForUnmountedComponent[componentName] = true;
        };

        warnAboutInvalidUpdates = function warnAboutInvalidUpdates(instance) {
          switch (ReactDebugCurrentFiber.phase) {
            case "getChildContext":
              if (didWarnSetStateChildContext) {
                return;
              }

              warning(false, "setState(...): Cannot call setState() inside getChildContext()");
              didWarnSetStateChildContext = true;
              break;

            case "render":
              if (didWarnAboutStateTransition) {
                return;
              }

              warning(false, "Cannot update during an existing state transition (such as within " + "`render` or another component's constructor). Render methods should " + "be a pure function of props and state; constructor side-effects are " + "an anti-pattern, but can be moved to `componentWillMount`.");
              didWarnAboutStateTransition = true;
              break;
          }
        };
      }
      var originalStartTimeMs = now();
      var mostRecentCurrentTime = msToExpirationTime(0);
      var mostRecentCurrentTimeMs = originalStartTimeMs;
      var lastUniqueAsyncExpiration = 0;
      var expirationContext = NoWork;
      var isWorking = false;
      var nextUnitOfWork = null;
      var nextRoot = null;
      var nextRenderExpirationTime = NoWork;
      var nextLatestTimeoutMs = -1;
      var nextRenderDidError = false;
      var nextEffect = null;
      var isCommitting$1 = false;
      var legacyErrorBoundariesThatAlreadyFailed = null;
      var interruptedBy = null;
      var stashedWorkInProgressProperties = void 0;
      var replayUnitOfWork = void 0;
      var isReplayingFailedUnitOfWork = void 0;
      var originalReplayError = void 0;
      var rethrowOriginalError = void 0;

      if (true && replayFailedUnitOfWorkWithInvokeGuardedCallback) {
        stashedWorkInProgressProperties = null;
        isReplayingFailedUnitOfWork = false;
        originalReplayError = null;

        replayUnitOfWork = function replayUnitOfWork(failedUnitOfWork, thrownValue, isYieldy) {
          if (thrownValue !== null && typeof thrownValue === "object" && typeof thrownValue.then === "function") {
            return;
          }

          if (stashedWorkInProgressProperties === null) {
            warning(false, "Could not replay rendering after an error. This is likely a bug in React. " + "Please file an issue.");
            return;
          }

          assignFiberPropertiesInDEV(failedUnitOfWork, stashedWorkInProgressProperties);

          switch (failedUnitOfWork.tag) {
            case HostRoot:
              popHostContainer(failedUnitOfWork);
              popTopLevelContextObject(failedUnitOfWork);
              break;

            case HostComponent:
              popHostContext(failedUnitOfWork);
              break;

            case ClassComponent:
              popContextProvider(failedUnitOfWork);
              break;

            case HostPortal:
              popHostContainer(failedUnitOfWork);
              break;

            case ContextProvider:
              popProvider(failedUnitOfWork);
              break;
          }

          isReplayingFailedUnitOfWork = true;
          originalReplayError = thrownValue;
          invokeGuardedCallback$2(null, workLoop, null, isYieldy);
          isReplayingFailedUnitOfWork = false;
          originalReplayError = null;

          if (hasCaughtError()) {
            clearCaughtError();

            if (enableProfilerTimer) {
              if (failedUnitOfWork.mode & ProfileMode) {
                recordElapsedActualRenderTime(failedUnitOfWork);
              }

              stopBaseRenderTimerIfRunning();
            }
          } else {
            nextUnitOfWork = failedUnitOfWork;
          }
        };

        rethrowOriginalError = function rethrowOriginalError() {
          throw originalReplayError;
        };
      }

      function resetStack() {
        if (nextUnitOfWork !== null) {
          var interruptedWork = nextUnitOfWork.return;

          while (interruptedWork !== null) {
            unwindInterruptedWork(interruptedWork);
            interruptedWork = interruptedWork.return;
          }
        }

        {
          ReactStrictModeWarnings.discardPendingWarnings();
          checkThatStackIsEmpty();
        }
        nextRoot = null;
        nextRenderExpirationTime = NoWork;
        nextLatestTimeoutMs = -1;
        nextRenderDidError = false;
        nextUnitOfWork = null;
      }

      function commitAllHostEffects() {
        while (nextEffect !== null) {
          {
            ReactDebugCurrentFiber.setCurrentFiber(nextEffect);
          }
          recordEffect();
          var effectTag = nextEffect.effectTag;

          if (effectTag & ContentReset) {
            commitResetTextContent(nextEffect);
          }

          if (effectTag & Ref) {
            var current = nextEffect.alternate;

            if (current !== null) {
              commitDetachRef(current);
            }
          }

          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);
                break;
              }
          }

          nextEffect = nextEffect.nextEffect;
        }

        {
          ReactDebugCurrentFiber.resetCurrentFiber();
        }
      }

      function commitBeforeMutationLifecycles() {
        while (nextEffect !== null) {
          var effectTag = nextEffect.effectTag;

          if (effectTag & Snapshot) {
            recordEffect();
            var current = nextEffect.alternate;
            commitBeforeMutationLifeCycles(current, nextEffect);
          }

          nextEffect = nextEffect.nextEffect;
        }
      }

      function commitAllLifeCycles(finishedRoot, currentTime, committedExpirationTime) {
        {
          ReactStrictModeWarnings.flushPendingUnsafeLifecycleWarnings();

          if (warnAboutDeprecatedLifecycles) {
            ReactStrictModeWarnings.flushPendingDeprecationWarnings();
          }

          if (warnAboutLegacyContextAPI) {
            ReactStrictModeWarnings.flushLegacyContextWarning();
          }
        }

        while (nextEffect !== null) {
          var effectTag = nextEffect.effectTag;

          if (effectTag & (Update | Callback)) {
            recordEffect();
            var current = nextEffect.alternate;
            commitLifeCycles(finishedRoot, current, nextEffect, currentTime, committedExpirationTime);
          }

          if (effectTag & Ref) {
            recordEffect();
            commitAttachRef(nextEffect);
          }

          var next = nextEffect.nextEffect;
          nextEffect.nextEffect = null;
          nextEffect = next;
        }
      }

      function isAlreadyFailedLegacyErrorBoundary(instance) {
        return legacyErrorBoundariesThatAlreadyFailed !== null && legacyErrorBoundariesThatAlreadyFailed.has(instance);
      }

      function markLegacyErrorBoundaryAsFailed(instance) {
        if (legacyErrorBoundariesThatAlreadyFailed === null) {
          legacyErrorBoundariesThatAlreadyFailed = new Set([instance]);
        } else {
          legacyErrorBoundariesThatAlreadyFailed.add(instance);
        }
      }

      function commitRoot(root, finishedWork) {
        isWorking = true;
        isCommitting$1 = true;
        startCommitTimer();
        invariant(root.current !== finishedWork, "Cannot commit the same tree as before. This is probably a bug " + "related to the return field. This error is likely caused by a bug " + "in React. Please file an issue.");
        var committedExpirationTime = root.pendingCommitExpirationTime;
        invariant(committedExpirationTime !== NoWork, "Cannot commit an incomplete root. This error is likely caused by a " + "bug in React. Please file an issue.");
        root.pendingCommitExpirationTime = NoWork;
        var earliestRemainingTime = finishedWork.expirationTime;
        var currentTime = recalculateCurrentTime();
        markCommittedPriorityLevels(root, currentTime, earliestRemainingTime);
        ReactCurrentOwner.current = null;
        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;
        }

        prepareForCommit(root.containerInfo);
        nextEffect = firstEffect;
        startCommitSnapshotEffectsTimer();

        while (nextEffect !== null) {
          var didError = false;
          var error = void 0;
          {
            invokeGuardedCallback$2(null, commitBeforeMutationLifecycles, null);

            if (hasCaughtError()) {
              didError = true;
              error = clearCaughtError();
            }
          }

          if (didError) {
            invariant(nextEffect !== null, "Should have next effect. This error is likely caused by a bug " + "in React. Please file an issue.");
            captureCommitPhaseError(nextEffect, error);

            if (nextEffect !== null) {
              nextEffect = nextEffect.nextEffect;
            }
          }
        }

        stopCommitSnapshotEffectsTimer();

        if (enableProfilerTimer) {
          recordCommitTime();
        }

        nextEffect = firstEffect;
        startCommitHostEffectsTimer();

        while (nextEffect !== null) {
          var _didError = false;

          var _error = void 0;

          {
            invokeGuardedCallback$2(null, commitAllHostEffects, null);

            if (hasCaughtError()) {
              _didError = true;
              _error = clearCaughtError();
            }
          }

          if (_didError) {
            invariant(nextEffect !== null, "Should have next effect. This error is likely caused by a bug " + "in React. Please file an issue.");
            captureCommitPhaseError(nextEffect, _error);

            if (nextEffect !== null) {
              nextEffect = nextEffect.nextEffect;
            }
          }
        }

        stopCommitHostEffectsTimer();
        resetAfterCommit(root.containerInfo);
        root.current = finishedWork;
        nextEffect = firstEffect;
        startCommitLifeCyclesTimer();

        while (nextEffect !== null) {
          var _didError2 = false;

          var _error2 = void 0;

          {
            invokeGuardedCallback$2(null, commitAllLifeCycles, null, root, currentTime, committedExpirationTime);

            if (hasCaughtError()) {
              _didError2 = true;
              _error2 = clearCaughtError();
            }
          }

          if (_didError2) {
            invariant(nextEffect !== null, "Should have next effect. This error is likely caused by a bug " + "in React. Please file an issue.");
            captureCommitPhaseError(nextEffect, _error2);

            if (nextEffect !== null) {
              nextEffect = nextEffect.nextEffect;
            }
          }
        }

        if (enableProfilerTimer) {
          {
            checkActualRenderTimeStackEmpty();
          }
          resetActualRenderTimer();
        }

        isCommitting$1 = false;
        isWorking = false;
        stopCommitLifeCyclesTimer();
        stopCommitTimer();

        if (typeof onCommitRoot === "function") {
          onCommitRoot(finishedWork.stateNode);
        }

        if (true && ReactFiberInstrumentation_1.debugTool) {
          ReactFiberInstrumentation_1.debugTool.onCommitWork(finishedWork);
        }

        var expirationTime = root.expirationTime;

        if (expirationTime === NoWork) {
          legacyErrorBoundariesThatAlreadyFailed = null;
        }

        onCommit(root, expirationTime);
      }

      function resetExpirationTime(workInProgress, renderTime) {
        if (renderTime !== Never && workInProgress.expirationTime === Never) {
          return;
        }

        var newExpirationTime = NoWork;

        switch (workInProgress.tag) {
          case HostRoot:
          case ClassComponent:
            {
              var updateQueue = workInProgress.updateQueue;

              if (updateQueue !== null) {
                newExpirationTime = updateQueue.expirationTime;
              }
            }
        }

        if (enableProfilerTimer && workInProgress.mode & ProfileMode) {
          var treeBaseTime = workInProgress.selfBaseTime;
          var child = workInProgress.child;

          while (child !== null) {
            treeBaseTime += child.treeBaseTime;

            if (child.expirationTime !== NoWork && (newExpirationTime === NoWork || newExpirationTime > child.expirationTime)) {
              newExpirationTime = child.expirationTime;
            }

            child = child.sibling;
          }

          workInProgress.treeBaseTime = treeBaseTime;
        } else {
          var _child = workInProgress.child;

          while (_child !== null) {
            if (_child.expirationTime !== NoWork && (newExpirationTime === NoWork || newExpirationTime > _child.expirationTime)) {
              newExpirationTime = _child.expirationTime;
            }

            _child = _child.sibling;
          }
        }

        workInProgress.expirationTime = newExpirationTime;
      }

      function completeUnitOfWork(workInProgress) {
        while (true) {
          var current = workInProgress.alternate;
          {
            ReactDebugCurrentFiber.setCurrentFiber(workInProgress);
          }
          var returnFiber = workInProgress.return;
          var siblingFiber = workInProgress.sibling;

          if ((workInProgress.effectTag & Incomplete) === NoEffect) {
            var next = completeWork(current, workInProgress, nextRenderExpirationTime);
            stopWorkTimer(workInProgress);
            resetExpirationTime(workInProgress, nextRenderExpirationTime);
            {
              ReactDebugCurrentFiber.resetCurrentFiber();
            }

            if (next !== null) {
              stopWorkTimer(workInProgress);

              if (true && ReactFiberInstrumentation_1.debugTool) {
                ReactFiberInstrumentation_1.debugTool.onCompleteWork(workInProgress);
              }

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

            if (true && ReactFiberInstrumentation_1.debugTool) {
              ReactFiberInstrumentation_1.debugTool.onCompleteWork(workInProgress);
            }

            if (siblingFiber !== null) {
              return siblingFiber;
            } else if (returnFiber !== null) {
              workInProgress = returnFiber;
              continue;
            } else {
              return null;
            }
          } else {
            var _next = unwindWork(workInProgress, nextRenderExpirationTime);

            if (workInProgress.effectTag & DidCapture) {
              stopFailedWorkTimer(workInProgress);
            } else {
              stopWorkTimer(workInProgress);
            }

            {
              ReactDebugCurrentFiber.resetCurrentFiber();
            }

            if (_next !== null) {
              stopWorkTimer(workInProgress);

              if (true && ReactFiberInstrumentation_1.debugTool) {
                ReactFiberInstrumentation_1.debugTool.onCompleteWork(workInProgress);
              }

              _next.effectTag &= HostEffectMask;
              return _next;
            }

            if (returnFiber !== null) {
              returnFiber.firstEffect = returnFiber.lastEffect = null;
              returnFiber.effectTag |= Incomplete;
            }

            if (true && ReactFiberInstrumentation_1.debugTool) {
              ReactFiberInstrumentation_1.debugTool.onCompleteWork(workInProgress);
            }

            if (siblingFiber !== null) {
              return siblingFiber;
            } else if (returnFiber !== null) {
              workInProgress = returnFiber;
              continue;
            } else {
              return null;
            }
          }
        }

        return null;
      }

      function performUnitOfWork(workInProgress) {
        var current = workInProgress.alternate;
        startWorkTimer(workInProgress);
        {
          ReactDebugCurrentFiber.setCurrentFiber(workInProgress);
        }

        if (true && replayFailedUnitOfWorkWithInvokeGuardedCallback) {
          stashedWorkInProgressProperties = assignFiberPropertiesInDEV(stashedWorkInProgressProperties, workInProgress);
        }

        var next = void 0;

        if (enableProfilerTimer) {
          if (workInProgress.mode & ProfileMode) {
            startBaseRenderTimer();
          }

          next = beginWork(current, workInProgress, nextRenderExpirationTime);

          if (workInProgress.mode & ProfileMode) {
            recordElapsedBaseRenderTimeIfRunning(workInProgress);
            stopBaseRenderTimerIfRunning();
          }
        } else {
          next = beginWork(current, workInProgress, nextRenderExpirationTime);
        }

        {
          ReactDebugCurrentFiber.resetCurrentFiber();

          if (isReplayingFailedUnitOfWork) {
            rethrowOriginalError();
          }
        }

        if (true && ReactFiberInstrumentation_1.debugTool) {
          ReactFiberInstrumentation_1.debugTool.onBeginWork(workInProgress);
        }

        if (next === null) {
          next = completeUnitOfWork(workInProgress);
        }

        ReactCurrentOwner.current = null;
        return next;
      }

      function workLoop(isYieldy) {
        if (!isYieldy) {
          while (nextUnitOfWork !== null) {
            nextUnitOfWork = performUnitOfWork(nextUnitOfWork);
          }
        } else {
          while (nextUnitOfWork !== null && !shouldYield()) {
            nextUnitOfWork = performUnitOfWork(nextUnitOfWork);
          }

          if (enableProfilerTimer) {
            pauseActualRenderTimerIfRunning();
          }
        }
      }

      function renderRoot(root, isYieldy) {
        invariant(!isWorking, "renderRoot was called recursively. This error is likely caused " + "by a bug in React. Please file an issue.");
        isWorking = true;
        var expirationTime = root.nextExpirationTimeToWorkOn;

        if (expirationTime !== nextRenderExpirationTime || root !== nextRoot || nextUnitOfWork === null) {
          resetStack();
          nextRoot = root;
          nextRenderExpirationTime = expirationTime;
          nextLatestTimeoutMs = -1;
          nextRenderDidError = false;
          nextUnitOfWork = createWorkInProgress(nextRoot.current, null, nextRenderExpirationTime);
          root.pendingCommitExpirationTime = NoWork;
        }

        var didFatal = false;
        startWorkLoopTimer(nextUnitOfWork);

        do {
          try {
            workLoop(isYieldy);
          } catch (thrownValue) {
            if (enableProfilerTimer) {
              stopBaseRenderTimerIfRunning();
            }

            if (nextUnitOfWork === null) {
              didFatal = true;
              onUncaughtError(thrownValue);
            } else {
              {
                resetCurrentlyProcessingQueue();
              }
              var failedUnitOfWork = nextUnitOfWork;

              if (true && replayFailedUnitOfWorkWithInvokeGuardedCallback) {
                replayUnitOfWork(failedUnitOfWork, thrownValue, isYieldy);
              }

              invariant(nextUnitOfWork !== null, "Failed to replay rendering after an error. This " + "is likely caused by a bug in React. Please file an issue " + "with a reproducing case to help us find it.");
              var sourceFiber = nextUnitOfWork;
              var returnFiber = sourceFiber.return;

              if (returnFiber === null) {
                didFatal = true;
                onUncaughtError(thrownValue);
                break;
              }

              throwException(root, returnFiber, sourceFiber, thrownValue, nextRenderExpirationTime, mostRecentCurrentTimeMs);
              nextUnitOfWork = completeUnitOfWork(sourceFiber);
            }
          }

          break;
        } while (true);

        isWorking = false;

        if (didFatal) {
          var didCompleteRoot = false;
          stopWorkLoopTimer(interruptedBy, didCompleteRoot);
          interruptedBy = null;
          {
            resetStackAfterFatalErrorInDev();
          }
          onFatal(root);
        } else if (nextUnitOfWork === null) {
          var rootWorkInProgress = root.current.alternate;
          invariant(rootWorkInProgress !== null, "Finished root should have a work-in-progress. This error is likely " + "caused by a bug in React. Please file an issue.");

          if ((rootWorkInProgress.effectTag & Incomplete) === NoEffect) {
            var _didCompleteRoot = true;
            stopWorkLoopTimer(interruptedBy, _didCompleteRoot);
            interruptedBy = null;
            onComplete(root, rootWorkInProgress, expirationTime);
          } else {
            var _didCompleteRoot2 = false;
            stopWorkLoopTimer(interruptedBy, _didCompleteRoot2);
            interruptedBy = null;
            markSuspendedPriorityLevel(root, expirationTime, nextRenderDidError);
            var suspendedExpirationTime = expirationTime;
            var newExpirationTime = root.expirationTime;
            onSuspend(root, suspendedExpirationTime, newExpirationTime, nextLatestTimeoutMs);
          }
        } else {
          var _didCompleteRoot3 = false;
          stopWorkLoopTimer(interruptedBy, _didCompleteRoot3);
          interruptedBy = null;
          onYield(root);
        }
      }

      function dispatch(sourceFiber, value, expirationTime) {
        invariant(!isWorking || isCommitting$1, "dispatch: Cannot dispatch during the render phase.");
        var fiber = sourceFiber.return;

        while (fiber !== null) {
          switch (fiber.tag) {
            case ClassComponent:
              var ctor = fiber.type;
              var instance = fiber.stateNode;

              if (typeof ctor.getDerivedStateFromCatch === "function" || typeof instance.componentDidCatch === "function" && !isAlreadyFailedLegacyErrorBoundary(instance)) {
                var errorInfo = createCapturedValue(value, sourceFiber);
                var update = createClassErrorUpdate(fiber, errorInfo, expirationTime);
                enqueueUpdate(fiber, update, expirationTime);
                scheduleWork(fiber, expirationTime);
                return;
              }

              break;

            case HostRoot:
              {
                var _errorInfo = createCapturedValue(value, sourceFiber);

                var _update = createRootErrorUpdate(fiber, _errorInfo, expirationTime);

                enqueueUpdate(fiber, _update, expirationTime);
                scheduleWork(fiber, expirationTime);
                return;
              }
          }

          fiber = fiber.return;
        }

        if (sourceFiber.tag === HostRoot) {
          var rootFiber = sourceFiber;

          var _errorInfo2 = createCapturedValue(value, rootFiber);

          var _update2 = createRootErrorUpdate(rootFiber, _errorInfo2, expirationTime);

          enqueueUpdate(rootFiber, _update2, expirationTime);
          scheduleWork(rootFiber, expirationTime);
        }
      }

      function captureCommitPhaseError(fiber, error) {
        return dispatch(fiber, error, Sync);
      }

      function computeAsyncExpiration(currentTime) {
        var expirationMs = 5000;
        var bucketSizeMs = 250;
        return computeExpirationBucket(currentTime, expirationMs, bucketSizeMs);
      }

      function computeInteractiveExpiration(currentTime) {
        var expirationMs = void 0;
        {
          expirationMs = 500;
        }
        var bucketSizeMs = 100;
        return computeExpirationBucket(currentTime, expirationMs, bucketSizeMs);
      }

      function computeUniqueAsyncExpiration() {
        var currentTime = recalculateCurrentTime();
        var result = computeAsyncExpiration(currentTime);

        if (result <= lastUniqueAsyncExpiration) {
          result = lastUniqueAsyncExpiration + 1;
        }

        lastUniqueAsyncExpiration = result;
        return lastUniqueAsyncExpiration;
      }

      function computeExpirationForFiber(currentTime, fiber) {
        var expirationTime = void 0;

        if (expirationContext !== NoWork) {
          expirationTime = expirationContext;
        } else if (isWorking) {
          if (isCommitting$1) {
            expirationTime = Sync;
          } else {
            expirationTime = nextRenderExpirationTime;
          }
        } else {
          if (fiber.mode & AsyncMode) {
            if (isBatchingInteractiveUpdates) {
              expirationTime = computeInteractiveExpiration(currentTime);
            } else {
              expirationTime = computeAsyncExpiration(currentTime);
            }
          } else {
            expirationTime = Sync;
          }
        }

        if (isBatchingInteractiveUpdates) {
          if (lowestPendingInteractiveExpirationTime === NoWork || expirationTime > lowestPendingInteractiveExpirationTime) {
            lowestPendingInteractiveExpirationTime = expirationTime;
          }
        }

        return expirationTime;
      }

      function markTimeout(root, thenable, timeoutMs, suspendedTime) {
        if (timeoutMs >= 0 && nextLatestTimeoutMs < timeoutMs) {
          nextLatestTimeoutMs = timeoutMs;
        }
      }

      function markError(root) {
        nextRenderDidError = true;
      }

      function retrySuspendedRoot(root, suspendedTime) {
        markPingedPriorityLevel(root, suspendedTime);
        var retryTime = root.expirationTime;

        if (retryTime !== NoWork) {
          requestWork(root, retryTime);
        }
      }

      function scheduleWork(fiber, expirationTime) {
        recordScheduleUpdate();
        {
          if (fiber.tag === ClassComponent) {
            var instance = fiber.stateNode;
            warnAboutInvalidUpdates(instance);
          }
        }
        var node = fiber;

        while (node !== null) {
          if (node.expirationTime === NoWork || node.expirationTime > expirationTime) {
            node.expirationTime = expirationTime;
          }

          if (node.alternate !== null) {
            if (node.alternate.expirationTime === NoWork || node.alternate.expirationTime > expirationTime) {
              node.alternate.expirationTime = expirationTime;
            }
          }

          if (node.return === null) {
            if (node.tag === HostRoot) {
              var root = node.stateNode;

              if (!isWorking && nextRenderExpirationTime !== NoWork && expirationTime < nextRenderExpirationTime) {
                interruptedBy = fiber;
                resetStack();
              }

              markPendingPriorityLevel(root, expirationTime);

              if (!isWorking || isCommitting$1 || nextRoot !== root) {
                var rootExpirationTime = root.expirationTime;
                requestWork(root, rootExpirationTime);
              }

              if (nestedUpdateCount > NESTED_UPDATE_LIMIT) {
                invariant(false, "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.");
              }
            } else {
              {
                if (fiber.tag === ClassComponent) {
                  warnAboutUpdateOnUnmounted(fiber);
                }
              }
              return;
            }
          }

          node = node.return;
        }
      }

      function recalculateCurrentTime() {
        mostRecentCurrentTimeMs = now() - originalStartTimeMs;
        mostRecentCurrentTime = msToExpirationTime(mostRecentCurrentTimeMs);
        return mostRecentCurrentTime;
      }

      function deferredUpdates(fn) {
        var previousExpirationContext = expirationContext;
        var currentTime = recalculateCurrentTime();
        expirationContext = computeAsyncExpiration(currentTime);

        try {
          return fn();
        } finally {
          expirationContext = previousExpirationContext;
        }
      }

      function syncUpdates(fn, a, b, c, d) {
        var previousExpirationContext = expirationContext;
        expirationContext = Sync;

        try {
          return fn(a, b, c, d);
        } finally {
          expirationContext = previousExpirationContext;
        }
      }

      var firstScheduledRoot = null;
      var lastScheduledRoot = null;
      var callbackExpirationTime = NoWork;
      var callbackID = void 0;
      var isRendering = false;
      var nextFlushedRoot = null;
      var nextFlushedExpirationTime = NoWork;
      var lowestPendingInteractiveExpirationTime = NoWork;
      var deadlineDidExpire = false;
      var hasUnhandledError = false;
      var unhandledError = null;
      var deadline = null;
      var isBatchingUpdates = false;
      var isUnbatchingUpdates = false;
      var isBatchingInteractiveUpdates = false;
      var completedBatches = null;
      var NESTED_UPDATE_LIMIT = 1000;
      var nestedUpdateCount = 0;
      var timeHeuristicForUnitOfWork = 1;

      function scheduleCallbackWithExpirationTime(expirationTime) {
        if (callbackExpirationTime !== NoWork) {
          if (expirationTime > callbackExpirationTime) {
            return;
          } else {
            if (callbackID !== null) {
              cancelDeferredCallback(callbackID);
            }
          }
        } else {
          startRequestCallbackTimer();
        }

        callbackExpirationTime = expirationTime;
        var currentMs = now() - originalStartTimeMs;
        var expirationTimeMs = expirationTimeToMs(expirationTime);
        var timeout = expirationTimeMs - currentMs;
        callbackID = scheduleDeferredCallback(performAsyncWork, {
          timeout: timeout
        });
      }

      function onFatal(root) {
        root.finishedWork = null;
      }

      function onComplete(root, finishedWork, expirationTime) {
        root.pendingCommitExpirationTime = expirationTime;
        root.finishedWork = finishedWork;
      }

      function onSuspend(root, suspendedExpirationTime, expirationTime, timeoutMs) {
        if (timeoutMs >= 0) {
          var suspendedRoot = root;
          setTimeout(function () {
            retrySuspendedRoot(suspendedRoot, suspendedExpirationTime);
          }, timeoutMs);
        }

        root.expirationTime = expirationTime;
      }

      function onYield(root) {
        root.finishedWork = null;
      }

      function onCommit(root, expirationTime) {
        root.expirationTime = expirationTime;
        root.finishedWork = null;
      }

      function requestWork(root, expirationTime) {
        addRootToSchedule(root, expirationTime);

        if (isRendering) {
          return;
        }

        if (isBatchingUpdates) {
          if (isUnbatchingUpdates) {
            nextFlushedRoot = root;
            nextFlushedExpirationTime = Sync;
            performWorkOnRoot(root, Sync, false);
          }

          return;
        }

        if (expirationTime === Sync) {
          performSyncWork();
        } else {
          scheduleCallbackWithExpirationTime(expirationTime);
        }
      }

      function addRootToSchedule(root, expirationTime) {
        if (root.nextScheduledRoot === null) {
          root.expirationTime = expirationTime;

          if (lastScheduledRoot === null) {
            firstScheduledRoot = lastScheduledRoot = root;
            root.nextScheduledRoot = root;
          } else {
            lastScheduledRoot.nextScheduledRoot = root;
            lastScheduledRoot = root;
            lastScheduledRoot.nextScheduledRoot = firstScheduledRoot;
          }
        } else {
          var remainingExpirationTime = root.expirationTime;

          if (remainingExpirationTime === NoWork || expirationTime < remainingExpirationTime) {
            root.expirationTime = expirationTime;
          }
        }
      }

      function findHighestPriorityRoot() {
        var highestPriorityWork = NoWork;
        var highestPriorityRoot = null;

        if (lastScheduledRoot !== null) {
          var previousScheduledRoot = lastScheduledRoot;
          var root = firstScheduledRoot;

          while (root !== null) {
            var remainingExpirationTime = root.expirationTime;

            if (remainingExpirationTime === NoWork) {
              invariant(previousScheduledRoot !== null && lastScheduledRoot !== null, "Should have a previous and last root. This error is likely " + "caused by a bug in React. Please file an issue.");

              if (root === root.nextScheduledRoot) {
                root.nextScheduledRoot = null;
                firstScheduledRoot = lastScheduledRoot = null;
                break;
              } else if (root === firstScheduledRoot) {
                var next = root.nextScheduledRoot;
                firstScheduledRoot = next;
                lastScheduledRoot.nextScheduledRoot = next;
                root.nextScheduledRoot = null;
              } else if (root === lastScheduledRoot) {
                lastScheduledRoot = previousScheduledRoot;
                lastScheduledRoot.nextScheduledRoot = firstScheduledRoot;
                root.nextScheduledRoot = null;
                break;
              } else {
                previousScheduledRoot.nextScheduledRoot = root.nextScheduledRoot;
                root.nextScheduledRoot = null;
              }

              root = previousScheduledRoot.nextScheduledRoot;
            } else {
              if (highestPriorityWork === NoWork || remainingExpirationTime < highestPriorityWork) {
                highestPriorityWork = remainingExpirationTime;
                highestPriorityRoot = root;
              }

              if (root === lastScheduledRoot) {
                break;
              }

              previousScheduledRoot = root;
              root = root.nextScheduledRoot;
            }
          }
        }

        var previousFlushedRoot = nextFlushedRoot;

        if (previousFlushedRoot !== null && previousFlushedRoot === highestPriorityRoot && highestPriorityWork === Sync) {
          nestedUpdateCount++;
        } else {
          nestedUpdateCount = 0;
        }

        nextFlushedRoot = highestPriorityRoot;
        nextFlushedExpirationTime = highestPriorityWork;
      }

      function performAsyncWork(dl) {
        performWork(NoWork, dl);
      }

      function performSyncWork() {
        performWork(Sync, null);
      }

      function performWork(minExpirationTime, dl) {
        deadline = dl;
        findHighestPriorityRoot();

        if (enableProfilerTimer) {
          resumeActualRenderTimerIfPaused();
        }

        if (enableUserTimingAPI && deadline !== null) {
          var didExpire = nextFlushedExpirationTime < recalculateCurrentTime();
          var timeout = expirationTimeToMs(nextFlushedExpirationTime);
          stopRequestCallbackTimer(didExpire, timeout);
        }

        if (deadline !== null) {
          while (nextFlushedRoot !== null && nextFlushedExpirationTime !== NoWork && (minExpirationTime === NoWork || minExpirationTime >= nextFlushedExpirationTime) && (!deadlineDidExpire || recalculateCurrentTime() >= nextFlushedExpirationTime)) {
            recalculateCurrentTime();
            performWorkOnRoot(nextFlushedRoot, nextFlushedExpirationTime, true);
            findHighestPriorityRoot();
          }
        } else {
          while (nextFlushedRoot !== null && nextFlushedExpirationTime !== NoWork && (minExpirationTime === NoWork || minExpirationTime >= nextFlushedExpirationTime)) {
            performWorkOnRoot(nextFlushedRoot, nextFlushedExpirationTime, false);
            findHighestPriorityRoot();
          }
        }

        if (deadline !== null) {
          callbackExpirationTime = NoWork;
          callbackID = null;
        }

        if (nextFlushedExpirationTime !== NoWork) {
          scheduleCallbackWithExpirationTime(nextFlushedExpirationTime);
        }

        deadline = null;
        deadlineDidExpire = false;
        finishRendering();
      }

      function flushRoot(root, expirationTime) {
        invariant(!isRendering, "work.commit(): Cannot commit while already rendering. This likely " + "means you attempted to commit from inside a lifecycle method.");
        nextFlushedRoot = root;
        nextFlushedExpirationTime = expirationTime;
        performWorkOnRoot(root, expirationTime, false);
        performSyncWork();
        finishRendering();
      }

      function finishRendering() {
        nestedUpdateCount = 0;

        if (completedBatches !== null) {
          var batches = completedBatches;
          completedBatches = null;

          for (var i = 0; i < batches.length; i++) {
            var batch = batches[i];

            try {
              batch._onComplete();
            } catch (error) {
              if (!hasUnhandledError) {
                hasUnhandledError = true;
                unhandledError = error;
              }
            }
          }
        }

        if (hasUnhandledError) {
          var error = unhandledError;
          unhandledError = null;
          hasUnhandledError = false;
          throw error;
        }
      }

      function performWorkOnRoot(root, expirationTime, isYieldy) {
        invariant(!isRendering, "performWorkOnRoot was called recursively. This error is likely caused " + "by a bug in React. Please file an issue.");
        isRendering = true;

        if (!isYieldy) {
          var finishedWork = root.finishedWork;

          if (finishedWork !== null) {
            completeRoot$1(root, finishedWork, expirationTime);
          } else {
            root.finishedWork = null;
            renderRoot(root, false);
            finishedWork = root.finishedWork;

            if (finishedWork !== null) {
              completeRoot$1(root, finishedWork, expirationTime);
            }
          }
        } else {
          var _finishedWork = root.finishedWork;

          if (_finishedWork !== null) {
            completeRoot$1(root, _finishedWork, expirationTime);
          } else {
            root.finishedWork = null;
            renderRoot(root, true);
            _finishedWork = root.finishedWork;

            if (_finishedWork !== null) {
              if (!shouldYield()) {
                completeRoot$1(root, _finishedWork, expirationTime);
              } else {
                root.finishedWork = _finishedWork;

                if (enableProfilerTimer) {
                  pauseActualRenderTimerIfRunning();
                }
              }
            }
          }
        }

        isRendering = false;
      }

      function completeRoot$1(root, finishedWork, expirationTime) {
        var firstBatch = root.firstBatch;

        if (firstBatch !== null && firstBatch._expirationTime <= expirationTime) {
          if (completedBatches === null) {
            completedBatches = [firstBatch];
          } else {
            completedBatches.push(firstBatch);
          }

          if (firstBatch._defer) {
            root.finishedWork = finishedWork;
            root.expirationTime = NoWork;
            return;
          }
        }

        root.finishedWork = null;
        commitRoot(root, finishedWork);
      }

      function shouldYield() {
        if (deadline === null || deadlineDidExpire) {
          return false;
        }

        if (deadline.timeRemaining() > timeHeuristicForUnitOfWork) {
          return false;
        }

        deadlineDidExpire = true;
        return true;
      }

      function onUncaughtError(error) {
        invariant(nextFlushedRoot !== null, "Should be working on a root. This error is likely caused by a bug in " + "React. Please file an issue.");
        nextFlushedRoot.expirationTime = NoWork;

        if (!hasUnhandledError) {
          hasUnhandledError = true;
          unhandledError = error;
        }
      }

      function batchedUpdates$1(fn, a) {
        var previousIsBatchingUpdates = isBatchingUpdates;
        isBatchingUpdates = true;

        try {
          return fn(a);
        } finally {
          isBatchingUpdates = previousIsBatchingUpdates;

          if (!isBatchingUpdates && !isRendering) {
            performSyncWork();
          }
        }
      }

      function unbatchedUpdates(fn, a) {
        if (isBatchingUpdates && !isUnbatchingUpdates) {
          isUnbatchingUpdates = true;

          try {
            return fn(a);
          } finally {
            isUnbatchingUpdates = false;
          }
        }

        return fn(a);
      }

      function flushSync(fn, a) {
        invariant(!isRendering, "flushSync was called from inside a lifecycle method. It cannot be " + "called when React is already rendering.");
        var previousIsBatchingUpdates = isBatchingUpdates;
        isBatchingUpdates = true;

        try {
          return syncUpdates(fn, a);
        } finally {
          isBatchingUpdates = previousIsBatchingUpdates;
          performSyncWork();
        }
      }

      function interactiveUpdates$1(fn, a, b) {
        if (isBatchingInteractiveUpdates) {
          return fn(a, b);
        }

        if (!isBatchingUpdates && !isRendering && lowestPendingInteractiveExpirationTime !== NoWork) {
          performWork(lowestPendingInteractiveExpirationTime, null);
          lowestPendingInteractiveExpirationTime = NoWork;
        }

        var previousIsBatchingInteractiveUpdates = isBatchingInteractiveUpdates;
        var previousIsBatchingUpdates = isBatchingUpdates;
        isBatchingInteractiveUpdates = true;
        isBatchingUpdates = true;

        try {
          return fn(a, b);
        } finally {
          isBatchingInteractiveUpdates = previousIsBatchingInteractiveUpdates;
          isBatchingUpdates = previousIsBatchingUpdates;

          if (!isBatchingUpdates && !isRendering) {
            performSyncWork();
          }
        }
      }

      function flushInteractiveUpdates$1() {
        if (!isRendering && lowestPendingInteractiveExpirationTime !== NoWork) {
          performWork(lowestPendingInteractiveExpirationTime, null);
          lowestPendingInteractiveExpirationTime = NoWork;
        }
      }

      function flushControlled(fn) {
        var previousIsBatchingUpdates = isBatchingUpdates;
        isBatchingUpdates = true;

        try {
          syncUpdates(fn);
        } finally {
          isBatchingUpdates = previousIsBatchingUpdates;

          if (!isBatchingUpdates && !isRendering) {
            performWork(Sync, null);
          }
        }
      }

      var didWarnAboutNestedUpdates = void 0;
      {
        didWarnAboutNestedUpdates = false;
      }

      function getContextForSubtree(parentComponent) {
        if (!parentComponent) {
          return emptyObject;
        }

        var fiber = get$1(parentComponent);
        var parentContext = findCurrentUnmaskedContext(fiber);
        return isContextProvider(fiber) ? processChildContext(fiber, parentContext) : parentContext;
      }

      function scheduleRootUpdate(current, element, expirationTime, callback) {
        {
          if (ReactDebugCurrentFiber.phase === "render" && ReactDebugCurrentFiber.current !== null && !didWarnAboutNestedUpdates) {
            didWarnAboutNestedUpdates = true;
            warning(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(ReactDebugCurrentFiber.current) || "Unknown");
          }
        }
        var update = createUpdate(expirationTime);
        update.payload = {
          element: element
        };
        callback = callback === undefined ? null : callback;

        if (callback !== null) {
          !(typeof callback === "function") ? warning(false, "render(...): Expected the last optional `callback` argument to be a " + "function. Instead received: %s.", callback) : void 0;
          update.callback = callback;
        }

        enqueueUpdate(current, update, expirationTime);
        scheduleWork(current, expirationTime);
        return expirationTime;
      }

      function updateContainerAtExpirationTime(element, container, parentComponent, expirationTime, callback) {
        var current = container.current;
        {
          if (ReactFiberInstrumentation_1.debugTool) {
            if (current.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, element, expirationTime, callback);
      }

      function findHostInstance$1(component) {
        var fiber = get$1(component);

        if (fiber === undefined) {
          if (typeof component.render === "function") {
            invariant(false, "Unable to find node on an unmounted component.");
          } else {
            invariant(false, "Argument appears to not be a ReactComponent. Keys: %s", Object.keys(component));
          }
        }

        var hostFiber = findCurrentHostFiber(fiber);

        if (hostFiber === null) {
          return null;
        }

        return hostFiber.stateNode;
      }

      function createContainer(containerInfo, isAsync, hydrate) {
        return createFiberRoot(containerInfo, isAsync, hydrate);
      }

      function updateContainer(element, container, parentComponent, callback) {
        var current = container.current;
        var currentTime = recalculateCurrentTime();
        var expirationTime = computeExpirationForFiber(currentTime, current);
        return updateContainerAtExpirationTime(element, container, parentComponent, expirationTime, 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;
        }
      }

      function findHostInstanceWithNoPortals(fiber) {
        var hostFiber = findCurrentHostFiberWithNoPortals(fiber);

        if (hostFiber === null) {
          return null;
        }

        return hostFiber.stateNode;
      }

      function injectIntoDevTools(devToolsConfig) {
        var _findFiberByHostInstance = devToolsConfig.findFiberByHostInstance;
        return injectInternals(_extends({}, devToolsConfig, {
          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);
          }
        }));
      }

      var ReactFabricRenderer = Object.freeze({
        updateContainerAtExpirationTime: updateContainerAtExpirationTime,
        createContainer: createContainer,
        updateContainer: updateContainer,
        flushRoot: flushRoot,
        requestWork: requestWork,
        computeUniqueAsyncExpiration: computeUniqueAsyncExpiration,
        batchedUpdates: batchedUpdates$1,
        unbatchedUpdates: unbatchedUpdates,
        deferredUpdates: deferredUpdates,
        syncUpdates: syncUpdates,
        interactiveUpdates: interactiveUpdates$1,
        flushInteractiveUpdates: flushInteractiveUpdates$1,
        flushControlled: flushControlled,
        flushSync: flushSync,
        getPublicRootInstance: getPublicRootInstance,
        findHostInstance: findHostInstance$1,
        findHostInstanceWithNoPortals: findHostInstanceWithNoPortals,
        injectIntoDevTools: injectIntoDevTools
      });

      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.4.1";

      var NativeMethodsMixin = function NativeMethodsMixin(findNodeHandle, findHostInstance) {
        var NativeMethodsMixin = {
          measure: function measure(callback) {
            UIManager.measure(findNodeHandle(this), mountSafeCallback(this, callback));
          },
          measureInWindow: function measureInWindow(callback) {
            UIManager.measureInWindow(findNodeHandle(this), mountSafeCallback(this, callback));
          },
          measureLayout: function measureLayout(relativeToNativeNode, onSuccess, onFail) {
            UIManager.measureLayout(findNodeHandle(this), relativeToNativeNode, mountSafeCallback(this, onFail), mountSafeCallback(this, onSuccess));
          },
          setNativeProps: function setNativeProps(nativeProps) {
            var maybeInstance = void 0;

            try {
              maybeInstance = findHostInstance(this);
            } catch (error) {}

            if (maybeInstance == null) {
              return;
            }

            var viewConfig = maybeInstance.viewConfig;
            {
              warnForStyleProps(nativeProps, viewConfig.validAttributes);
            }
            var updatePayload = create(nativeProps, viewConfig.validAttributes);

            if (updatePayload != null) {
              UIManager.updateView(maybeInstance._nativeTag, viewConfig.uiViewClassName, updatePayload);
            }
          },
          focus: function focus() {
            TextInputState.focusTextInput(findNodeHandle(this));
          },
          blur: function blur() {
            TextInputState.blurTextInput(findNodeHandle(this));
          }
        };
        {
          var NativeMethodsMixin_DEV = NativeMethodsMixin;
          invariant(!NativeMethodsMixin_DEV.componentWillMount && !NativeMethodsMixin_DEV.componentWillReceiveProps && !NativeMethodsMixin_DEV.UNSAFE_componentWillMount && !NativeMethodsMixin_DEV.UNSAFE_componentWillReceiveProps, "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() {
            TextInputState.blurTextInput(findNodeHandle(this));
          };

          ReactNativeComponent.prototype.focus = function focus() {
            TextInputState.focusTextInput(findNodeHandle(this));
          };

          ReactNativeComponent.prototype.measure = function measure(callback) {
            UIManager.measure(findNodeHandle(this), mountSafeCallback(this, callback));
          };

          ReactNativeComponent.prototype.measureInWindow = function measureInWindow(callback) {
            UIManager.measureInWindow(findNodeHandle(this), mountSafeCallback(this, callback));
          };

          ReactNativeComponent.prototype.measureLayout = function measureLayout(relativeToNativeNode, onSuccess, onFail) {
            UIManager.measureLayout(findNodeHandle(this), relativeToNativeNode, mountSafeCallback(this, onFail), mountSafeCallback(this, onSuccess));
          };

          ReactNativeComponent.prototype.setNativeProps = function setNativeProps(nativeProps) {
            var maybeInstance = void 0;

            try {
              maybeInstance = findHostInstance(this);
            } catch (error) {}

            if (maybeInstance == null) {
              return;
            }

            var viewConfig = maybeInstance.viewConfig || maybeInstance.canonical.viewConfig;
            var updatePayload = create(nativeProps, viewConfig.validAttributes);

            if (updatePayload != null) {
              UIManager.updateView(maybeInstance._nativeTag, viewConfig.uiViewClassName, updatePayload);
            }
          };

          return ReactNativeComponent;
        }(React.Component);

        return ReactNativeComponent;
      };

      var instanceCache = {};

      function getInstanceFromTag(tag) {
        return instanceCache[tag] || null;
      }

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

          return emptyObject;
        };

        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),
              getInspectorData: function getInspectorData(findNodeHandle) {
                return {
                  measure: function measure(callback) {
                    return 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,
              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 findHostInstance = findHostInstance$1;

      function findNodeHandle(componentOrHandle) {
        {
          var owner = ReactCurrentOwner.current;

          if (owner !== null && owner.stateNode !== null) {
            !owner.stateNode._warnedAboutRefsInRender ? warning(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) || "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 = findHostInstance(componentOrHandle);

        if (hostInstance == null) {
          return hostInstance;
        }

        if (hostInstance.canonical) {
          return hostInstance.canonical._nativeTag;
        }

        return hostInstance._nativeTag;
      }

      injection$2.injectRenderer(ReactFabricRenderer);
      var roots = new Map();
      var ReactFabric = {
        NativeComponent: ReactNativeComponent(findNodeHandle, findHostInstance),
        findNodeHandle: findNodeHandle,
        render: function render(element, containerTag, callback) {
          var root = roots.get(containerTag);

          if (!root) {
            root = createContainer(containerTag, false, 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.default : ReactFabric$3;
      module.exports = fabric;
    })();
  }
},489,[263,166,183,231,218,1,323,324,226,173,325,490,9,271],"node_modules/react-native/Libraries/Renderer/oss/ReactFabric-dev.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var FabricUIManager = global.nativeFabricUIManager;
  module.exports = FabricUIManager;
},490,[],"node_modules/react-native/Libraries/ReactNative/FabricUIManager.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  "use strict";

  function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

  _$$_REQUIRE(_dependencyMap[0], "InitializeCore");

  var invariant = _$$_REQUIRE(_dependencyMap[1], "fbjs/lib/invariant"),
      ReactNativeViewConfigRegistry = _$$_REQUIRE(_dependencyMap[2], "ReactNativeViewConfigRegistry"),
      UIManager = _$$_REQUIRE(_dependencyMap[3], "UIManager"),
      React = _$$_REQUIRE(_dependencyMap[4], "react"),
      emptyObject = _$$_REQUIRE(_dependencyMap[5], "fbjs/lib/emptyObject"),
      deepDiffer = _$$_REQUIRE(_dependencyMap[6], "deepDiffer"),
      flattenStyle = _$$_REQUIRE(_dependencyMap[7], "flattenStyle"),
      TextInputState = _$$_REQUIRE(_dependencyMap[8], "TextInputState"),
      FabricUIManager = _$$_REQUIRE(_dependencyMap[9], "FabricUIManager"),
      ExceptionsManager = _$$_REQUIRE(_dependencyMap[10], "ExceptionsManager");

  function _invokeGuardedCallback(name, func, context, a, b, c, d, e, f) {
    this._hasCaughtError = !1;
    this._caughtError = null;
    var funcArgs = Array.prototype.slice.call(arguments, 3);

    try {
      func.apply(context, funcArgs);
    } catch (error) {
      this._caughtError = error, this._hasCaughtError = !0;
    }
  }

  var ReactErrorUtils = {
    _caughtError: null,
    _hasCaughtError: !1,
    _rethrowError: null,
    _hasRethrowError: !1,
    invokeGuardedCallback: function invokeGuardedCallback(name, func, context, a, b, c, d, e, f) {
      _invokeGuardedCallback.apply(ReactErrorUtils, arguments);
    },
    invokeGuardedCallbackAndCatchFirstError: function invokeGuardedCallbackAndCatchFirstError(name, func, context, a, b, c, d, e, f) {
      ReactErrorUtils.invokeGuardedCallback.apply(this, arguments);

      if (ReactErrorUtils.hasCaughtError()) {
        var error = ReactErrorUtils.clearCaughtError();
        ReactErrorUtils._hasRethrowError || (ReactErrorUtils._hasRethrowError = !0, ReactErrorUtils._rethrowError = error);
      }
    },
    rethrowCaughtError: function rethrowCaughtError() {
      return _rethrowCaughtError.apply(ReactErrorUtils, arguments);
    },
    hasCaughtError: function hasCaughtError() {
      return ReactErrorUtils._hasCaughtError;
    },
    clearCaughtError: function clearCaughtError() {
      if (ReactErrorUtils._hasCaughtError) {
        var error = ReactErrorUtils._caughtError;
        ReactErrorUtils._caughtError = null;
        ReactErrorUtils._hasCaughtError = !1;
        return error;
      }

      invariant(!1, "clearCaughtError was called but no error was captured. This error is likely caused by a bug in React. Please file an issue.");
    }
  };

  function _rethrowCaughtError() {
    if (ReactErrorUtils._hasRethrowError) {
      var error = ReactErrorUtils._rethrowError;
      ReactErrorUtils._rethrowError = null;
      ReactErrorUtils._hasRethrowError = !1;
      throw error;
    }
  }

  var eventPluginOrder = null,
      namesToPlugins = {};

  function recomputePluginOrdering() {
    if (eventPluginOrder) for (var pluginName in namesToPlugins) {
      var pluginModule = namesToPlugins[pluginName],
          pluginIndex = eventPluginOrder.indexOf(pluginName);
      invariant(-1 < pluginIndex, "EventPluginRegistry: Cannot inject event plugins that do not exist in the plugin ordering, `%s`.", pluginName);

      if (!plugins[pluginIndex]) {
        invariant(pluginModule.extractEvents, "EventPluginRegistry: Event plugins must implement an `extractEvents` method, but `%s` does not.", pluginName);
        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;
          invariant(!eventNameDispatchConfigs.hasOwnProperty(eventName$jscomp$0), "EventPluginHub: More than one plugin attempted to publish the same event name, `%s`.", 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;

          invariant(JSCompiler_inline_result, "EventPluginRegistry: Failed to publish event `%s` for plugin `%s`.", eventName, pluginName);
        }
      }
    }
  }

  function publishRegistrationName(registrationName, pluginModule) {
    invariant(!registrationNameModules[registrationName], "EventPluginHub: More than one plugin attempted to publish the same registration name, `%s`.", registrationName);
    registrationNameModules[registrationName] = pluginModule;
  }

  var plugins = [],
      eventNameDispatchConfigs = {},
      registrationNameModules = {},
      getFiberCurrentPropsFromNode = null,
      getInstanceFromNode = null,
      getNodeFromInstance = null;

  function executeDispatch(event, simulated, listener, inst) {
    simulated = event.type || "unknown-event";
    event.currentTarget = getNodeFromInstance(inst);
    ReactErrorUtils.invokeGuardedCallbackAndCatchFirstError(simulated, listener, void 0, event);
    event.currentTarget = null;
  }

  function executeDirectDispatch(event) {
    var dispatchListener = event._dispatchListeners,
        dispatchInstance = event._dispatchInstances;
    invariant(!Array.isArray(dispatchListener), "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) {
    invariant(null != next, "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, !1, dispatchListeners[i], dispatchInstances[i]);
      } else dispatchListeners && executeDispatch(e, !1, dispatchListeners, dispatchInstances);
      e._dispatchListeners = null;
      e._dispatchInstances = null;
      e.isPersistent() || e.constructor.release(e);
    }
  }

  var injection = {
    injectEventPluginOrder: function injectEventPluginOrder(injectedEventPluginOrder) {
      invariant(!eventPluginOrder, "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];
          namesToPlugins.hasOwnProperty(pluginName) && namesToPlugins[pluginName] === pluginModule || (invariant(!namesToPlugins[pluginName], "EventPluginRegistry: Cannot inject two different event plugins using the same name, `%s`.", 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;
    invariant(!listener || "function" === typeof listener, "Expected `%s` listener to be a function, instead got a value of `%s` type.", registrationName, typeof listener);
    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));
      }
    }
  }

  var shouldBeReleasedProperties = "dispatchConfig _targetInst nativeEvent isDefaultPrevented isPropagationStopped _dispatchListeners _dispatchInstances".split(" ");

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

      for (Interface = 0; Interface < shouldBeReleasedProperties.length; Interface++) {
        this[shouldBeReleasedProperties[Interface]] = 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) {
    invariant(event instanceof this, "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;
    invariant(null != _ref, "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.error("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.error("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) {
    invariant(null != next, "accumulate(...): Accumulated items must be 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$1 = {
    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$1,
    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$1.startShouldSetResponder : isMoveish(topLevelType) ? eventTypes$1.moveShouldSetResponder : "topSelectionChange" === topLevelType ? eventTypes$1.selectionChangeShouldSetResponder : eventTypes$1.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$1.responderGrant, JSCompiler_temp, nativeEvent, nativeEventTarget), targetInst.touchHistory = ResponderTouchHistoryStore.touchHistory, forEachAccumulated(targetInst, accumulateDirectDispatchesSingle), depthA = !0 === executeDirectDispatch(targetInst), responderInst ? (tempA = ResponderSyntheticEvent.getPooled(eventTypes$1.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$1.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$1.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$1.responderStart : targetInst ? eventTypes$1.responderMove : depthA ? eventTypes$1.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$1.responderTerminate : topLevelType ? eventTypes$1.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$1 = ReactNativeViewConfigRegistry.customBubblingEventTypes,
      customDirectEventTypes$1 = ReactNativeViewConfigRegistry.customDirectEventTypes,
      ReactNativeBridgeEventPlugin = {
    eventTypes: ReactNativeViewConfigRegistry.eventTypes,
    extractEvents: function extractEvents(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
      if (null == targetInst) return null;
      var bubbleDispatchConfig = customBubblingEventTypes$1[topLevelType],
          directDispatchConfig = customDirectEventTypes$1[topLevelType];
      invariant(bubbleDispatchConfig || directDispatchConfig, 'Unsupported top level event type "%s" dispatched', topLevelType);
      topLevelType = SyntheticEvent.getPooled(bubbleDispatchConfig || directDispatchConfig, targetInst, nativeEvent, nativeEventTarget);
      if (bubbleDispatchConfig) forEachAccumulated(topLevelType, accumulateTwoPhaseDispatchesSingle);else if (directDispatchConfig) forEachAccumulated(topLevelType, accumulateDirectDispatchesSingle);else return null;
      return topLevelType;
    }
  };
  injection.injectEventPluginOrder(["ResponderEventPlugin", "ReactNativeBridgeEventPlugin"]);
  injection.injectEventPluginsByName({
    ResponderEventPlugin: ResponderEventPlugin,
    ReactNativeBridgeEventPlugin: ReactNativeBridgeEventPlugin
  });

  function getInstanceFromInstance(instanceHandle) {
    return instanceHandle;
  }

  var Injected$jscomp$inline_574 = {
    getClosestInstanceFromNode: getInstanceFromInstance,
    getInstanceFromNode: getInstanceFromInstance,
    getNodeFromInstance: function getNodeFromInstance(inst) {
      inst = inst.stateNode.canonical._nativeTag;
      invariant(inst, "All native instances should have a tag.");
      return inst;
    },
    getFiberCurrentPropsFromNode: function getFiberCurrentPropsFromNode(inst) {
      return inst.canonical.currentProps;
    }
  };
  getFiberCurrentPropsFromNode = Injected$jscomp$inline_574.getFiberCurrentPropsFromNode;
  getInstanceFromNode = Injected$jscomp$inline_574.getInstanceFromNode;
  getNodeFromInstance = Injected$jscomp$inline_574.getNodeFromInstance;
  ResponderEventPlugin.injection.injectGlobalResponderHandler({
    onChange: function onChange(from, to, blockNativeResponder) {
      null !== to ? UIManager.setJSResponder(to.stateNode.canonical._nativeTag, blockNativeResponder) : UIManager.clearJSResponder();
    }
  });
  var ReactCurrentOwner = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner,
      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_ASYNC_MODE_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.async_mode") : 60111,
      REACT_FORWARD_REF_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.forward_ref") : 60112,
      REACT_TIMEOUT_TYPE = hasSymbol ? (typeof Symbol === "function" ? Symbol.for : "@@for")("react.timeout") : 60113,
      MAYBE_ITERATOR_SYMBOL = "function" === typeof Symbol && (typeof Symbol === "function" ? Symbol.iterator : "@@iterator");

  function getIteratorFn(maybeIterable) {
    if (null === maybeIterable || "undefined" === typeof maybeIterable) return null;
    maybeIterable = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable["@@iterator"];
    return "function" === typeof maybeIterable ? maybeIterable : null;
  }

  function getComponentName(fiber) {
    var type = fiber.type;
    if ("function" === typeof type) return type.displayName || type.name;
    if ("string" === typeof type) return type;

    switch (type) {
      case REACT_ASYNC_MODE_TYPE:
        return "AsyncMode";

      case REACT_CONTEXT_TYPE:
        return "Context.Consumer";

      case REACT_FRAGMENT_TYPE:
        return "ReactFragment";

      case REACT_PORTAL_TYPE:
        return "ReactPortal";

      case REACT_PROFILER_TYPE:
        return "Profiler(" + fiber.pendingProps.id + ")";

      case REACT_PROVIDER_TYPE:
        return "Context.Provider";

      case REACT_STRICT_MODE_TYPE:
        return "StrictMode";

      case REACT_TIMEOUT_TYPE:
        return "Timeout";
    }

    if ("object" === typeof type && null !== type) switch (type.$$typeof) {
      case REACT_FORWARD_REF_TYPE:
        return fiber = type.render.displayName || type.render.name || "", "" !== fiber ? "ForwardRef(" + fiber + ")" : "ForwardRef";
    }
    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) {
    invariant(2 === isFiberMountedImpl(fiber), "Unable to find node on an unmounted component.");
  }

  function findCurrentFiberUsingSlowPath(fiber) {
    var alternate = fiber.alternate;
    if (!alternate) return alternate = isFiberMountedImpl(fiber), invariant(3 !== alternate, "Unable to find node on an unmounted component."), 1 === alternate ? null : fiber;

    for (var a = fiber, b = alternate;;) {
      var parentA = a.return,
          parentB = parentA ? parentA.alternate : null;
      if (!parentA || !parentB) break;

      if (parentA.child === parentB.child) {
        for (var child = parentA.child; child;) {
          if (child === a) return assertIsMounted(parentA), fiber;
          if (child === b) return assertIsMounted(parentA), alternate;
          child = child.sibling;
        }

        invariant(!1, "Unable to find node on an unmounted component.");
      }

      if (a.return !== b.return) a = parentA, b = parentB;else {
        child = !1;

        for (var _child = parentA.child; _child;) {
          if (_child === a) {
            child = !0;
            a = parentA;
            b = parentB;
            break;
          }

          if (_child === b) {
            child = !0;
            b = parentA;
            a = parentB;
            break;
          }

          _child = _child.sibling;
        }

        if (!child) {
          for (_child = parentB.child; _child;) {
            if (_child === a) {
              child = !0;
              a = parentB;
              b = parentA;
              break;
            }

            if (_child === b) {
              child = !0;
              b = parentB;
              a = parentA;
              break;
            }

            _child = _child.sibling;
          }

          invariant(child, "Child was not found in either parent set. This indicates a bug in React related to the return pointer. Please file an issue.");
        }
      }
      invariant(a.alternate === b, "Return fibers should always be each others' alternates. This error is likely caused by a bug in React. Please file an issue.");
    }

    invariant(3 === a.tag, "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 findCurrentHostFiberWithNoPortals(parent) {
    parent = findCurrentFiberUsingSlowPath(parent);
    if (!parent) return null;

    for (var node = parent;;) {
      if (5 === node.tag || 6 === node.tag) return node;
      if (node.child && 4 !== node.tag) 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(context, callback) {
    return function () {
      if (callback) {
        if ("boolean" === typeof context.__isMounted) {
          if (!context.__isMounted) return;
        } else if ("function" === typeof context.isMounted && !context.isMounted()) return;

        return callback.apply(context, arguments);
      }
    };
  }

  var emptyObject$1 = {},
      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, flattenStyle(prevProp), nextProp, validAttributes) : diffProperties(updatePayload, prevProp, flattenStyle(nextProp), validAttributes);
  }

  function addNestedProperty(updatePayload, nextProp, validAttributes) {
    if (!nextProp) return updatePayload;
    if (!Array.isArray(nextProp)) return diffProperties(updatePayload, emptyObject$1, 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$1, 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 || 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 || 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 now$1 = "object" === typeof performance && "function" === typeof performance.now ? function () {
    return performance.now();
  } : function () {
    return Date.now();
  },
      scheduledCallback = null,
      frameDeadline = 0,
      frameDeadlineObject = {
    timeRemaining: function timeRemaining() {
      return frameDeadline - now$1();
    },
    didTimeout: !1
  };

  function setTimeoutCallback() {
    frameDeadline = now$1() + 5;
    var callback = scheduledCallback;
    scheduledCallback = null;
    null !== callback && callback(frameDeadlineObject);
  }

  var restoreTarget = null,
      restoreQueue = null;

  function restoreStateOfTarget(target) {
    if (target = getInstanceFromNode(target)) {
      invariant(null, "Fiber needs to be injected to handle a fiber target for controlled events. This error is likely caused by a bug in React. Please file an issue.");
      var props = getFiberCurrentPropsFromNode(target.stateNode);
      null.restoreControlledState(target.stateNode, target.type, props);
    }
  }

  function _batchedUpdates(fn, bookkeeping) {
    return fn(bookkeeping);
  }

  function _flushInteractiveUpdates() {}

  var isBatching = !1;

  function batchedUpdates(fn, bookkeeping) {
    if (isBatching) return fn(bookkeeping);
    isBatching = !0;

    try {
      return _batchedUpdates(fn, bookkeeping);
    } finally {
      if (isBatching = !1, null !== restoreTarget || null !== restoreQueue) if (_flushInteractiveUpdates(), restoreTarget && (bookkeeping = restoreTarget, fn = restoreQueue, restoreQueue = restoreTarget = null, restoreStateOfTarget(bookkeeping), fn)) for (bookkeeping = 0; bookkeeping < fn.length; bookkeeping++) {
        restoreStateOfTarget(fn[bookkeeping]);
      }
    }
  }

  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;
      events && (forEachAccumulated(events, executeDispatchesAndReleaseTopLevel), invariant(!eventQueue, "processEventQueue(): Additional events were enqueued while processing an event queue. Support for this has not yet been implemented."), ReactErrorUtils.rethrowCaughtError());
    });
  }

  function shim$1() {
    invariant(!1, "The current renderer does not support hyration. This error is likely caused by a bug in React. Please file an issue.");
  }

  var nextReactTag = 2;
  FabricUIManager.registerEventHandler && FabricUIManager.registerEventHandler(dispatchEvent);

  var ReactFabricHostComponent = function () {
    function ReactFabricHostComponent(tag, viewConfig, props) {
      if (!(this instanceof ReactFabricHostComponent)) throw new TypeError("Cannot call a class as a function");
      this._nativeTag = tag;
      this.viewConfig = viewConfig;
      this.currentProps = props;
    }

    ReactFabricHostComponent.prototype.blur = function () {
      TextInputState.blurTextInput(this._nativeTag);
    };

    ReactFabricHostComponent.prototype.focus = function () {
      TextInputState.focusTextInput(this._nativeTag);
    };

    ReactFabricHostComponent.prototype.measure = function (callback) {
      UIManager.measure(this._nativeTag, mountSafeCallback(this, callback));
    };

    ReactFabricHostComponent.prototype.measureInWindow = function (callback) {
      UIManager.measureInWindow(this._nativeTag, mountSafeCallback(this, callback));
    };

    ReactFabricHostComponent.prototype.measureLayout = function (relativeToNativeNode, onSuccess, onFail) {
      UIManager.measureLayout(this._nativeTag, relativeToNativeNode, mountSafeCallback(this, onFail), mountSafeCallback(this, onSuccess));
    };

    ReactFabricHostComponent.prototype.setNativeProps = function (nativeProps) {
      nativeProps = diffProperties(null, emptyObject$1, nativeProps, this.viewConfig.validAttributes);
      null != nativeProps && UIManager.updateView(this._nativeTag, this.viewConfig.uiViewClassName, nativeProps);
    };

    return ReactFabricHostComponent;
  }();

  function createTextInstance(text, rootContainerInstance, hostContext, internalInstanceHandle) {
    invariant(hostContext.isInAParentText, "Text strings must be rendered within a <Text> component.");
    hostContext = nextReactTag;
    nextReactTag += 2;
    return {
      node: FabricUIManager.createNode(hostContext, "RCTRawText", rootContainerInstance, {
        text: text
      }, internalInstanceHandle)
    };
  }

  function getStackAddendumByWorkInProgressFiber(workInProgress) {
    var info = "";

    do {
      a: switch (workInProgress.tag) {
        case 0:
        case 1:
        case 2:
        case 5:
          var owner = workInProgress._debugOwner,
              source = workInProgress._debugSource;
          var JSCompiler_inline_result = getComponentName(workInProgress);
          var ownerName = null;
          owner && (ownerName = getComponentName(owner));
          owner = source;
          JSCompiler_inline_result = "\n    in " + (JSCompiler_inline_result || "Unknown") + (owner ? " (at " + owner.fileName.replace(/^.*[\\\/]/, "") + ":" + owner.lineNumber + ")" : ownerName ? " (created by " + ownerName + ")" : "");
          break a;

        default:
          JSCompiler_inline_result = "";
      }

      info += JSCompiler_inline_result;
      workInProgress = workInProgress.return;
    } while (workInProgress);

    return info;
  }

  new Set();
  var valueStack = [],
      index = -1;

  function createCursor(defaultValue) {
    return {
      current: defaultValue
    };
  }

  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 contextStackCursor = createCursor(emptyObject),
      didPerformWorkStackCursor = createCursor(!1),
      previousContext = emptyObject;

  function getUnmaskedContext(workInProgress) {
    return isContextProvider(workInProgress) ? previousContext : contextStackCursor.current;
  }

  function getMaskedContext(workInProgress, unmaskedContext) {
    var contextTypes = workInProgress.type.contextTypes;
    if (!contextTypes) return emptyObject;
    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(fiber) {
    return 2 === fiber.tag && null != fiber.type.childContextTypes;
  }

  function popContextProvider(fiber) {
    isContextProvider(fiber) && (pop(didPerformWorkStackCursor, fiber), pop(contextStackCursor, fiber));
  }

  function popTopLevelContextObject(fiber) {
    pop(didPerformWorkStackCursor, fiber);
    pop(contextStackCursor, fiber);
  }

  function pushTopLevelContextObject(fiber, context, didChange) {
    invariant(contextStackCursor.current === emptyObject, "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, parentContext) {
    var instance = fiber.stateNode,
        childContextTypes = fiber.type.childContextTypes;
    if ("function" !== typeof instance.getChildContext) return parentContext;
    instance = instance.getChildContext();

    for (var contextKey in instance) {
      invariant(contextKey in childContextTypes, '%s.getChildContext(): key "%s" is not defined in childContextTypes.', getComponentName(fiber) || "Unknown", contextKey);
    }

    return _extends({}, parentContext, instance);
  }

  function pushContextProvider(workInProgress) {
    if (!isContextProvider(workInProgress)) return !1;
    var instance = workInProgress.stateNode;
    instance = instance && instance.__reactInternalMemoizedMergedChildContext || emptyObject;
    previousContext = contextStackCursor.current;
    push(contextStackCursor, instance, workInProgress);
    push(didPerformWorkStackCursor, didPerformWorkStackCursor.current, workInProgress);
    return !0;
  }

  function invalidateContextProvider(workInProgress, didChange) {
    var instance = workInProgress.stateNode;
    invariant(instance, "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, previousContext);
      instance.__reactInternalMemoizedMergedChildContext = mergedContext;
      pop(didPerformWorkStackCursor, workInProgress);
      pop(contextStackCursor, workInProgress);
      push(contextStackCursor, mergedContext, workInProgress);
    } else pop(didPerformWorkStackCursor, workInProgress);

    push(didPerformWorkStackCursor, didChange, workInProgress);
  }

  function FiberNode(tag, pendingProps, key, mode) {
    this.tag = tag;
    this.key = key;
    this.sibling = this.child = this.return = this.stateNode = this.type = null;
    this.index = 0;
    this.ref = null;
    this.pendingProps = pendingProps;
    this.memoizedState = this.updateQueue = this.memoizedProps = null;
    this.mode = mode;
    this.effectTag = 0;
    this.lastEffect = this.firstEffect = this.nextEffect = null;
    this.expirationTime = 0;
    this.alternate = null;
  }

  function createWorkInProgress(current, pendingProps, expirationTime) {
    var workInProgress = current.alternate;
    null === workInProgress ? (workInProgress = new FiberNode(current.tag, pendingProps, current.key, current.mode), 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.expirationTime = expirationTime;
    workInProgress.child = current.child;
    workInProgress.memoizedProps = current.memoizedProps;
    workInProgress.memoizedState = current.memoizedState;
    workInProgress.updateQueue = current.updateQueue;
    workInProgress.sibling = current.sibling;
    workInProgress.index = current.index;
    workInProgress.ref = current.ref;
    return workInProgress;
  }

  function createFiberFromElement(element, mode, expirationTime) {
    var type = element.type,
        key = element.key;
    element = element.props;
    if ("function" === typeof type) var fiberTag = type.prototype && type.prototype.isReactComponent ? 2 : 0;else if ("string" === typeof type) fiberTag = 5;else switch (type) {
      case REACT_FRAGMENT_TYPE:
        return createFiberFromFragment(element.children, mode, expirationTime, key);

      case REACT_ASYNC_MODE_TYPE:
        fiberTag = 11;
        mode |= 3;
        break;

      case REACT_STRICT_MODE_TYPE:
        fiberTag = 11;
        mode |= 2;
        break;

      case REACT_PROFILER_TYPE:
        return type = new FiberNode(15, element, key, mode | 4), type.type = REACT_PROFILER_TYPE, type.expirationTime = expirationTime, type;

      case REACT_TIMEOUT_TYPE:
        fiberTag = 16;
        mode |= 2;
        break;

      default:
        a: {
          switch ("object" === typeof type && null !== type ? type.$$typeof : null) {
            case REACT_PROVIDER_TYPE:
              fiberTag = 13;
              break a;

            case REACT_CONTEXT_TYPE:
              fiberTag = 12;
              break a;

            case REACT_FORWARD_REF_TYPE:
              fiberTag = 14;
              break a;

            default:
              invariant(!1, "Element type is invalid: expected a string (for built-in components) or a class/function (for composite components) but got: %s.%s", null == type ? type : typeof type, "");
          }

          fiberTag = void 0;
        }

    }
    mode = new FiberNode(fiberTag, element, key, mode);
    mode.type = type;
    mode.expirationTime = expirationTime;
    return mode;
  }

  function createFiberFromFragment(elements, mode, expirationTime, key) {
    elements = new FiberNode(10, elements, key, mode);
    elements.expirationTime = expirationTime;
    return elements;
  }

  function createFiberFromText(content, mode, expirationTime) {
    content = new FiberNode(6, content, null, mode);
    content.expirationTime = expirationTime;
    return content;
  }

  function createFiberFromPortal(portal, mode, expirationTime) {
    mode = new FiberNode(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 createFiberRoot(containerInfo, isAsync, hydrate) {
    isAsync = new FiberNode(3, null, null, isAsync ? 3 : 0);
    containerInfo = {
      current: isAsync,
      containerInfo: containerInfo,
      pendingChildren: null,
      earliestPendingTime: 0,
      latestPendingTime: 0,
      earliestSuspendedTime: 0,
      latestSuspendedTime: 0,
      latestPingedTime: 0,
      didError: !1,
      pendingCommitExpirationTime: 0,
      finishedWork: null,
      context: null,
      pendingContext: null,
      hydrate: hydrate,
      nextExpirationTimeToWorkOn: 0,
      expirationTime: 0,
      firstBatch: null,
      nextScheduledRoot: null
    };
    return isAsync.stateNode = containerInfo;
  }

  var onCommitFiberRoot = null,
      onCommitFiberUnmount = null;

  function catchErrors(fn) {
    return function (arg) {
      try {
        return fn(arg);
      } catch (err) {}
    };
  }

  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 = catchErrors(function (root) {
        return hook.onCommitFiberRoot(rendererID, root);
      });
      onCommitFiberUnmount = catchErrors(function (fiber) {
        return hook.onCommitFiberUnmount(rendererID, fiber);
      });
    } catch (err) {}

    return !0;
  }

  function onCommitRoot(root) {
    "function" === typeof onCommitFiberRoot && onCommitFiberRoot(root);
  }

  function onCommitUnmount(fiber) {
    "function" === typeof onCommitFiberUnmount && onCommitFiberUnmount(fiber);
  }

  function markPendingPriorityLevel(root, expirationTime) {
    root.didError = !1;
    var earliestPendingTime = root.earliestPendingTime;
    0 === earliestPendingTime ? root.earliestPendingTime = root.latestPendingTime = expirationTime : earliestPendingTime > expirationTime ? root.earliestPendingTime = expirationTime : root.latestPendingTime < expirationTime && (root.latestPendingTime = expirationTime);
    findNextPendingPriorityLevel(root);
  }

  function findNextPendingPriorityLevel(root) {
    var earliestSuspendedTime = root.earliestSuspendedTime,
        earliestPendingTime = root.earliestPendingTime;
    if (0 === earliestSuspendedTime) var nextExpirationTimeToWorkOn = earliestSuspendedTime = earliestPendingTime;else 0 !== earliestPendingTime ? (nextExpirationTimeToWorkOn = earliestPendingTime, earliestSuspendedTime = earliestSuspendedTime < earliestPendingTime ? earliestSuspendedTime : earliestPendingTime) : nextExpirationTimeToWorkOn = earliestSuspendedTime = root.latestPingedTime;
    root.didError && (earliestSuspendedTime = 1);
    root.nextExpirationTimeToWorkOn = nextExpirationTimeToWorkOn;
    root.expirationTime = earliestSuspendedTime;
  }

  var hasForceUpdate = !1;

  function createUpdateQueue(baseState) {
    return {
      expirationTime: 0,
      baseState: baseState,
      firstUpdate: null,
      lastUpdate: null,
      firstCapturedUpdate: null,
      lastCapturedUpdate: null,
      firstEffect: null,
      lastEffect: null,
      firstCapturedEffect: null,
      lastCapturedEffect: null
    };
  }

  function cloneUpdateQueue(currentQueue) {
    return {
      expirationTime: currentQueue.expirationTime,
      baseState: currentQueue.baseState,
      firstUpdate: currentQueue.firstUpdate,
      lastUpdate: currentQueue.lastUpdate,
      firstCapturedUpdate: null,
      lastCapturedUpdate: null,
      firstEffect: null,
      lastEffect: null,
      firstCapturedEffect: null,
      lastCapturedEffect: null
    };
  }

  function createUpdate(expirationTime) {
    return {
      expirationTime: expirationTime,
      tag: 0,
      payload: null,
      callback: null,
      next: null,
      nextEffect: null
    };
  }

  function appendUpdateToQueue(queue, update, expirationTime) {
    null === queue.lastUpdate ? queue.firstUpdate = queue.lastUpdate = update : (queue.lastUpdate.next = update, queue.lastUpdate = update);
    if (0 === queue.expirationTime || queue.expirationTime > expirationTime) queue.expirationTime = expirationTime;
  }

  function enqueueUpdate(fiber, update, expirationTime) {
    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, expirationTime) : null === queue1.lastUpdate || null === queue2.lastUpdate ? (appendUpdateToQueue(queue1, update, expirationTime), appendUpdateToQueue(queue2, update, expirationTime)) : (appendUpdateToQueue(queue1, update, expirationTime), queue2.lastUpdate = update);
  }

  function enqueueCapturedUpdate(workInProgress, update, renderExpirationTime) {
    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);
    if (0 === workInProgressQueue.expirationTime || workInProgressQueue.expirationTime > renderExpirationTime) workInProgressQueue.expirationTime = renderExpirationTime;
  }

  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 & -1025 | 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;

    if (!(0 === queue.expirationTime || queue.expirationTime > renderExpirationTime)) {
      queue = ensureWorkInProgressQueueIsAClone(workInProgress, queue);

      for (var newBaseState = queue.baseState, newFirstUpdate = null, newExpirationTime = 0, update = queue.firstUpdate, resultState = newBaseState; null !== update;) {
        var updateExpirationTime = update.expirationTime;

        if (updateExpirationTime > renderExpirationTime) {
          if (null === newFirstUpdate && (newFirstUpdate = update, newBaseState = resultState), 0 === newExpirationTime || newExpirationTime > updateExpirationTime) newExpirationTime = updateExpirationTime;
        } else 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;

        if (_updateExpirationTime > renderExpirationTime) {
          if (null === updateExpirationTime && (updateExpirationTime = update, null === newFirstUpdate && (newBaseState = resultState)), 0 === newExpirationTime || newExpirationTime > _updateExpirationTime) newExpirationTime = _updateExpirationTime;
        } else 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;
      queue.expirationTime = newExpirationTime;
      workInProgress.memoizedState = resultState;
    }
  }

  function callCallback(callback, context) {
    invariant("function" === typeof callback, "Invalid argument passed as callback. Expected a function. Instead received: %s", callback);
    callback.call(context);
  }

  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);
    finishedWork = finishedQueue.firstEffect;

    for (finishedQueue.firstEffect = finishedQueue.lastEffect = null; null !== finishedWork;) {
      var _callback3 = finishedWork.callback;
      null !== _callback3 && (finishedWork.callback = null, callCallback(_callback3, instance));
      finishedWork = finishedWork.nextEffect;
    }

    finishedWork = finishedQueue.firstCapturedEffect;

    for (finishedQueue.firstCapturedEffect = finishedQueue.lastCapturedEffect = null; null !== finishedWork;) {
      finishedQueue = finishedWork.callback, null !== finishedQueue && (finishedWork.callback = null, callCallback(finishedQueue, instance)), finishedWork = finishedWork.nextEffect;
    }
  }

  function createCapturedValue(value, source) {
    return {
      value: value,
      source: source,
      stack: getStackAddendumByWorkInProgressFiber(source)
    };
  }

  var providerCursor = createCursor(null),
      valueCursor = createCursor(null),
      changedBitsCursor = createCursor(0);

  function pushProvider(providerFiber) {
    var context = providerFiber.type._context;
    push(changedBitsCursor, context._changedBits2, providerFiber);
    push(valueCursor, context._currentValue2, providerFiber);
    push(providerCursor, providerFiber, providerFiber);
    context._currentValue2 = providerFiber.pendingProps.value;
    context._changedBits2 = providerFiber.stateNode;
  }

  function popProvider(providerFiber) {
    var changedBits = changedBitsCursor.current,
        currentValue = valueCursor.current;
    pop(providerCursor, providerFiber);
    pop(valueCursor, providerFiber);
    pop(changedBitsCursor, providerFiber);
    providerFiber = providerFiber.type._context;
    providerFiber._currentValue2 = currentValue;
    providerFiber._changedBits2 = changedBits;
  }

  var NO_CONTEXT = {},
      contextStackCursor$1 = createCursor(NO_CONTEXT),
      contextFiberStackCursor = createCursor(NO_CONTEXT),
      rootInstanceStackCursor = createCursor(NO_CONTEXT);

  function requiredContext(c) {
    invariant(c !== NO_CONTEXT, "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 popHostContext(fiber) {
    contextFiberStackCursor.current === fiber && (pop(contextStackCursor$1, fiber), pop(contextFiberStackCursor, fiber));
  }

  var hasOwnProperty = Object.prototype.hasOwnProperty;

  function is(x, y) {
    return x === y ? 0 !== x || 0 !== y || 1 / x === 1 / y : x !== x && y !== y;
  }

  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 applyDerivedStateFromProps(workInProgress, getDerivedStateFromProps, nextProps) {
    var prevState = workInProgress.memoizedState;
    getDerivedStateFromProps = getDerivedStateFromProps(nextProps, prevState);
    prevState = null === getDerivedStateFromProps || void 0 === getDerivedStateFromProps ? prevState : _extends({}, prevState, getDerivedStateFromProps);
    workInProgress.memoizedState = prevState;
    workInProgress = workInProgress.updateQueue;
    null !== workInProgress && 0 === workInProgress.expirationTime && (workInProgress.baseState = prevState);
  }

  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 = recalculateCurrentTime();
      currentTime = computeExpirationForFiber(currentTime, inst);
      var update = createUpdate(currentTime);
      update.payload = payload;
      void 0 !== callback && null !== callback && (update.callback = callback);
      enqueueUpdate(inst, update, currentTime);
      scheduleWork(inst, currentTime);
    },
    enqueueReplaceState: function enqueueReplaceState(inst, payload, callback) {
      inst = inst._reactInternalFiber;
      var currentTime = recalculateCurrentTime();
      currentTime = computeExpirationForFiber(currentTime, inst);
      var update = createUpdate(currentTime);
      update.tag = 1;
      update.payload = payload;
      void 0 !== callback && null !== callback && (update.callback = callback);
      enqueueUpdate(inst, update, currentTime);
      scheduleWork(inst, currentTime);
    },
    enqueueForceUpdate: function enqueueForceUpdate(inst, callback) {
      inst = inst._reactInternalFiber;
      var currentTime = recalculateCurrentTime();
      currentTime = computeExpirationForFiber(currentTime, inst);
      var update = createUpdate(currentTime);
      update.tag = 2;
      void 0 !== callback && null !== callback && (update.callback = callback);
      enqueueUpdate(inst, update, currentTime);
      scheduleWork(inst, currentTime);
    }
  };

  function checkShouldComponentUpdate(workInProgress, oldProps, newProps, oldState, newState, newContext) {
    var instance = workInProgress.stateNode;
    workInProgress = workInProgress.type;
    return "function" === typeof instance.shouldComponentUpdate ? instance.shouldComponentUpdate(newProps, newState, newContext) : workInProgress.prototype && workInProgress.prototype.isPureReactComponent ? !shallowEqual(oldProps, newProps) || !shallowEqual(oldState, newState) : !0;
  }

  function callComponentWillReceiveProps(workInProgress, instance, newProps, newContext) {
    workInProgress = instance.state;
    "function" === typeof instance.componentWillReceiveProps && instance.componentWillReceiveProps(newProps, newContext);
    "function" === typeof instance.UNSAFE_componentWillReceiveProps && instance.UNSAFE_componentWillReceiveProps(newProps, newContext);
    instance.state !== workInProgress && classComponentUpdater.enqueueReplaceState(instance, instance.state, null);
  }

  function mountClassInstance(workInProgress, renderExpirationTime) {
    var ctor = workInProgress.type,
        instance = workInProgress.stateNode,
        props = workInProgress.pendingProps,
        unmaskedContext = getUnmaskedContext(workInProgress);
    instance.props = props;
    instance.state = workInProgress.memoizedState;
    instance.refs = emptyObject;
    instance.context = getMaskedContext(workInProgress, unmaskedContext);
    unmaskedContext = workInProgress.updateQueue;
    null !== unmaskedContext && (processUpdateQueue(workInProgress, unmaskedContext, props, instance, renderExpirationTime), instance.state = workInProgress.memoizedState);
    unmaskedContext = workInProgress.type.getDerivedStateFromProps;
    "function" === typeof unmaskedContext && (applyDerivedStateFromProps(workInProgress, unmaskedContext, props), 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), unmaskedContext = workInProgress.updateQueue, null !== unmaskedContext && (processUpdateQueue(workInProgress, unmaskedContext, props, instance, renderExpirationTime), instance.state = workInProgress.memoizedState));
    "function" === typeof instance.componentDidMount && (workInProgress.effectTag |= 4);
  }

  var isArray$1 = Array.isArray;

  function coerceRef(returnFiber, current, element) {
    returnFiber = element.ref;

    if (null !== returnFiber && "function" !== typeof returnFiber && "object" !== typeof returnFiber) {
      if (element._owner) {
        element = element._owner;
        var inst = void 0;
        element && (invariant(2 === element.tag, "Stateless function components cannot have refs."), inst = element.stateNode);
        invariant(inst, "Missing owner for string ref %s. This error is likely caused by a bug in React. Please file an issue.", returnFiber);
        var stringRef = "" + returnFiber;
        if (null !== current && null !== current.ref && "function" === typeof current.ref && current.ref._stringRef === stringRef) return current.ref;

        current = function current(value) {
          var refs = inst.refs === emptyObject ? inst.refs = {} : inst.refs;
          null === value ? delete refs[stringRef] : refs[stringRef] = value;
        };

        current._stringRef = stringRef;
        return current;
      }

      invariant("string" === typeof returnFiber, "Expected ref to be a function or a string.");
      invariant(element._owner, "Element ref was specified as a string (%s) but no owner was set. This could happen for one of the following reasons:\n1. You may be adding a ref to a functional 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.", returnFiber);
    }

    return returnFiber;
  }

  function throwOnInvalidObjectType(returnFiber, newChild) {
    "textarea" !== returnFiber.type && invariant(!1, "Objects are not valid as a React child (found: %s).%s", "[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, textContent, expirationTime) {
      if (null === current || 6 !== current.tag) return current = createFiberFromText(textContent, returnFiber.mode, expirationTime), current.return = returnFiber, current;
      current = useFiber(current, textContent, expirationTime);
      current.return = returnFiber;
      return current;
    }

    function updateElement(returnFiber, current, element, expirationTime) {
      if (null !== current && current.type === element.type) return expirationTime = useFiber(current, element.props, expirationTime), expirationTime.ref = coerceRef(returnFiber, current, element), expirationTime.return = returnFiber, expirationTime;
      expirationTime = createFiberFromElement(element, returnFiber.mode, expirationTime);
      expirationTime.ref = coerceRef(returnFiber, current, element);
      expirationTime.return = returnFiber;
      return expirationTime;
    }

    function updatePortal(returnFiber, current, portal, expirationTime) {
      if (null === current || 4 !== current.tag || current.stateNode.containerInfo !== portal.containerInfo || current.stateNode.implementation !== portal.implementation) return current = createFiberFromPortal(portal, returnFiber.mode, expirationTime), current.return = returnFiber, current;
      current = useFiber(current, portal.children || [], expirationTime);
      current.return = returnFiber;
      return current;
    }

    function updateFragment(returnFiber, current, fragment, expirationTime, key) {
      if (null === current || 10 !== current.tag) return current = createFiberFromFragment(fragment, returnFiber.mode, expirationTime, key), current.return = returnFiber, current;
      current = useFiber(current, fragment, expirationTime);
      current.return = returnFiber;
      return current;
    }

    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 = createFiberFromElement(newChild, 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$1(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$1(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$1(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++) {
          if (oldFiber = createChild(returnFiber, newChildren[newIdx], expirationTime)) 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++) {
        if (nextOldFiber = updateFromMap(oldFiber, returnFiber, newIdx, newChildren[newIdx], expirationTime)) 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);
      invariant("function" === typeof iteratorFn, "An object is not an iterable. This error is likely caused by a bug in React. Please file an issue.");
      newChildrenIterable = iteratorFn.call(newChildrenIterable);
      invariant(null != newChildrenIterable, "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) {
          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 (10 === isUnkeyedTopLevelFragment.tag ? newChild.type === REACT_FRAGMENT_TYPE : isUnkeyedTopLevelFragment.type === 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;
                } else {
                  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 = createFiberFromElement(newChild, 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;
                } else {
                  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$1(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 2:
        case 1:
          expirationTime = returnFiber.type, invariant(!1, "%s(...): Nothing was returned from render. This usually means a return statement is missing. Or, to render nothing, return null.", expirationTime.displayName || expirationTime.name || "Component");
      }
      return deleteRemainingChildren(returnFiber, currentFirstChild);
    };
  }

  var reconcileChildFibers = ChildReconciler(!0),
      mountChildFibers = ChildReconciler(!1),
      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;

      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 = new FiberNode(5, null, null, 0);
          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;
    }
  }

  function reconcileChildren(current, workInProgress, nextChildren) {
    reconcileChildrenAtExpirationTime(current, workInProgress, nextChildren, workInProgress.expirationTime);
  }

  function reconcileChildrenAtExpirationTime(current, workInProgress, nextChildren, renderExpirationTime) {
    workInProgress.child = null === current ? mountChildFibers(workInProgress, null, nextChildren, renderExpirationTime) : reconcileChildFibers(workInProgress, current.child, nextChildren, renderExpirationTime);
  }

  function markRef(current, workInProgress) {
    var ref = workInProgress.ref;
    if (null === current && null !== ref || null !== current && current.ref !== ref) workInProgress.effectTag |= 128;
  }

  function finishClassComponent(current, workInProgress, shouldUpdate, hasContext, renderExpirationTime) {
    markRef(current, workInProgress);
    var didCaptureError = 0 !== (workInProgress.effectTag & 64);
    if (!shouldUpdate && !didCaptureError) return hasContext && invalidateContextProvider(workInProgress, !1), bailoutOnAlreadyFinishedWork(current, workInProgress);
    shouldUpdate = workInProgress.stateNode;
    ReactCurrentOwner.current = workInProgress;
    var nextChildren = didCaptureError ? null : shouldUpdate.render();
    workInProgress.effectTag |= 1;
    didCaptureError && (reconcileChildrenAtExpirationTime(current, workInProgress, null, renderExpirationTime), workInProgress.child = null);
    reconcileChildrenAtExpirationTime(current, workInProgress, nextChildren, renderExpirationTime);
    workInProgress.memoizedState = shouldUpdate.state;
    workInProgress.memoizedProps = shouldUpdate.props;
    hasContext && invalidateContextProvider(workInProgress, !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);
  }

  function propagateContextChange(workInProgress, context, changedBits, renderExpirationTime) {
    var fiber = workInProgress.child;
    null !== fiber && (fiber.return = workInProgress);

    for (; null !== fiber;) {
      switch (fiber.tag) {
        case 12:
          var nextFiber = fiber.stateNode | 0;

          if (fiber.type === context && 0 !== (nextFiber & changedBits)) {
            for (nextFiber = fiber; null !== nextFiber;) {
              var alternate = nextFiber.alternate;
              if (0 === nextFiber.expirationTime || nextFiber.expirationTime > renderExpirationTime) nextFiber.expirationTime = renderExpirationTime, null !== alternate && (0 === alternate.expirationTime || alternate.expirationTime > renderExpirationTime) && (alternate.expirationTime = renderExpirationTime);else if (null !== alternate && (0 === alternate.expirationTime || alternate.expirationTime > renderExpirationTime)) alternate.expirationTime = renderExpirationTime;else break;
              nextFiber = nextFiber.return;
            }

            nextFiber = null;
          } else nextFiber = fiber.child;

          break;

        case 13:
          nextFiber = fiber.type === workInProgress.type ? null : fiber.child;
          break;

        default:
          nextFiber = fiber.child;
      }

      if (null !== nextFiber) nextFiber.return = fiber;else for (nextFiber = fiber; null !== nextFiber;) {
        if (nextFiber === workInProgress) {
          nextFiber = null;
          break;
        }

        fiber = nextFiber.sibling;

        if (null !== fiber) {
          fiber.return = nextFiber.return;
          nextFiber = fiber;
          break;
        }

        nextFiber = nextFiber.return;
      }
      fiber = nextFiber;
    }
  }

  function updateContextProvider(current, workInProgress, renderExpirationTime) {
    var context = workInProgress.type._context,
        newProps = workInProgress.pendingProps,
        oldProps = workInProgress.memoizedProps,
        canBailOnProps = !0;
    if (didPerformWorkStackCursor.current) canBailOnProps = !1;else if (oldProps === newProps) return workInProgress.stateNode = 0, pushProvider(workInProgress), bailoutOnAlreadyFinishedWork(current, workInProgress);
    var newValue = newProps.value;
    workInProgress.memoizedProps = newProps;
    if (null === oldProps) newValue = 1073741823;else if (oldProps.value === newProps.value) {
      if (oldProps.children === newProps.children && canBailOnProps) return workInProgress.stateNode = 0, pushProvider(workInProgress), bailoutOnAlreadyFinishedWork(current, workInProgress);
      newValue = 0;
    } else {
      var oldValue = oldProps.value;

      if (oldValue === newValue && (0 !== oldValue || 1 / oldValue === 1 / newValue) || oldValue !== oldValue && newValue !== newValue) {
        if (oldProps.children === newProps.children && canBailOnProps) return workInProgress.stateNode = 0, pushProvider(workInProgress), bailoutOnAlreadyFinishedWork(current, workInProgress);
        newValue = 0;
      } else if (newValue = "function" === typeof context._calculateChangedBits ? context._calculateChangedBits(oldValue, newValue) : 1073741823, newValue |= 0, 0 === newValue) {
        if (oldProps.children === newProps.children && canBailOnProps) return workInProgress.stateNode = 0, pushProvider(workInProgress), bailoutOnAlreadyFinishedWork(current, workInProgress);
      } else propagateContextChange(workInProgress, context, newValue, renderExpirationTime);
    }
    workInProgress.stateNode = newValue;
    pushProvider(workInProgress);
    reconcileChildren(current, workInProgress, newProps.children);
    return workInProgress.child;
  }

  function bailoutOnAlreadyFinishedWork(current, workInProgress) {
    invariant(null === current || workInProgress.child === current.child, "Resuming work not yet implemented.");

    if (null !== workInProgress.child) {
      current = workInProgress.child;
      var newChild = createWorkInProgress(current, current.pendingProps, current.expirationTime);
      workInProgress.child = newChild;

      for (newChild.return = workInProgress; null !== current.sibling;) {
        current = current.sibling, newChild = newChild.sibling = createWorkInProgress(current, current.pendingProps, current.expirationTime), newChild.return = workInProgress;
      }

      newChild.sibling = null;
    }

    return workInProgress.child;
  }

  function beginWork(current, workInProgress, renderExpirationTime) {
    if (0 === workInProgress.expirationTime || workInProgress.expirationTime > renderExpirationTime) {
      switch (workInProgress.tag) {
        case 3:
          pushHostRootContext(workInProgress);
          break;

        case 2:
          pushContextProvider(workInProgress);
          break;

        case 4:
          pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo);
          break;

        case 13:
          pushProvider(workInProgress);
      }

      return null;
    }

    switch (workInProgress.tag) {
      case 0:
        invariant(null === current, "An indeterminate component should never have mounted. This error is likely caused by a bug in React. Please file an issue.");
        var fn = workInProgress.type,
            props = workInProgress.pendingProps,
            unmaskedContext = getUnmaskedContext(workInProgress);
        unmaskedContext = getMaskedContext(workInProgress, unmaskedContext);
        fn = fn(props, unmaskedContext);
        workInProgress.effectTag |= 1;
        "object" === typeof fn && null !== fn && "function" === typeof fn.render && void 0 === fn.$$typeof ? (unmaskedContext = workInProgress.type, workInProgress.tag = 2, workInProgress.memoizedState = null !== fn.state && void 0 !== fn.state ? fn.state : null, unmaskedContext = unmaskedContext.getDerivedStateFromProps, "function" === typeof unmaskedContext && applyDerivedStateFromProps(workInProgress, unmaskedContext, props), props = pushContextProvider(workInProgress), fn.updater = classComponentUpdater, workInProgress.stateNode = fn, fn._reactInternalFiber = workInProgress, mountClassInstance(workInProgress, renderExpirationTime), current = finishClassComponent(current, workInProgress, !0, props, renderExpirationTime)) : (workInProgress.tag = 1, reconcileChildren(current, workInProgress, fn), workInProgress.memoizedProps = props, current = workInProgress.child);
        return current;

      case 1:
        return props = workInProgress.type, renderExpirationTime = workInProgress.pendingProps, didPerformWorkStackCursor.current || workInProgress.memoizedProps !== renderExpirationTime ? (fn = getUnmaskedContext(workInProgress), fn = getMaskedContext(workInProgress, fn), props = props(renderExpirationTime, fn), workInProgress.effectTag |= 1, reconcileChildren(current, workInProgress, props), workInProgress.memoizedProps = renderExpirationTime, current = workInProgress.child) : current = bailoutOnAlreadyFinishedWork(current, workInProgress), current;

      case 2:
        props = pushContextProvider(workInProgress);
        if (null === current) {
          if (null === workInProgress.stateNode) {
            var props$jscomp$0 = workInProgress.pendingProps,
                ctor = workInProgress.type;
            fn = getUnmaskedContext(workInProgress);
            var needsContext = 2 === workInProgress.tag && null != workInProgress.type.contextTypes;
            unmaskedContext = needsContext ? getMaskedContext(workInProgress, fn) : emptyObject;
            props$jscomp$0 = new ctor(props$jscomp$0, unmaskedContext);
            workInProgress.memoizedState = null !== props$jscomp$0.state && void 0 !== props$jscomp$0.state ? props$jscomp$0.state : null;
            props$jscomp$0.updater = classComponentUpdater;
            workInProgress.stateNode = props$jscomp$0;
            props$jscomp$0._reactInternalFiber = workInProgress;
            needsContext && (needsContext = workInProgress.stateNode, needsContext.__reactInternalMemoizedUnmaskedChildContext = fn, needsContext.__reactInternalMemoizedMaskedChildContext = unmaskedContext);
            mountClassInstance(workInProgress, renderExpirationTime);
            fn = !0;
          } else {
            ctor = workInProgress.type;
            fn = workInProgress.stateNode;
            needsContext = workInProgress.memoizedProps;
            unmaskedContext = workInProgress.pendingProps;
            fn.props = needsContext;
            var oldContext = fn.context;
            props$jscomp$0 = getUnmaskedContext(workInProgress);
            props$jscomp$0 = getMaskedContext(workInProgress, props$jscomp$0);
            var getDerivedStateFromProps = ctor.getDerivedStateFromProps;
            (ctor = "function" === typeof getDerivedStateFromProps || "function" === typeof fn.getSnapshotBeforeUpdate) || "function" !== typeof fn.UNSAFE_componentWillReceiveProps && "function" !== typeof fn.componentWillReceiveProps || (needsContext !== unmaskedContext || oldContext !== props$jscomp$0) && callComponentWillReceiveProps(workInProgress, fn, unmaskedContext, props$jscomp$0);
            hasForceUpdate = !1;
            var oldState = workInProgress.memoizedState;
            oldContext = fn.state = oldState;
            var updateQueue = workInProgress.updateQueue;
            null !== updateQueue && (processUpdateQueue(workInProgress, updateQueue, unmaskedContext, fn, renderExpirationTime), oldContext = workInProgress.memoizedState);
            needsContext !== unmaskedContext || oldState !== oldContext || didPerformWorkStackCursor.current || hasForceUpdate ? ("function" === typeof getDerivedStateFromProps && (applyDerivedStateFromProps(workInProgress, getDerivedStateFromProps, unmaskedContext), oldContext = workInProgress.memoizedState), (needsContext = hasForceUpdate || checkShouldComponentUpdate(workInProgress, needsContext, unmaskedContext, oldState, oldContext, props$jscomp$0)) ? (ctor || "function" !== typeof fn.UNSAFE_componentWillMount && "function" !== typeof fn.componentWillMount || ("function" === typeof fn.componentWillMount && fn.componentWillMount(), "function" === typeof fn.UNSAFE_componentWillMount && fn.UNSAFE_componentWillMount()), "function" === typeof fn.componentDidMount && (workInProgress.effectTag |= 4)) : ("function" === typeof fn.componentDidMount && (workInProgress.effectTag |= 4), workInProgress.memoizedProps = unmaskedContext, workInProgress.memoizedState = oldContext), fn.props = unmaskedContext, fn.state = oldContext, fn.context = props$jscomp$0, fn = needsContext) : ("function" === typeof fn.componentDidMount && (workInProgress.effectTag |= 4), fn = !1);
          }
        } else ctor = workInProgress.type, fn = workInProgress.stateNode, unmaskedContext = workInProgress.memoizedProps, needsContext = workInProgress.pendingProps, fn.props = unmaskedContext, oldContext = fn.context, props$jscomp$0 = getUnmaskedContext(workInProgress), props$jscomp$0 = getMaskedContext(workInProgress, props$jscomp$0), getDerivedStateFromProps = ctor.getDerivedStateFromProps, (ctor = "function" === typeof getDerivedStateFromProps || "function" === typeof fn.getSnapshotBeforeUpdate) || "function" !== typeof fn.UNSAFE_componentWillReceiveProps && "function" !== typeof fn.componentWillReceiveProps || (unmaskedContext !== needsContext || oldContext !== props$jscomp$0) && callComponentWillReceiveProps(workInProgress, fn, needsContext, props$jscomp$0), hasForceUpdate = !1, oldContext = workInProgress.memoizedState, oldState = fn.state = oldContext, updateQueue = workInProgress.updateQueue, null !== updateQueue && (processUpdateQueue(workInProgress, updateQueue, needsContext, fn, renderExpirationTime), oldState = workInProgress.memoizedState), unmaskedContext !== needsContext || oldContext !== oldState || didPerformWorkStackCursor.current || hasForceUpdate ? ("function" === typeof getDerivedStateFromProps && (applyDerivedStateFromProps(workInProgress, getDerivedStateFromProps, needsContext), oldState = workInProgress.memoizedState), (getDerivedStateFromProps = hasForceUpdate || checkShouldComponentUpdate(workInProgress, unmaskedContext, needsContext, oldContext, oldState, props$jscomp$0)) ? (ctor || "function" !== typeof fn.UNSAFE_componentWillUpdate && "function" !== typeof fn.componentWillUpdate || ("function" === typeof fn.componentWillUpdate && fn.componentWillUpdate(needsContext, oldState, props$jscomp$0), "function" === typeof fn.UNSAFE_componentWillUpdate && fn.UNSAFE_componentWillUpdate(needsContext, oldState, props$jscomp$0)), "function" === typeof fn.componentDidUpdate && (workInProgress.effectTag |= 4), "function" === typeof fn.getSnapshotBeforeUpdate && (workInProgress.effectTag |= 256)) : ("function" !== typeof fn.componentDidUpdate || unmaskedContext === current.memoizedProps && oldContext === current.memoizedState || (workInProgress.effectTag |= 4), "function" !== typeof fn.getSnapshotBeforeUpdate || unmaskedContext === current.memoizedProps && oldContext === current.memoizedState || (workInProgress.effectTag |= 256), workInProgress.memoizedProps = needsContext, workInProgress.memoizedState = oldState), fn.props = needsContext, fn.state = oldState, fn.context = props$jscomp$0, fn = getDerivedStateFromProps) : ("function" !== typeof fn.componentDidUpdate || unmaskedContext === current.memoizedProps && oldContext === current.memoizedState || (workInProgress.effectTag |= 4), "function" !== typeof fn.getSnapshotBeforeUpdate || unmaskedContext === current.memoizedProps && oldContext === current.memoizedState || (workInProgress.effectTag |= 256), fn = !1);
        return finishClassComponent(current, workInProgress, fn, props, renderExpirationTime);

      case 3:
        return pushHostRootContext(workInProgress), props = workInProgress.updateQueue, null !== props ? (fn = workInProgress.memoizedState, fn = null !== fn ? fn.element : null, processUpdateQueue(workInProgress, props, workInProgress.pendingProps, null, renderExpirationTime), renderExpirationTime = workInProgress.memoizedState.element, renderExpirationTime === fn ? current = bailoutOnAlreadyFinishedWork(current, workInProgress) : (reconcileChildren(current, workInProgress, renderExpirationTime), current = workInProgress.child)) : current = bailoutOnAlreadyFinishedWork(current, workInProgress), current;

      case 5:
        return requiredContext(rootInstanceStackCursor.current), renderExpirationTime = requiredContext(contextStackCursor$1.current), props = workInProgress.type, props = "AndroidTextInput" === props || "RCTMultilineTextInputView" === props || "RCTSinglelineTextInputView" === props || "RCTText" === props || "RCTVirtualText" === props, props = renderExpirationTime.isInAParentText !== props ? {
          isInAParentText: props
        } : renderExpirationTime, renderExpirationTime !== props && (push(contextFiberStackCursor, workInProgress, workInProgress), push(contextStackCursor$1, props, workInProgress)), null === current && tryToClaimNextHydratableInstance(workInProgress), props = workInProgress.memoizedProps, renderExpirationTime = workInProgress.pendingProps, didPerformWorkStackCursor.current || props !== renderExpirationTime ? (props = renderExpirationTime.children, markRef(current, workInProgress), reconcileChildren(current, workInProgress, props), workInProgress.memoizedProps = renderExpirationTime, current = workInProgress.child) : current = bailoutOnAlreadyFinishedWork(current, workInProgress), current;

      case 6:
        return null === current && tryToClaimNextHydratableInstance(workInProgress), workInProgress.memoizedProps = workInProgress.pendingProps, null;

      case 16:
        return null;

      case 4:
        return pushHostContainer(workInProgress, workInProgress.stateNode.containerInfo), props = workInProgress.pendingProps, didPerformWorkStackCursor.current || workInProgress.memoizedProps !== props ? (null === current ? workInProgress.child = reconcileChildFibers(workInProgress, null, props, renderExpirationTime) : reconcileChildren(current, workInProgress, props), workInProgress.memoizedProps = props, current = workInProgress.child) : current = bailoutOnAlreadyFinishedWork(current, workInProgress), current;

      case 14:
        return props = workInProgress.type.render, renderExpirationTime = workInProgress.pendingProps, fn = workInProgress.ref, didPerformWorkStackCursor.current || workInProgress.memoizedProps !== renderExpirationTime || fn !== (null !== current ? current.ref : null) ? (props = props(renderExpirationTime, fn), reconcileChildren(current, workInProgress, props), workInProgress.memoizedProps = renderExpirationTime, current = workInProgress.child) : current = bailoutOnAlreadyFinishedWork(current, workInProgress), current;

      case 10:
        return renderExpirationTime = workInProgress.pendingProps, didPerformWorkStackCursor.current || workInProgress.memoizedProps !== renderExpirationTime ? (reconcileChildren(current, workInProgress, renderExpirationTime), workInProgress.memoizedProps = renderExpirationTime, current = workInProgress.child) : current = bailoutOnAlreadyFinishedWork(current, workInProgress), current;

      case 11:
        return renderExpirationTime = workInProgress.pendingProps.children, didPerformWorkStackCursor.current || null !== renderExpirationTime && workInProgress.memoizedProps !== renderExpirationTime ? (reconcileChildren(current, workInProgress, renderExpirationTime), workInProgress.memoizedProps = renderExpirationTime, current = workInProgress.child) : current = bailoutOnAlreadyFinishedWork(current, workInProgress), current;

      case 15:
        return renderExpirationTime = workInProgress.pendingProps, workInProgress.memoizedProps === renderExpirationTime ? current = bailoutOnAlreadyFinishedWork(current, workInProgress) : (reconcileChildren(current, workInProgress, renderExpirationTime.children), workInProgress.memoizedProps = renderExpirationTime, current = workInProgress.child), current;

      case 13:
        return updateContextProvider(current, workInProgress, renderExpirationTime);

      case 12:
        a: if (fn = workInProgress.type, unmaskedContext = workInProgress.pendingProps, needsContext = workInProgress.memoizedProps, props = fn._currentValue2, props$jscomp$0 = fn._changedBits2, didPerformWorkStackCursor.current || 0 !== props$jscomp$0 || needsContext !== unmaskedContext) {
          workInProgress.memoizedProps = unmaskedContext;
          ctor = unmaskedContext.unstable_observedBits;
          if (void 0 === ctor || null === ctor) ctor = 1073741823;
          workInProgress.stateNode = ctor;
          if (0 !== (props$jscomp$0 & ctor)) propagateContextChange(workInProgress, fn, props$jscomp$0, renderExpirationTime);else if (needsContext === unmaskedContext) {
            current = bailoutOnAlreadyFinishedWork(current, workInProgress);
            break a;
          }
          renderExpirationTime = unmaskedContext.children;
          renderExpirationTime = renderExpirationTime(props);
          workInProgress.effectTag |= 1;
          reconcileChildren(current, workInProgress, renderExpirationTime);
          current = workInProgress.child;
        } else current = bailoutOnAlreadyFinishedWork(current, workInProgress);

        return current;

      default:
        invariant(!1, "Unknown unit of work tag. This error is likely caused by a bug in React. Please file an issue.");
    }
  }

  function appendAllChildren(parent, workInProgress) {
    for (var node = workInProgress.child; null !== node;) {
      if (5 === node.tag || 6 === node.tag) FabricUIManager.appendChild(parent.node, node.stateNode.node);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;
    }
  }

  var updateHostContainer = void 0,
      updateHostComponent$1 = void 0,
      updateHostText$1 = void 0;

  updateHostContainer = function updateHostContainer(workInProgress) {
    var portalOrRoot = workInProgress.stateNode;

    if (null !== workInProgress.firstEffect) {
      var container = portalOrRoot.containerInfo,
          newChildSet = FabricUIManager.createChildSet(container);

      a: for (var node = workInProgress.child; null !== node;) {
        if (5 === node.tag || 6 === node.tag) FabricUIManager.appendChildToSet(newChildSet, node.stateNode.node);else if (4 !== node.tag && null !== node.child) {
          node.child.return = node;
          node = node.child;
          continue;
        }
        if (node === workInProgress) break a;

        for (; null === node.sibling;) {
          if (null === node.return || node.return === workInProgress) break a;
          node = node.return;
        }

        node.sibling.return = node.return;
        node = node.sibling;
      }

      portalOrRoot.pendingChildren = newChildSet;
      workInProgress.effectTag |= 4;
      FabricUIManager.completeRoot(container, newChildSet);
    }
  };

  updateHostComponent$1 = function updateHostComponent$1(current, workInProgress, updatePayload) {
    var childrenUnchanged = null === workInProgress.firstEffect;
    current = current.stateNode;
    if (childrenUnchanged && null === updatePayload) workInProgress.stateNode = current;else {
      var node = current.node;
      updatePayload = {
        node: childrenUnchanged ? null !== updatePayload ? FabricUIManager.cloneNodeWithNewProps(node, updatePayload, workInProgress) : FabricUIManager.cloneNode(node, workInProgress) : null !== updatePayload ? FabricUIManager.cloneNodeWithNewChildrenAndProps(node, updatePayload, workInProgress) : FabricUIManager.cloneNodeWithNewChildren(node, workInProgress),
        canonical: current.canonical
      };
      workInProgress.stateNode = updatePayload;
      childrenUnchanged ? workInProgress.effectTag |= 4 : appendAllChildren(updatePayload, workInProgress);
    }
  };

  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 completeWork(current, workInProgress) {
    var newProps = workInProgress.pendingProps;

    switch (workInProgress.tag) {
      case 1:
        return null;

      case 2:
        return popContextProvider(workInProgress), null;

      case 3:
        popHostContainer(workInProgress);
        popTopLevelContextObject(workInProgress);
        newProps = workInProgress.stateNode;
        newProps.pendingContext && (newProps.context = newProps.pendingContext, newProps.pendingContext = null);
        if (null === current || null === current.child) workInProgress.effectTag &= -3;
        updateHostContainer(workInProgress);
        return null;

      case 5:
        popHostContext(workInProgress);
        var rootContainerInstance = requiredContext(rootInstanceStackCursor.current),
            type = workInProgress.type;

        if (null !== current && null != workInProgress.stateNode) {
          var oldProps = current.memoizedProps,
              instance = workInProgress.stateNode,
              currentHostContext = requiredContext(contextStackCursor$1.current),
              updatePayload = diffProperties(null, oldProps, newProps, instance.canonical.viewConfig.validAttributes);
          instance.canonical.currentProps = newProps;
          updateHostComponent$1(current, workInProgress, updatePayload, type, oldProps, newProps, rootContainerInstance, currentHostContext);
          current.ref !== workInProgress.ref && (workInProgress.effectTag |= 128);
        } else {
          if (!newProps) return invariant(null !== workInProgress.stateNode, "We must have new props for new mounts. This error is likely caused by a bug in React. Please file an issue."), null;
          instance = requiredContext(contextStackCursor$1.current);
          current = nextReactTag;
          nextReactTag += 2;
          oldProps = ReactNativeViewConfigRegistry.get(type);
          invariant("RCTView" !== type || !instance.isInAParentText, "Nesting of <View> within <Text> is not currently supported.");
          type = diffProperties(null, emptyObject$1, newProps, oldProps.validAttributes);
          rootContainerInstance = FabricUIManager.createNode(current, oldProps.uiViewClassName, rootContainerInstance, type, workInProgress);
          newProps = new ReactFabricHostComponent(current, oldProps, newProps);
          newProps = {
            node: rootContainerInstance,
            canonical: newProps
          };
          appendAllChildren(newProps, workInProgress);
          workInProgress.stateNode = newProps;
          null !== workInProgress.ref && (workInProgress.effectTag |= 128);
        }

        return null;

      case 6:
        if (current && null != workInProgress.stateNode) updateHostText$1(current, workInProgress, current.memoizedProps, newProps);else {
          if ("string" !== typeof newProps) return invariant(null !== workInProgress.stateNode, "We must have new props for new mounts. This error is likely caused by a bug in React. Please file an issue."), null;
          rootContainerInstance = requiredContext(rootInstanceStackCursor.current);
          type = requiredContext(contextStackCursor$1.current);
          workInProgress.stateNode = createTextInstance(newProps, rootContainerInstance, type, workInProgress);
        }
        return null;

      case 14:
        return null;

      case 16:
        return null;

      case 10:
        return null;

      case 11:
        return null;

      case 15:
        return null;

      case 4:
        return popHostContainer(workInProgress), updateHostContainer(workInProgress), null;

      case 13:
        return popProvider(workInProgress), null;

      case 12:
        return null;

      case 0:
        invariant(!1, "An indeterminate component should have become determinate before completing. This error is likely caused by a bug in React. Please file an issue.");

      default:
        invariant(!1, "Unknown unit of work tag. This error is likely caused by a bug in React. Please file an issue.");
    }
  }

  function logError(boundary, errorInfo) {
    var source = errorInfo.source,
        stack = errorInfo.stack;
    null === stack && null !== source && (stack = getStackAddendumByWorkInProgressFiber(source));
    null !== source && getComponentName(source);
    source = null !== stack ? stack : "";
    errorInfo = errorInfo.value;
    null !== boundary && 2 === boundary.tag && getComponentName(boundary);

    try {
      if (errorInfo instanceof Error) {
        var message = errorInfo.message,
            name = errorInfo.name;
        var errorToHandle = errorInfo;

        try {
          errorToHandle.message = (message ? name + ": " + message : name) + "\n\nThis error is located at:" + source;
        } catch (e) {}
      } else errorToHandle = "string" === typeof errorInfo ? Error(errorInfo + "\n\nThis error is located at:" + source) : Error("Unspecified error at:" + source);

      ExceptionsManager.handleException(errorToHandle, !1);
    } catch (e) {
      e && e.suppressReactErrorLogging || console.error(e);
    }
  }

  function safelyDetachRef(current) {
    var ref = current.ref;
    if (null !== ref) if ("function" === typeof ref) try {
      ref(null);
    } catch (refError) {
      captureCommitPhaseError(current, refError);
    } else ref.current = null;
  }

  function commitWork(current, finishedWork) {
    switch (finishedWork.tag) {
      case 2:
        break;

      case 5:
        break;

      case 6:
        break;

      case 3:
      case 4:
        break;

      default:
        invariant(!1, "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 createRootErrorUpdate(fiber, errorInfo, expirationTime) {
    expirationTime = createUpdate(expirationTime);
    expirationTime.tag = 3;
    expirationTime.payload = {
      element: null
    };
    var error = errorInfo.value;

    expirationTime.callback = function () {
      onUncaughtError(error);
      logError(fiber, errorInfo);
    };

    return expirationTime;
  }

  function createClassErrorUpdate(fiber, errorInfo, expirationTime) {
    expirationTime = createUpdate(expirationTime);
    expirationTime.tag = 3;
    var inst = fiber.stateNode;
    null !== inst && "function" === typeof inst.componentDidCatch && (expirationTime.callback = function () {
      null === legacyErrorBoundariesThatAlreadyFailed ? legacyErrorBoundariesThatAlreadyFailed = new Set([this]) : legacyErrorBoundariesThatAlreadyFailed.add(this);
      var error = errorInfo.value,
          stack = errorInfo.stack;
      logError(fiber, errorInfo);
      this.componentDidCatch(error, {
        componentStack: null !== stack ? stack : ""
      });
    });
    return expirationTime;
  }

  function unwindWork(workInProgress) {
    switch (workInProgress.tag) {
      case 2:
        popContextProvider(workInProgress);
        var effectTag = workInProgress.effectTag;
        return effectTag & 1024 ? (workInProgress.effectTag = effectTag & -1025 | 64, workInProgress) : null;

      case 3:
        return popHostContainer(workInProgress), popTopLevelContextObject(workInProgress), effectTag = workInProgress.effectTag, effectTag & 1024 ? (workInProgress.effectTag = effectTag & -1025 | 64, workInProgress) : null;

      case 5:
        return popHostContext(workInProgress), null;

      case 16:
        return effectTag = workInProgress.effectTag, effectTag & 1024 ? (workInProgress.effectTag = effectTag & -1025 | 64, workInProgress) : null;

      case 4:
        return popHostContainer(workInProgress), null;

      case 13:
        return popProvider(workInProgress), null;

      default:
        return null;
    }
  }

  var originalStartTimeMs = now$1(),
      mostRecentCurrentTime = 2,
      mostRecentCurrentTimeMs = originalStartTimeMs,
      lastUniqueAsyncExpiration = 0,
      expirationContext = 0,
      isWorking = !1,
      nextUnitOfWork = null,
      nextRoot = null,
      nextRenderExpirationTime = 0,
      nextLatestTimeoutMs = -1,
      nextRenderDidError = !1,
      nextEffect = null,
      isCommitting$1 = !1,
      legacyErrorBoundariesThatAlreadyFailed = null;

  function resetStack() {
    if (null !== nextUnitOfWork) for (var interruptedWork = nextUnitOfWork.return; null !== interruptedWork;) {
      var interruptedWork$jscomp$0 = interruptedWork;

      switch (interruptedWork$jscomp$0.tag) {
        case 2:
          popContextProvider(interruptedWork$jscomp$0);
          break;

        case 3:
          popHostContainer(interruptedWork$jscomp$0);
          popTopLevelContextObject(interruptedWork$jscomp$0);
          break;

        case 5:
          popHostContext(interruptedWork$jscomp$0);
          break;

        case 4:
          popHostContainer(interruptedWork$jscomp$0);
          break;

        case 13:
          popProvider(interruptedWork$jscomp$0);
      }

      interruptedWork = interruptedWork.return;
    }
    nextRoot = null;
    nextRenderExpirationTime = 0;
    nextLatestTimeoutMs = -1;
    nextRenderDidError = !1;
    nextUnitOfWork = null;
  }

  function completeUnitOfWork(workInProgress$jscomp$0) {
    for (;;) {
      var current = workInProgress$jscomp$0.alternate,
          returnFiber = workInProgress$jscomp$0.return,
          siblingFiber = workInProgress$jscomp$0.sibling;

      if (0 === (workInProgress$jscomp$0.effectTag & 512)) {
        current = completeWork(current, workInProgress$jscomp$0, nextRenderExpirationTime);
        var workInProgress = workInProgress$jscomp$0;

        if (1073741823 === nextRenderExpirationTime || 1073741823 !== workInProgress.expirationTime) {
          var newExpirationTime = 0;

          switch (workInProgress.tag) {
            case 3:
            case 2:
              var updateQueue = workInProgress.updateQueue;
              null !== updateQueue && (newExpirationTime = updateQueue.expirationTime);
          }

          for (updateQueue = workInProgress.child; null !== updateQueue;) {
            0 !== updateQueue.expirationTime && (0 === newExpirationTime || newExpirationTime > updateQueue.expirationTime) && (newExpirationTime = updateQueue.expirationTime), updateQueue = updateQueue.sibling;
          }

          workInProgress.expirationTime = newExpirationTime;
        }

        if (null !== current) return current;
        null !== returnFiber && 0 === (returnFiber.effectTag & 512) && (null === returnFiber.firstEffect && (returnFiber.firstEffect = workInProgress$jscomp$0.firstEffect), null !== workInProgress$jscomp$0.lastEffect && (null !== returnFiber.lastEffect && (returnFiber.lastEffect.nextEffect = workInProgress$jscomp$0.firstEffect), returnFiber.lastEffect = workInProgress$jscomp$0.lastEffect), 1 < workInProgress$jscomp$0.effectTag && (null !== returnFiber.lastEffect ? returnFiber.lastEffect.nextEffect = workInProgress$jscomp$0 : returnFiber.firstEffect = workInProgress$jscomp$0, returnFiber.lastEffect = workInProgress$jscomp$0));
      } else {
        workInProgress$jscomp$0 = unwindWork(workInProgress$jscomp$0, nextRenderExpirationTime);
        if (null !== workInProgress$jscomp$0) return workInProgress$jscomp$0.effectTag &= 511, workInProgress$jscomp$0;
        null !== returnFiber && (returnFiber.firstEffect = returnFiber.lastEffect = null, returnFiber.effectTag |= 512);
      }

      if (null !== siblingFiber) return siblingFiber;
      if (null !== returnFiber) workInProgress$jscomp$0 = returnFiber;else break;
    }

    return null;
  }

  function performUnitOfWork(workInProgress) {
    var next = beginWork(workInProgress.alternate, workInProgress, nextRenderExpirationTime);
    null === next && (next = completeUnitOfWork(workInProgress));
    ReactCurrentOwner.current = null;
    return next;
  }

  function renderRoot(root$jscomp$0, isYieldy) {
    invariant(!isWorking, "renderRoot was called recursively. This error is likely caused by a bug in React. Please file an issue.");
    isWorking = !0;
    var expirationTime = root$jscomp$0.nextExpirationTimeToWorkOn;
    if (expirationTime !== nextRenderExpirationTime || root$jscomp$0 !== nextRoot || null === nextUnitOfWork) resetStack(), nextRoot = root$jscomp$0, nextRenderExpirationTime = expirationTime, nextLatestTimeoutMs = -1, nextRenderDidError = !1, nextUnitOfWork = createWorkInProgress(nextRoot.current, null, nextRenderExpirationTime), root$jscomp$0.pendingCommitExpirationTime = 0;
    var didFatal = !1;

    do {
      try {
        if (isYieldy) for (; null !== nextUnitOfWork && !shouldYield();) {
          nextUnitOfWork = performUnitOfWork(nextUnitOfWork);
        } else for (; null !== nextUnitOfWork;) {
          nextUnitOfWork = performUnitOfWork(nextUnitOfWork);
        }
      } catch (thrownValue) {
        if (null === nextUnitOfWork) didFatal = !0, onUncaughtError(thrownValue);else {
          invariant(null !== nextUnitOfWork, "Failed to replay rendering after an error. This is likely caused by a bug in React. Please file an issue with a reproducing case to help us find it.");
          isYieldy = nextUnitOfWork;
          var returnFiber = isYieldy.return;

          if (null === returnFiber) {
            didFatal = !0;
            onUncaughtError(thrownValue);
            break;
          }

          a: {
            var root = root$jscomp$0,
                returnFiber$jscomp$0 = returnFiber,
                sourceFiber = isYieldy,
                value = thrownValue;
            returnFiber = nextRenderExpirationTime;
            sourceFiber.effectTag |= 512;
            sourceFiber.firstEffect = sourceFiber.lastEffect = null;
            nextRenderDidError = !0;

            if ((root.didError || 1 === returnFiber) && (returnFiber === root.latestPendingTime || returnFiber === root.latestSuspendedTime)) {
              value = createCapturedValue(value, sourceFiber);
              root = returnFiber$jscomp$0;

              do {
                switch (root.tag) {
                  case 3:
                    root.effectTag |= 1024;
                    value = createRootErrorUpdate(root, value, returnFiber);
                    enqueueCapturedUpdate(root, value, returnFiber);
                    break a;

                  case 2:
                    if (returnFiber$jscomp$0 = value, sourceFiber = root.stateNode, 0 === (root.effectTag & 64) && null !== sourceFiber && "function" === typeof sourceFiber.componentDidCatch && (null === legacyErrorBoundariesThatAlreadyFailed || !legacyErrorBoundariesThatAlreadyFailed.has(sourceFiber))) {
                      root.effectTag |= 1024;
                      value = createClassErrorUpdate(root, returnFiber$jscomp$0, returnFiber);
                      enqueueCapturedUpdate(root, value, returnFiber);
                      break a;
                    }

                }

                root = root.return;
              } while (null !== root);
            }
          }

          nextUnitOfWork = completeUnitOfWork(isYieldy);
        }
      }

      break;
    } while (1);

    isWorking = !1;
    didFatal ? root$jscomp$0.finishedWork = null : null === nextUnitOfWork ? (didFatal = root$jscomp$0.current.alternate, invariant(null !== didFatal, "Finished root should have a work-in-progress. This error is likely caused by a bug in React. Please file an issue."), 0 === (didFatal.effectTag & 512) ? (root$jscomp$0.pendingCommitExpirationTime = expirationTime, root$jscomp$0.finishedWork = didFatal) : (!nextRenderDidError || expirationTime !== root$jscomp$0.latestPendingTime && expirationTime !== root$jscomp$0.latestSuspendedTime ? (didFatal = root$jscomp$0.earliestPendingTime, isYieldy = root$jscomp$0.latestPendingTime, didFatal === expirationTime ? root$jscomp$0.earliestPendingTime = isYieldy === expirationTime ? root$jscomp$0.latestPendingTime = 0 : isYieldy : isYieldy === expirationTime && (root$jscomp$0.latestPendingTime = didFatal), didFatal = root$jscomp$0.latestSuspendedTime, didFatal === expirationTime && (root$jscomp$0.latestPingedTime = 0), isYieldy = root$jscomp$0.earliestSuspendedTime, 0 === isYieldy ? root$jscomp$0.earliestSuspendedTime = root$jscomp$0.latestSuspendedTime = expirationTime : isYieldy > expirationTime ? root$jscomp$0.earliestSuspendedTime = expirationTime : didFatal < expirationTime && (root$jscomp$0.latestSuspendedTime = expirationTime)) : root$jscomp$0.didError = !0, findNextPendingPriorityLevel(root$jscomp$0), onSuspend(root$jscomp$0, expirationTime, root$jscomp$0.expirationTime, nextLatestTimeoutMs))) : root$jscomp$0.finishedWork = null;
  }

  function captureCommitPhaseError(fiber, error) {
    var JSCompiler_inline_result;

    a: {
      invariant(!isWorking || isCommitting$1, "dispatch: Cannot dispatch during the render phase.");

      for (JSCompiler_inline_result = fiber.return; null !== JSCompiler_inline_result;) {
        switch (JSCompiler_inline_result.tag) {
          case 2:
            var instance = JSCompiler_inline_result.stateNode;

            if ("function" === typeof JSCompiler_inline_result.type.getDerivedStateFromCatch || "function" === typeof instance.componentDidCatch && (null === legacyErrorBoundariesThatAlreadyFailed || !legacyErrorBoundariesThatAlreadyFailed.has(instance))) {
              fiber = createCapturedValue(error, fiber);
              fiber = createClassErrorUpdate(JSCompiler_inline_result, fiber, 1);
              enqueueUpdate(JSCompiler_inline_result, fiber, 1);
              scheduleWork(JSCompiler_inline_result, 1);
              JSCompiler_inline_result = void 0;
              break a;
            }

            break;

          case 3:
            fiber = createCapturedValue(error, fiber);
            fiber = createRootErrorUpdate(JSCompiler_inline_result, fiber, 1);
            enqueueUpdate(JSCompiler_inline_result, fiber, 1);
            scheduleWork(JSCompiler_inline_result, 1);
            JSCompiler_inline_result = void 0;
            break a;
        }

        JSCompiler_inline_result = JSCompiler_inline_result.return;
      }

      3 === fiber.tag && (JSCompiler_inline_result = createCapturedValue(error, fiber), JSCompiler_inline_result = createRootErrorUpdate(fiber, JSCompiler_inline_result, 1), enqueueUpdate(fiber, JSCompiler_inline_result, 1), scheduleWork(fiber, 1));
      JSCompiler_inline_result = void 0;
    }

    return JSCompiler_inline_result;
  }

  function computeExpirationForFiber(currentTime, fiber) {
    currentTime = 0 !== expirationContext ? expirationContext : isWorking ? isCommitting$1 ? 1 : nextRenderExpirationTime : fiber.mode & 1 ? isBatchingInteractiveUpdates ? 2 + 10 * (((currentTime - 2 + 15) / 10 | 0) + 1) : 2 + 25 * (((currentTime - 2 + 500) / 25 | 0) + 1) : 1;
    isBatchingInteractiveUpdates && (0 === lowestPendingInteractiveExpirationTime || currentTime > lowestPendingInteractiveExpirationTime) && (lowestPendingInteractiveExpirationTime = currentTime);
    return currentTime;
  }

  function scheduleWork(fiber, expirationTime) {
    for (; null !== fiber;) {
      if (0 === fiber.expirationTime || fiber.expirationTime > expirationTime) fiber.expirationTime = expirationTime;
      null !== fiber.alternate && (0 === fiber.alternate.expirationTime || fiber.alternate.expirationTime > expirationTime) && (fiber.alternate.expirationTime = expirationTime);
      if (null === fiber.return) if (3 === fiber.tag) {
        var root = fiber.stateNode;
        !isWorking && 0 !== nextRenderExpirationTime && expirationTime < nextRenderExpirationTime && resetStack();
        markPendingPriorityLevel(root, expirationTime);
        isWorking && !isCommitting$1 && nextRoot === root || requestWork(root, root.expirationTime);
        nestedUpdateCount > NESTED_UPDATE_LIMIT && invariant(!1, "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.");
      } else break;
      fiber = fiber.return;
    }
  }

  function recalculateCurrentTime() {
    mostRecentCurrentTimeMs = now$1() - originalStartTimeMs;
    return mostRecentCurrentTime = (mostRecentCurrentTimeMs / 10 | 0) + 2;
  }

  function syncUpdates(fn, a, b, c, d) {
    var previousExpirationContext = expirationContext;
    expirationContext = 1;

    try {
      return fn(a, b, c, d);
    } finally {
      expirationContext = previousExpirationContext;
    }
  }

  var firstScheduledRoot = null,
      lastScheduledRoot = null,
      callbackExpirationTime = 0,
      callbackID = void 0,
      isRendering = !1,
      nextFlushedRoot = null,
      nextFlushedExpirationTime = 0,
      lowestPendingInteractiveExpirationTime = 0,
      deadlineDidExpire = !1,
      hasUnhandledError = !1,
      unhandledError = null,
      deadline = null,
      isBatchingUpdates = !1,
      isUnbatchingUpdates = !1,
      isBatchingInteractiveUpdates = !1,
      completedBatches = null,
      NESTED_UPDATE_LIMIT = 1e3,
      nestedUpdateCount = 0,
      timeHeuristicForUnitOfWork = 1;

  function scheduleCallbackWithExpirationTime(expirationTime) {
    if (0 !== callbackExpirationTime) {
      if (expirationTime > callbackExpirationTime) return;

      if (null !== callbackID) {
        var callbackID$jscomp$0 = callbackID;
        scheduledCallback = null;
        clearTimeout(callbackID$jscomp$0);
      }
    }

    callbackExpirationTime = expirationTime;
    now$1();
    scheduledCallback = performAsyncWork;
    callbackID = setTimeout(setTimeoutCallback, 1);
  }

  function onSuspend(root, suspendedExpirationTime, expirationTime, timeoutMs) {
    0 <= timeoutMs && setTimeout(function () {
      var latestSuspendedTime = root.latestSuspendedTime;
      0 !== latestSuspendedTime && latestSuspendedTime <= suspendedExpirationTime && (latestSuspendedTime = root.latestPingedTime, 0 === latestSuspendedTime || latestSuspendedTime < suspendedExpirationTime) && (root.latestPingedTime = suspendedExpirationTime);
      findNextPendingPriorityLevel(root);
      latestSuspendedTime = root.expirationTime;
      0 !== latestSuspendedTime && requestWork(root, latestSuspendedTime);
    }, timeoutMs);
    root.expirationTime = expirationTime;
  }

  function requestWork(root, expirationTime) {
    if (null === root.nextScheduledRoot) root.expirationTime = expirationTime, null === lastScheduledRoot ? (firstScheduledRoot = lastScheduledRoot = root, root.nextScheduledRoot = root) : (lastScheduledRoot = lastScheduledRoot.nextScheduledRoot = root, lastScheduledRoot.nextScheduledRoot = firstScheduledRoot);else {
      var remainingExpirationTime = root.expirationTime;
      if (0 === remainingExpirationTime || expirationTime < remainingExpirationTime) root.expirationTime = expirationTime;
    }
    isRendering || (isBatchingUpdates ? isUnbatchingUpdates && (nextFlushedRoot = root, nextFlushedExpirationTime = 1, performWorkOnRoot(root, 1, !1)) : 1 === expirationTime ? performWork(1, null) : scheduleCallbackWithExpirationTime(expirationTime));
  }

  function findHighestPriorityRoot() {
    var highestPriorityWork = 0,
        highestPriorityRoot = null;
    if (null !== lastScheduledRoot) for (var previousScheduledRoot = lastScheduledRoot, root = firstScheduledRoot; null !== root;) {
      var remainingExpirationTime = root.expirationTime;

      if (0 === remainingExpirationTime) {
        invariant(null !== previousScheduledRoot && null !== lastScheduledRoot, "Should have a previous and last root. This error is likely caused by a bug in React. Please file an issue.");

        if (root === root.nextScheduledRoot) {
          firstScheduledRoot = lastScheduledRoot = root.nextScheduledRoot = null;
          break;
        } else if (root === firstScheduledRoot) firstScheduledRoot = remainingExpirationTime = root.nextScheduledRoot, lastScheduledRoot.nextScheduledRoot = remainingExpirationTime, root.nextScheduledRoot = null;else if (root === lastScheduledRoot) {
          lastScheduledRoot = previousScheduledRoot;
          lastScheduledRoot.nextScheduledRoot = firstScheduledRoot;
          root.nextScheduledRoot = null;
          break;
        } else previousScheduledRoot.nextScheduledRoot = root.nextScheduledRoot, root.nextScheduledRoot = null;

        root = previousScheduledRoot.nextScheduledRoot;
      } else {
        if (0 === highestPriorityWork || remainingExpirationTime < highestPriorityWork) highestPriorityWork = remainingExpirationTime, highestPriorityRoot = root;
        if (root === lastScheduledRoot) break;
        previousScheduledRoot = root;
        root = root.nextScheduledRoot;
      }
    }
    previousScheduledRoot = nextFlushedRoot;
    null !== previousScheduledRoot && previousScheduledRoot === highestPriorityRoot && 1 === highestPriorityWork ? nestedUpdateCount++ : nestedUpdateCount = 0;
    nextFlushedRoot = highestPriorityRoot;
    nextFlushedExpirationTime = highestPriorityWork;
  }

  function performAsyncWork(dl) {
    performWork(0, dl);
  }

  function performWork(minExpirationTime, dl) {
    deadline = dl;
    findHighestPriorityRoot();
    if (null !== deadline) for (; null !== nextFlushedRoot && 0 !== nextFlushedExpirationTime && (0 === minExpirationTime || minExpirationTime >= nextFlushedExpirationTime) && (!deadlineDidExpire || recalculateCurrentTime() >= nextFlushedExpirationTime);) {
      recalculateCurrentTime(), performWorkOnRoot(nextFlushedRoot, nextFlushedExpirationTime, !0), findHighestPriorityRoot();
    } else for (; null !== nextFlushedRoot && 0 !== nextFlushedExpirationTime && (0 === minExpirationTime || minExpirationTime >= nextFlushedExpirationTime);) {
      performWorkOnRoot(nextFlushedRoot, nextFlushedExpirationTime, !1), findHighestPriorityRoot();
    }
    null !== deadline && (callbackExpirationTime = 0, callbackID = null);
    0 !== nextFlushedExpirationTime && scheduleCallbackWithExpirationTime(nextFlushedExpirationTime);
    deadline = null;
    deadlineDidExpire = !1;
    finishRendering();
  }

  function finishRendering() {
    nestedUpdateCount = 0;

    if (null !== completedBatches) {
      var batches = completedBatches;
      completedBatches = null;

      for (var i = 0; i < batches.length; i++) {
        var batch = batches[i];

        try {
          batch._onComplete();
        } catch (error) {
          hasUnhandledError || (hasUnhandledError = !0, unhandledError = error);
        }
      }
    }

    if (hasUnhandledError) throw batches = unhandledError, unhandledError = null, hasUnhandledError = !1, batches;
  }

  function performWorkOnRoot(root, expirationTime, isYieldy) {
    invariant(!isRendering, "performWorkOnRoot was called recursively. This error is likely caused by a bug in React. Please file an issue.");
    isRendering = !0;
    isYieldy ? (isYieldy = root.finishedWork, null !== isYieldy ? completeRoot$1(root, isYieldy, expirationTime) : (root.finishedWork = null, renderRoot(root, !0), isYieldy = root.finishedWork, null !== isYieldy && (shouldYield() ? root.finishedWork = isYieldy : completeRoot$1(root, isYieldy, expirationTime)))) : (isYieldy = root.finishedWork, null !== isYieldy ? completeRoot$1(root, isYieldy, expirationTime) : (root.finishedWork = null, renderRoot(root, !1), isYieldy = root.finishedWork, null !== isYieldy && completeRoot$1(root, isYieldy, expirationTime)));
    isRendering = !1;
  }

  function completeRoot$1(root, finishedWork$jscomp$0, expirationTime) {
    var firstBatch = root.firstBatch;

    if (null !== firstBatch && firstBatch._expirationTime <= expirationTime && (null === completedBatches ? completedBatches = [firstBatch] : completedBatches.push(firstBatch), firstBatch._defer)) {
      root.finishedWork = finishedWork$jscomp$0;
      root.expirationTime = 0;
      return;
    }

    root.finishedWork = null;
    isCommitting$1 = isWorking = !0;
    invariant(root.current !== finishedWork$jscomp$0, "Cannot commit the same tree as before. This is probably a bug related to the return field. This error is likely caused by a bug in React. Please file an issue.");
    expirationTime = root.pendingCommitExpirationTime;
    invariant(0 !== expirationTime, "Cannot commit an incomplete root. This error is likely caused by a bug in React. Please file an issue.");
    root.pendingCommitExpirationTime = 0;
    firstBatch = finishedWork$jscomp$0.expirationTime;
    recalculateCurrentTime();
    root.didError = !1;
    if (0 === firstBatch) root.earliestPendingTime = 0, root.latestPendingTime = 0, root.earliestSuspendedTime = 0, root.latestSuspendedTime = 0, root.latestPingedTime = 0;else {
      var latestPendingTime = root.latestPendingTime;
      0 !== latestPendingTime && (latestPendingTime < firstBatch ? root.earliestPendingTime = root.latestPendingTime = 0 : root.earliestPendingTime < firstBatch && (root.earliestPendingTime = root.latestPendingTime));
      latestPendingTime = root.earliestSuspendedTime;
      0 === latestPendingTime ? markPendingPriorityLevel(root, firstBatch) : firstBatch > root.latestSuspendedTime ? (root.earliestSuspendedTime = 0, root.latestSuspendedTime = 0, root.latestPingedTime = 0, markPendingPriorityLevel(root, firstBatch)) : firstBatch < latestPendingTime && markPendingPriorityLevel(root, firstBatch);
    }
    findNextPendingPriorityLevel(root);
    ReactCurrentOwner.current = null;
    1 < finishedWork$jscomp$0.effectTag ? null !== finishedWork$jscomp$0.lastEffect ? (finishedWork$jscomp$0.lastEffect.nextEffect = finishedWork$jscomp$0, firstBatch = finishedWork$jscomp$0.firstEffect) : firstBatch = finishedWork$jscomp$0 : firstBatch = finishedWork$jscomp$0.firstEffect;

    for (nextEffect = firstBatch; null !== nextEffect;) {
      latestPendingTime = !1;
      var error = void 0;

      try {
        for (; null !== nextEffect;) {
          if (nextEffect.effectTag & 256) {
            var current = nextEffect.alternate,
                finishedWork = nextEffect;

            switch (finishedWork.tag) {
              case 2:
                if (finishedWork.effectTag & 256 && null !== current) {
                  var prevProps = current.memoizedProps,
                      prevState = current.memoizedState,
                      instance = finishedWork.stateNode;
                  instance.props = finishedWork.memoizedProps;
                  instance.state = finishedWork.memoizedState;
                  var snapshot = instance.getSnapshotBeforeUpdate(prevProps, prevState);
                  instance.__reactInternalSnapshotBeforeUpdate = snapshot;
                }

                break;

              case 3:
              case 5:
              case 6:
              case 4:
                break;

              default:
                invariant(!1, "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 (e) {
        latestPendingTime = !0, error = e;
      }

      latestPendingTime && (invariant(null !== nextEffect, "Should have next effect. This error is likely caused by a bug in React. Please file an issue."), captureCommitPhaseError(nextEffect, error), null !== nextEffect && (nextEffect = nextEffect.nextEffect));
    }

    for (nextEffect = firstBatch; null !== nextEffect;) {
      current = !1;
      prevProps = void 0;

      try {
        for (; null !== nextEffect;) {
          var effectTag = nextEffect.effectTag;

          if (effectTag & 128) {
            var current$jscomp$0 = nextEffect.alternate;

            if (null !== current$jscomp$0) {
              var currentRef = current$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:
              prevState = nextEffect;

              a: for (snapshot = instance = prevState;;) {
                latestPendingTime = snapshot;
                "function" === typeof onCommitUnmount && onCommitUnmount(latestPendingTime);

                switch (latestPendingTime.tag) {
                  case 2:
                    safelyDetachRef(latestPendingTime);
                    var instance$jscomp$0 = latestPendingTime.stateNode;
                    if ("function" === typeof instance$jscomp$0.componentWillUnmount) try {
                      instance$jscomp$0.props = latestPendingTime.memoizedProps, instance$jscomp$0.state = latestPendingTime.memoizedState, instance$jscomp$0.componentWillUnmount();
                    } catch (unmountError) {
                      captureCommitPhaseError(latestPendingTime, unmountError);
                    }
                    break;

                  case 5:
                    safelyDetachRef(latestPendingTime);
                    break;

                  case 4:
                    FabricUIManager.createChildSet(latestPendingTime.stateNode.containerInfo);
                }

                if (null !== snapshot.child) snapshot.child.return = snapshot, snapshot = snapshot.child;else {
                  if (snapshot === instance) break;

                  for (; null === snapshot.sibling;) {
                    if (null === snapshot.return || snapshot.return === instance) break a;
                    snapshot = snapshot.return;
                  }

                  snapshot.sibling.return = snapshot.return;
                  snapshot = snapshot.sibling;
                }
              }

              prevState.return = null;
              prevState.child = null;
              prevState.alternate && (prevState.alternate.child = null, prevState.alternate.return = null);
          }

          nextEffect = nextEffect.nextEffect;
        }
      } catch (e) {
        current = !0, prevProps = e;
      }

      current && (invariant(null !== nextEffect, "Should have next effect. This error is likely caused by a bug in React. Please file an issue."), captureCommitPhaseError(nextEffect, prevProps), null !== nextEffect && (nextEffect = nextEffect.nextEffect));
    }

    root.current = finishedWork$jscomp$0;

    for (nextEffect = firstBatch; null !== nextEffect;) {
      effectTag = !1;
      current$jscomp$0 = void 0;

      try {
        for (currentRef = expirationTime; null !== nextEffect;) {
          var effectTag$jscomp$0 = nextEffect.effectTag;

          if (effectTag$jscomp$0 & 36) {
            var current$jscomp$1 = nextEffect.alternate;
            instance$jscomp$0 = nextEffect;
            firstBatch = currentRef;

            switch (instance$jscomp$0.tag) {
              case 2:
                var instance$jscomp$1 = instance$jscomp$0.stateNode;
                if (instance$jscomp$0.effectTag & 4) if (null === current$jscomp$1) instance$jscomp$1.props = instance$jscomp$0.memoizedProps, instance$jscomp$1.state = instance$jscomp$0.memoizedState, instance$jscomp$1.componentDidMount();else {
                  var prevProps$jscomp$0 = current$jscomp$1.memoizedProps,
                      prevState$jscomp$0 = current$jscomp$1.memoizedState;
                  instance$jscomp$1.props = instance$jscomp$0.memoizedProps;
                  instance$jscomp$1.state = instance$jscomp$0.memoizedState;
                  instance$jscomp$1.componentDidUpdate(prevProps$jscomp$0, prevState$jscomp$0, instance$jscomp$1.__reactInternalSnapshotBeforeUpdate);
                }
                var updateQueue = instance$jscomp$0.updateQueue;
                null !== updateQueue && (instance$jscomp$1.props = instance$jscomp$0.memoizedProps, instance$jscomp$1.state = instance$jscomp$0.memoizedState, commitUpdateQueue(instance$jscomp$0, updateQueue, instance$jscomp$1, firstBatch));
                break;

              case 3:
                var _updateQueue = instance$jscomp$0.updateQueue;

                if (null !== _updateQueue) {
                  current = null;
                  if (null !== instance$jscomp$0.child) switch (instance$jscomp$0.child.tag) {
                    case 5:
                      current = instance$jscomp$0.child.stateNode.canonical;
                      break;

                    case 2:
                      current = instance$jscomp$0.child.stateNode;
                  }
                  commitUpdateQueue(instance$jscomp$0, _updateQueue, current, firstBatch);
                }

                break;

              case 5:
                null === current$jscomp$1 && instance$jscomp$0.effectTag & 4 && invariant(!1, "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 15:
                break;

              case 16:
                break;

              default:
                invariant(!1, "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) {
            instance$jscomp$0 = void 0;
            var ref = nextEffect.ref;

            if (null !== ref) {
              var instance$jscomp$2 = nextEffect.stateNode;

              switch (nextEffect.tag) {
                case 5:
                  instance$jscomp$0 = instance$jscomp$2.canonical;
                  break;

                default:
                  instance$jscomp$0 = instance$jscomp$2;
              }

              "function" === typeof ref ? ref(instance$jscomp$0) : ref.current = instance$jscomp$0;
            }
          }

          var next = nextEffect.nextEffect;
          nextEffect.nextEffect = null;
          nextEffect = next;
        }
      } catch (e) {
        effectTag = !0, current$jscomp$0 = e;
      }

      effectTag && (invariant(null !== nextEffect, "Should have next effect. This error is likely caused by a bug in React. Please file an issue."), captureCommitPhaseError(nextEffect, current$jscomp$0), null !== nextEffect && (nextEffect = nextEffect.nextEffect));
    }

    isWorking = isCommitting$1 = !1;
    "function" === typeof onCommitRoot && onCommitRoot(finishedWork$jscomp$0.stateNode);
    finishedWork$jscomp$0 = root.expirationTime;
    0 === finishedWork$jscomp$0 && (legacyErrorBoundariesThatAlreadyFailed = null);
    root.expirationTime = finishedWork$jscomp$0;
    root.finishedWork = null;
  }

  function shouldYield() {
    return null === deadline || deadlineDidExpire || deadline.timeRemaining() > timeHeuristicForUnitOfWork ? !1 : deadlineDidExpire = !0;
  }

  function onUncaughtError(error) {
    invariant(null !== nextFlushedRoot, "Should be working on a root. This error is likely caused by a bug in React. Please file an issue.");
    nextFlushedRoot.expirationTime = 0;
    hasUnhandledError || (hasUnhandledError = !0, unhandledError = error);
  }

  function updateContainerAtExpirationTime(element, container, parentComponent, expirationTime, callback) {
    var current = container.current;

    if (parentComponent) {
      parentComponent = parentComponent._reactInternalFiber;
      var parentContext;

      b: {
        invariant(2 === isFiberMountedImpl(parentComponent) && 2 === parentComponent.tag, "Expected subtree parent to be a mounted class component. This error is likely caused by a bug in React. Please file an issue.");

        for (parentContext = parentComponent; 3 !== parentContext.tag;) {
          if (isContextProvider(parentContext)) {
            parentContext = parentContext.stateNode.__reactInternalMemoizedMergedChildContext;
            break b;
          }

          parentContext = parentContext.return;
          invariant(parentContext, "Found unexpected detached subtree parent. This error is likely caused by a bug in React. Please file an issue.");
        }

        parentContext = parentContext.stateNode.context;
      }

      parentComponent = isContextProvider(parentComponent) ? processChildContext(parentComponent, parentContext) : parentContext;
    } else parentComponent = emptyObject;

    null === container.context ? container.context = parentComponent : container.pendingContext = parentComponent;
    container = callback;
    callback = createUpdate(expirationTime);
    callback.payload = {
      element: element
    };
    container = void 0 === container ? null : container;
    null !== container && (callback.callback = container);
    enqueueUpdate(current, callback, expirationTime);
    scheduleWork(current, expirationTime);
    return expirationTime;
  }

  function findHostInstance$1(component) {
    var fiber = component._reactInternalFiber;
    void 0 === fiber && ("function" === typeof component.render ? invariant(!1, "Unable to find node on an unmounted component.") : invariant(!1, "Argument appears to not be a ReactComponent. Keys: %s", Object.keys(component)));
    component = findCurrentHostFiber(fiber);
    return null === component ? null : component.stateNode;
  }

  function updateContainer(element, container, parentComponent, callback) {
    var current = container.current,
        currentTime = recalculateCurrentTime();
    current = computeExpirationForFiber(currentTime, current);
    return updateContainerAtExpirationTime(element, container, parentComponent, current, callback);
  }

  function getPublicRootInstance(container) {
    container = container.current;
    if (!container.child) return null;

    switch (container.child.tag) {
      case 5:
        return container.child.stateNode.canonical;

      default:
        return container.child.stateNode;
    }
  }

  function injectIntoDevTools(devToolsConfig) {
    var _findFiberByHostInstance = devToolsConfig.findFiberByHostInstance;
    return injectInternals(_extends({}, devToolsConfig, {
      findHostInstanceByFiber: function findHostInstanceByFiber(fiber) {
        fiber = findCurrentHostFiber(fiber);
        return null === fiber ? null : fiber.stateNode;
      },
      findFiberByHostInstance: function findFiberByHostInstance(instance) {
        return _findFiberByHostInstance ? _findFiberByHostInstance(instance) : null;
      }
    }));
  }

  var ReactFabricRenderer = {
    updateContainerAtExpirationTime: updateContainerAtExpirationTime,
    createContainer: function createContainer(containerInfo, isAsync, hydrate) {
      return createFiberRoot(containerInfo, isAsync, hydrate);
    },
    updateContainer: updateContainer,
    flushRoot: function flushRoot(root, expirationTime) {
      invariant(!isRendering, "work.commit(): Cannot commit while already rendering. This likely means you attempted to commit from inside a lifecycle method.");
      nextFlushedRoot = root;
      nextFlushedExpirationTime = expirationTime;
      performWorkOnRoot(root, expirationTime, !1);
      performWork(1, null);
      finishRendering();
    },
    requestWork: requestWork,
    computeUniqueAsyncExpiration: function computeUniqueAsyncExpiration() {
      var result = 2 + 25 * (((recalculateCurrentTime() - 2 + 500) / 25 | 0) + 1);
      result <= lastUniqueAsyncExpiration && (result = lastUniqueAsyncExpiration + 1);
      return lastUniqueAsyncExpiration = result;
    },
    batchedUpdates: function batchedUpdates(fn, a) {
      var previousIsBatchingUpdates = isBatchingUpdates;
      isBatchingUpdates = !0;

      try {
        return fn(a);
      } finally {
        (isBatchingUpdates = previousIsBatchingUpdates) || isRendering || performWork(1, null);
      }
    },
    unbatchedUpdates: function unbatchedUpdates(fn, a) {
      if (isBatchingUpdates && !isUnbatchingUpdates) {
        isUnbatchingUpdates = !0;

        try {
          return fn(a);
        } finally {
          isUnbatchingUpdates = !1;
        }
      }

      return fn(a);
    },
    deferredUpdates: function deferredUpdates(fn) {
      var previousExpirationContext = expirationContext;
      expirationContext = 2 + 25 * (((recalculateCurrentTime() - 2 + 500) / 25 | 0) + 1);

      try {
        return fn();
      } finally {
        expirationContext = previousExpirationContext;
      }
    },
    syncUpdates: syncUpdates,
    interactiveUpdates: function interactiveUpdates(fn, a, b) {
      if (isBatchingInteractiveUpdates) return fn(a, b);
      isBatchingUpdates || isRendering || 0 === lowestPendingInteractiveExpirationTime || (performWork(lowestPendingInteractiveExpirationTime, null), lowestPendingInteractiveExpirationTime = 0);
      var previousIsBatchingInteractiveUpdates = isBatchingInteractiveUpdates,
          previousIsBatchingUpdates = isBatchingUpdates;
      isBatchingUpdates = isBatchingInteractiveUpdates = !0;

      try {
        return fn(a, b);
      } finally {
        isBatchingInteractiveUpdates = previousIsBatchingInteractiveUpdates, (isBatchingUpdates = previousIsBatchingUpdates) || isRendering || performWork(1, null);
      }
    },
    flushInteractiveUpdates: function flushInteractiveUpdates() {
      isRendering || 0 === lowestPendingInteractiveExpirationTime || (performWork(lowestPendingInteractiveExpirationTime, null), lowestPendingInteractiveExpirationTime = 0);
    },
    flushControlled: function flushControlled(fn) {
      var previousIsBatchingUpdates = isBatchingUpdates;
      isBatchingUpdates = !0;

      try {
        syncUpdates(fn);
      } finally {
        (isBatchingUpdates = previousIsBatchingUpdates) || isRendering || performWork(1, null);
      }
    },
    flushSync: function flushSync(fn, a) {
      invariant(!isRendering, "flushSync was called from inside a lifecycle method. It cannot be called when React is already rendering.");
      var previousIsBatchingUpdates = isBatchingUpdates;
      isBatchingUpdates = !0;

      try {
        return syncUpdates(fn, a);
      } finally {
        isBatchingUpdates = previousIsBatchingUpdates, performWork(1, null);
      }
    },
    getPublicRootInstance: getPublicRootInstance,
    findHostInstance: findHostInstance$1,
    findHostInstanceWithNoPortals: function findHostInstanceWithNoPortals(fiber) {
      fiber = findCurrentHostFiberWithNoPortals(fiber);
      return null === fiber ? null : fiber.stateNode;
    },
    injectIntoDevTools: injectIntoDevTools
  };

  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() {
    invariant(!1, "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$1(componentOrHandle);
    return null == componentOrHandle ? componentOrHandle : componentOrHandle.canonical ? componentOrHandle.canonical._nativeTag : componentOrHandle._nativeTag;
  }

  _batchedUpdates = ReactFabricRenderer.batchedUpdates;
  _flushInteractiveUpdates = ReactFabricRenderer.flushInteractiveUpdates;
  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(ReactNativeComponent, _React$Component);

        ReactNativeComponent.prototype.blur = function () {
          TextInputState.blurTextInput(findNodeHandle(this));
        };

        ReactNativeComponent.prototype.focus = function () {
          TextInputState.focusTextInput(findNodeHandle(this));
        };

        ReactNativeComponent.prototype.measure = function (callback) {
          UIManager.measure(findNodeHandle(this), mountSafeCallback(this, callback));
        };

        ReactNativeComponent.prototype.measureInWindow = function (callback) {
          UIManager.measureInWindow(findNodeHandle(this), mountSafeCallback(this, callback));
        };

        ReactNativeComponent.prototype.measureLayout = function (relativeToNativeNode, onSuccess, onFail) {
          UIManager.measureLayout(findNodeHandle(this), relativeToNativeNode, mountSafeCallback(this, onFail), mountSafeCallback(this, onSuccess));
        };

        ReactNativeComponent.prototype.setNativeProps = function (nativeProps) {
          var maybeInstance = void 0;

          try {
            maybeInstance = findHostInstance(this);
          } catch (error) {}

          if (null != maybeInstance) {
            var viewConfig = maybeInstance.viewConfig || maybeInstance.canonical.viewConfig;
            nativeProps = diffProperties(null, emptyObject$1, nativeProps, viewConfig.validAttributes);
            null != nativeProps && UIManager.updateView(maybeInstance._nativeTag, viewConfig.uiViewClassName, nativeProps);
          }
        };

        return ReactNativeComponent;
      }(React.Component);
    }(findNodeHandle, findHostInstance$1),
    findNodeHandle: findNodeHandle,
    render: function render(element, containerTag, callback) {
      var root = roots.get(containerTag);
      root || (root = createFiberRoot(containerTag, !1, !1), roots.set(containerTag, root));
      updateContainer(element, root, null, callback);
      return getPublicRootInstance(root);
    },
    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) {
            UIManager.measure(findNodeHandle(this), mountSafeCallback(this, callback));
          },
          measureInWindow: function measureInWindow(callback) {
            UIManager.measureInWindow(findNodeHandle(this), mountSafeCallback(this, callback));
          },
          measureLayout: function measureLayout(relativeToNativeNode, onSuccess, onFail) {
            UIManager.measureLayout(findNodeHandle(this), relativeToNativeNode, mountSafeCallback(this, onFail), mountSafeCallback(this, onSuccess));
          },
          setNativeProps: function setNativeProps(nativeProps) {
            var maybeInstance = void 0;

            try {
              maybeInstance = findHostInstance(this);
            } catch (error) {}

            if (null != maybeInstance) {
              var viewConfig = maybeInstance.viewConfig;
              nativeProps = diffProperties(null, emptyObject$1, nativeProps, viewConfig.validAttributes);
              null != nativeProps && UIManager.updateView(maybeInstance._nativeTag, viewConfig.uiViewClassName, nativeProps);
            }
          },
          focus: function focus() {
            TextInputState.focusTextInput(findNodeHandle(this));
          },
          blur: function blur() {
            TextInputState.blurTextInput(findNodeHandle(this));
          }
        };
      }(findNodeHandle, findHostInstance$1)
    }
  };
  injectIntoDevTools({
    findFiberByHostInstance: getInstanceFromInstance,
    getInspectorDataForViewTag: getInspectorDataForViewTag,
    bundleType: 0,
    version: "16.4.1",
    rendererPackageName: "react-native-renderer"
  });
  var ReactFabric$2 = {
    default: ReactFabric
  },
      ReactFabric$3 = ReactFabric$2 && ReactFabric || ReactFabric$2;
  module.exports = ReactFabric$3.default ? ReactFabric$3.default : ReactFabric$3;
},491,[263,166,231,218,1,323,324,226,325,490,271],"node_modules/react-native/Libraries/Renderer/oss/ReactFabric-prod.js");
__d(function (global, _$$_REQUIRE, 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 NativeModules = _$$_REQUIRE(_dependencyMap[0], 'NativeModules');

  var RCTAsyncStorage = NativeModules.AsyncRocksDBStorage || NativeModules.AsyncSQLiteDBStorage || NativeModules.AsyncLocalStorage;
  var AsyncStorage = {
    _getRequests: [],
    _getKeys: [],
    _immediate: null,
    getItem: function getItem(key, callback) {
      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) {
      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) {
      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) {
      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) {
      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) {
      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 = [];
      RCTAsyncStorage.multiGet(getKeys, function (errors, result) {
        var map = {};
        result && result.forEach(function (_ref) {
          var _ref2 = _slicedToArray(_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) {
        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) {
        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;
  }

  module.exports = AsyncStorage;
},492,[168],"node_modules/react-native/Libraries/Storage/AsyncStorage.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var BackHandler = _$$_REQUIRE(_dependencyMap[0], 'BackHandler');

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

  var BackAndroid = {
    exitApp: function exitApp() {
      warning(false, 'BackAndroid is deprecated.  Please use BackHandler instead.');
      BackHandler.exitApp();
    },
    addEventListener: function addEventListener(eventName, handler) {
      warning(false, 'BackAndroid is deprecated.  Please use BackHandler instead.');
      return BackHandler.addEventListener(eventName, handler);
    },
    removeEventListener: function removeEventListener(eventName, handler) {
      warning(false, 'BackAndroid is deprecated.  Please use BackHandler instead.');
      BackHandler.removeEventListener(eventName, handler);
    }
  };
  module.exports = BackAndroid;
},493,[487,183],"node_modules/react-native/Libraries/Utilities/BackAndroid.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  var PropTypes = _$$_REQUIRE(_dependencyMap[0], 'prop-types');

  var checkPropTypes = PropTypes.checkPropTypes;

  var RCTCameraRollManager = _$$_REQUIRE(_dependencyMap[1], 'NativeModules').CameraRollManager;

  var createStrictShapeTypeChecker = _$$_REQUIRE(_dependencyMap[2], 'createStrictShapeTypeChecker');

  var invariant = _$$_REQUIRE(_dependencyMap[3], 'fbjs/lib/invariant');

  var GROUP_TYPES_OPTIONS = {
    Album: 'Album',
    All: 'All',
    Event: 'Event',
    Faces: 'Faces',
    Library: 'Library',
    PhotoStream: 'PhotoStream',
    SavedPhotos: 'SavedPhotos'
  };
  var ASSET_TYPE_OPTIONS = {
    All: 'All',
    Videos: 'Videos',
    Photos: 'Photos'
  };
  var getPhotosParamChecker = createStrictShapeTypeChecker({
    first: PropTypes.number.isRequired,
    after: PropTypes.string,
    groupTypes: PropTypes.oneOf(Object.keys(GROUP_TYPES_OPTIONS)),
    groupName: PropTypes.string,
    assetType: PropTypes.oneOf(Object.keys(ASSET_TYPE_OPTIONS)),
    mimeTypes: PropTypes.arrayOf(PropTypes.string)
  });
  var getPhotosReturnChecker = createStrictShapeTypeChecker({
    edges: PropTypes.arrayOf(createStrictShapeTypeChecker({
      node: createStrictShapeTypeChecker({
        type: PropTypes.string.isRequired,
        group_name: PropTypes.string.isRequired,
        image: createStrictShapeTypeChecker({
          uri: PropTypes.string.isRequired,
          height: PropTypes.number.isRequired,
          width: PropTypes.number.isRequired,
          isStored: PropTypes.bool,
          playableDuration: PropTypes.number.isRequired
        }).isRequired,
        timestamp: PropTypes.number.isRequired,
        location: createStrictShapeTypeChecker({
          latitude: PropTypes.number,
          longitude: PropTypes.number,
          altitude: PropTypes.number,
          heading: PropTypes.number,
          speed: PropTypes.number
        })
      }).isRequired
    })).isRequired,
    page_info: createStrictShapeTypeChecker({
      has_next_page: PropTypes.bool.isRequired,
      start_cursor: PropTypes.string,
      end_cursor: PropTypes.string
    }).isRequired
  });

  var CameraRoll = function () {
    function CameraRoll() {
      _classCallCheck(this, CameraRoll);
    }

    _createClass(CameraRoll, null, [{
      key: "saveImageWithTag",
      value: function saveImageWithTag(tag) {
        console.warn('`CameraRoll.saveImageWithTag()` is deprecated. Use `CameraRoll.saveToCameraRoll()` instead.');
        return this.saveToCameraRoll(tag, 'photo');
      }
    }, {
      key: "deletePhotos",
      value: function deletePhotos(photos) {
        return RCTCameraRollManager.deletePhotos(photos);
      }
    }, {
      key: "saveToCameraRoll",
      value: function saveToCameraRoll(tag, type) {
        invariant(typeof tag === 'string', 'CameraRoll.saveToCameraRoll must be a valid string.');
        invariant(type === 'photo' || type === 'video' || type === undefined, "The second argument to saveToCameraRoll must be 'photo' or 'video'. You passed " + (type || 'unknown'));
        var mediaType = 'photo';

        if (type) {
          mediaType = type;
        } else if (['mov', 'mp4'].indexOf(tag.split('.').slice(-1)[0]) >= 0) {
          mediaType = 'video';
        }

        return RCTCameraRollManager.saveToCameraRoll(tag, mediaType);
      }
    }, {
      key: "getPhotos",
      value: function getPhotos(params) {
        if (__DEV__) {
          checkPropTypes({
            params: getPhotosParamChecker
          }, {
            params: params
          }, 'params', 'CameraRoll.getPhotos');
        }

        if (arguments.length > 1) {
          console.warn('CameraRoll.getPhotos(tag, success, error) is deprecated.  Use the returned Promise instead');
          var successCallback = arguments[1];

          if (__DEV__) {
            var callback = arguments[1];

            successCallback = function successCallback(response) {
              checkPropTypes({
                response: getPhotosReturnChecker
              }, {
                response: response
              }, 'response', 'CameraRoll.getPhotos callback');
              callback(response);
            };
          }

          var errorCallback = arguments[2] || function () {};

          RCTCameraRollManager.getPhotos(params).then(successCallback, errorCallback);
        }

        return RCTCameraRollManager.getPhotos(params);
      }
    }]);

    return CameraRoll;
  }();

  CameraRoll.GroupTypesOptions = GROUP_TYPES_OPTIONS;
  CameraRoll.AssetTypeOptions = ASSET_TYPE_OPTIONS;
  module.exports = CameraRoll;
},494,[212,168,256,166],"node_modules/react-native/Libraries/CameraRoll/CameraRoll.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var Clipboard = _$$_REQUIRE(_dependencyMap[0], 'NativeModules').Clipboard;

  module.exports = {
    getString: function getString() {
      return Clipboard.getString();
    },
    setString: function setString(content) {
      Clipboard.setString(content);
    }
  };
},495,[168],"node_modules/react-native/Libraries/Components/Clipboard/Clipboard.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var DatePickerAndroid = {
    open: function open(options) {
      return regeneratorRuntime.async(function open$(_context) {
        while (1) {
          switch (_context.prev = _context.next) {
            case 0:
              return _context.abrupt("return", Promise.reject({
                message: 'DatePickerAndroid is not supported on this platform.'
              }));

            case 1:
            case "end":
              return _context.stop();
          }
        }
      }, null, this);
    }
  };
  module.exports = DatePickerAndroid;
},496,[],"node_modules/react-native/Libraries/Components/DatePickerAndroid/DatePickerAndroid.ios.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  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 RCTImagePicker = _$$_REQUIRE(_dependencyMap[0], 'NativeModules').ImagePickerIOS;

  var ImagePickerIOS = {
    canRecordVideos: function canRecordVideos(callback) {
      return RCTImagePicker.canRecordVideos(callback);
    },
    canUseCamera: function canUseCamera(callback) {
      return RCTImagePicker.canUseCamera(callback);
    },
    openCameraDialog: function openCameraDialog(config, successCallback, cancelCallback) {
      config = _objectSpread({
        videoMode: false
      }, config);
      return RCTImagePicker.openCameraDialog(config, successCallback, cancelCallback);
    },
    openSelectDialog: function openSelectDialog(config, successCallback, cancelCallback) {
      config = _objectSpread({
        showImages: true,
        showVideos: false
      }, config);
      return RCTImagePicker.openSelectDialog(config, successCallback, cancelCallback);
    }
  };
  module.exports = ImagePickerIOS;
},497,[168],"node_modules/react-native/Libraries/CameraRoll/ImagePickerIOS.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var Map = _$$_REQUIRE(_dependencyMap[0], 'Map');

  var NativeEventEmitter = _$$_REQUIRE(_dependencyMap[1], 'NativeEventEmitter');

  var NativeModules = _$$_REQUIRE(_dependencyMap[2], 'NativeModules');

  var Platform = _$$_REQUIRE(_dependencyMap[3], 'Platform');

  var RCTNetInfo = NativeModules.NetInfo;
  var NetInfoEventEmitter = new NativeEventEmitter(RCTNetInfo);
  var DEVICE_CONNECTIVITY_EVENT = 'networkStatusDidChange';

  var _subscriptions = new Map();

  var _isConnectedDeprecated;

  if (Platform.OS === 'ios') {
    _isConnectedDeprecated = function _isConnectedDeprecated(reachability) {
      return reachability !== 'none' && reachability !== 'unknown';
    };
  } else if (Platform.OS === 'android') {
    _isConnectedDeprecated = function _isConnectedDeprecated(connectionType) {
      return connectionType !== 'NONE' && connectionType !== 'UNKNOWN';
    };
  }

  function _isConnected(connection) {
    return connection.type !== 'none' && connection.type !== 'unknown';
  }

  var _isConnectedSubscriptions = new Map();

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

      if (eventName === 'connectionChange') {
        listener = NetInfoEventEmitter.addListener(DEVICE_CONNECTIVITY_EVENT, function (appStateData) {
          handler({
            type: appStateData.connectionType,
            effectiveType: appStateData.effectiveConnectionType
          });
        });
      } else if (eventName === 'change') {
        console.warn('NetInfo\'s "change" event is deprecated. Listen to the "connectionChange" event instead.');
        listener = NetInfoEventEmitter.addListener(DEVICE_CONNECTIVITY_EVENT, function (appStateData) {
          handler(appStateData.network_info);
        });
      } else {
        console.warn('Trying to subscribe to unknown event: "' + eventName + '"');
        return {
          remove: function remove() {}
        };
      }

      _subscriptions.set(handler, listener);

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

      if (!listener) {
        return;
      }

      listener.remove();

      _subscriptions.delete(handler);
    },
    fetch: function fetch() {
      console.warn('NetInfo.fetch() is deprecated. Use NetInfo.getConnectionInfo() instead.');
      return RCTNetInfo.getCurrentConnectivity().then(function (resp) {
        return resp.network_info;
      });
    },
    getConnectionInfo: function getConnectionInfo() {
      return RCTNetInfo.getCurrentConnectivity().then(function (resp) {
        return {
          type: resp.connectionType,
          effectiveType: resp.effectiveConnectionType
        };
      });
    },
    isConnected: {
      addEventListener: function addEventListener(eventName, handler) {
        var listener = function listener(connection) {
          if (eventName === 'change') {
            handler(_isConnectedDeprecated(connection));
          } else if (eventName === 'connectionChange') {
            handler(_isConnected(connection));
          }
        };

        _isConnectedSubscriptions.set(handler, listener);

        NetInfo.addEventListener(eventName, listener);
        return {
          remove: function remove() {
            return NetInfo.isConnected.removeEventListener(eventName, handler);
          }
        };
      },
      removeEventListener: function removeEventListener(eventName, handler) {
        var listener = _isConnectedSubscriptions.get(handler);

        NetInfo.removeEventListener(eventName, listener);

        _isConnectedSubscriptions.delete(handler);
      },
      fetch: function fetch() {
        return NetInfo.getConnectionInfo().then(_isConnected);
      }
    },
    isConnectionExpensive: function isConnectionExpensive() {
      return Platform.OS === 'android' ? RCTNetInfo.isConnectionMetered() : Promise.reject(new Error('Currently not supported on iOS'));
    }
  };
  module.exports = NetInfo;
},498,[266,286,168,176],"node_modules/react-native/Libraries/Network/NetInfo.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  var NativeEventEmitter = _$$_REQUIRE(_dependencyMap[0], 'NativeEventEmitter');

  var RCTPushNotificationManager = _$$_REQUIRE(_dependencyMap[1], 'NativeModules').PushNotificationManager;

  var invariant = _$$_REQUIRE(_dependencyMap[2], 'fbjs/lib/invariant');

  var PushNotificationEmitter = new NativeEventEmitter(RCTPushNotificationManager);

  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 () {
    _createClass(PushNotificationIOS, null, [{
      key: "presentLocalNotification",
      value: function presentLocalNotification(details) {
        RCTPushNotificationManager.presentLocalNotification(details);
      }
    }, {
      key: "scheduleLocalNotification",
      value: function scheduleLocalNotification(details) {
        RCTPushNotificationManager.scheduleLocalNotification(details);
      }
    }, {
      key: "cancelAllLocalNotifications",
      value: function cancelAllLocalNotifications() {
        RCTPushNotificationManager.cancelAllLocalNotifications();
      }
    }, {
      key: "removeAllDeliveredNotifications",
      value: function removeAllDeliveredNotifications() {
        RCTPushNotificationManager.removeAllDeliveredNotifications();
      }
    }, {
      key: "getDeliveredNotifications",
      value: function getDeliveredNotifications(callback) {
        RCTPushNotificationManager.getDeliveredNotifications(callback);
      }
    }, {
      key: "removeDeliveredNotifications",
      value: function removeDeliveredNotifications(identifiers) {
        RCTPushNotificationManager.removeDeliveredNotifications(identifiers);
      }
    }, {
      key: "setApplicationIconBadgeNumber",
      value: function setApplicationIconBadgeNumber(number) {
        RCTPushNotificationManager.setApplicationIconBadgeNumber(number);
      }
    }, {
      key: "getApplicationIconBadgeNumber",
      value: function getApplicationIconBadgeNumber(callback) {
        RCTPushNotificationManager.getApplicationIconBadgeNumber(callback);
      }
    }, {
      key: "cancelLocalNotifications",
      value: function cancelLocalNotifications(userInfo) {
        RCTPushNotificationManager.cancelLocalNotifications(userInfo);
      }
    }, {
      key: "getScheduledLocalNotifications",
      value: function getScheduledLocalNotifications(callback) {
        RCTPushNotificationManager.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
          };
        }

        return RCTPushNotificationManager.requestPermissions(requestedPermissions);
      }
    }, {
      key: "abandonPermissions",
      value: function abandonPermissions() {
        RCTPushNotificationManager.abandonPermissions();
      }
    }, {
      key: "checkPermissions",
      value: function checkPermissions(callback) {
        invariant(typeof callback === 'function', 'Must provide a valid callback');
        RCTPushNotificationManager.checkPermissions(callback);
      }
    }, {
      key: "getInitialNotification",
      value: function getInitialNotification() {
        return RCTPushNotificationManager.getInitialNotification().then(function (notification) {
          return notification && new PushNotificationIOS(notification);
        });
      }
    }]);

    function PushNotificationIOS(nativeNotif) {
      var _this = this;

      _classCallCheck(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;
      }
    }

    _createClass(PushNotificationIOS, [{
      key: "finish",
      value: function finish(fetchResult) {
        if (!this._isRemote || !this._notificationId || this._remoteNotificationCompleteCallbackCalled) {
          return;
        }

        this._remoteNotificationCompleteCallbackCalled = true;
        RCTPushNotificationManager.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;
},499,[286,168,166],"node_modules/react-native/Libraries/PushNotificationIOS/PushNotificationIOS.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

  var RCTDeviceEventEmitter = _$$_REQUIRE(_dependencyMap[0], 'RCTDeviceEventEmitter');

  var RCTSettingsManager = _$$_REQUIRE(_dependencyMap[1], 'NativeModules').SettingsManager;

  var invariant = _$$_REQUIRE(_dependencyMap[2], 'fbjs/lib/invariant');

  var subscriptions = [];
  var Settings = {
    _settings: RCTSettingsManager && RCTSettingsManager.settings,
    get: function get(key) {
      return this._settings[key];
    },
    set: function set(settings) {
      this._settings = _extends(this._settings, settings);
      RCTSettingsManager.setValues(settings);
    },
    watchKeys: function watchKeys(keys, callback) {
      if (typeof keys === 'string') {
        keys = [keys];
      }

      invariant(Array.isArray(keys), 'keys should be a string or array of strings');
      var sid = subscriptions.length;
      subscriptions.push({
        keys: keys,
        callback: callback
      });
      return sid;
    },
    clearWatch: function clearWatch(watchId) {
      if (watchId < subscriptions.length) {
        subscriptions[watchId] = {
          keys: [],
          callback: null
        };
      }
    },
    _sendObservations: function _sendObservations(body) {
      var _this = this;

      Object.keys(body).forEach(function (key) {
        var newValue = body[key];
        var didChange = _this._settings[key] !== newValue;
        _this._settings[key] = newValue;

        if (didChange) {
          subscriptions.forEach(function (sub) {
            if (sub.keys.indexOf(key) !== -1 && sub.callback) {
              sub.callback();
            }
          });
        }
      });
    }
  };
  RCTDeviceEventEmitter.addListener('settingsUpdated', Settings._sendObservations.bind(Settings));
  module.exports = Settings;
},500,[194,168,166],"node_modules/react-native/Libraries/Settings/Settings.ios.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

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

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  var Platform = _$$_REQUIRE(_dependencyMap[0], 'Platform');

  var invariant = _$$_REQUIRE(_dependencyMap[1], 'fbjs/lib/invariant');

  var processColor = _$$_REQUIRE(_dependencyMap[2], 'processColor');

  var _require = _$$_REQUIRE(_dependencyMap[3], 'NativeModules'),
      ActionSheetManager = _require.ActionSheetManager,
      ShareModule = _require.ShareModule;

  var Share = function () {
    function Share() {
      _classCallCheck(this, Share);
    }

    _createClass(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 (Platform.OS === 'android') {
          invariant(!content.title || typeof content.title === 'string', 'Invalid title: title should be a string.');
          return ShareModule.share(content, options.dialogTitle);
        } else if (Platform.OS === 'ios') {
          return new Promise(function (resolve, reject) {
            ActionSheetManager.showShareActionSheetWithOptions(_objectSpread({}, content, options, {
              tintColor: processColor(options.tintColor)
            }), 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'));
        }
      }
    }, {
      key: "sharedAction",
      get: function get() {
        return 'sharedAction';
      }
    }, {
      key: "dismissedAction",
      get: function get() {
        return 'dismissedAction';
      }
    }]);

    return Share;
  }();

  module.exports = Share;
},501,[176,166,221,168],"node_modules/react-native/Libraries/Share/Share.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

  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 _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var NativeEventEmitter = _$$_REQUIRE(_dependencyMap[0], 'NativeEventEmitter');

  var _require = _$$_REQUIRE(_dependencyMap[1], 'NativeModules'),
      StatusBarManager = _require.StatusBarManager;

  var StatusBarIOS = function (_NativeEventEmitter) {
    function StatusBarIOS() {
      _classCallCheck(this, StatusBarIOS);

      return _possibleConstructorReturn(this, _getPrototypeOf(StatusBarIOS).apply(this, arguments));
    }

    _inherits(StatusBarIOS, _NativeEventEmitter);

    return StatusBarIOS;
  }(NativeEventEmitter);

  module.exports = new StatusBarIOS(StatusBarManager);
},502,[286,168],"node_modules/react-native/Libraries/Components/StatusBar/StatusBarIOS.ios.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var TimePickerAndroid = {
    open: function open(options) {
      return regeneratorRuntime.async(function open$(_context) {
        while (1) {
          switch (_context.prev = _context.next) {
            case 0:
              return _context.abrupt("return", Promise.reject({
                message: 'TimePickerAndroid is not supported on this platform.'
              }));

            case 1:
            case "end":
              return _context.stop();
          }
        }
      }, null, this);
    }
  };
  module.exports = TimePickerAndroid;
},503,[],"node_modules/react-native/Libraries/Components/TimePickerAndroid/TimePickerAndroid.ios.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var RCTVibration = _$$_REQUIRE(_dependencyMap[0], 'NativeModules').Vibration;

  var Platform = _$$_REQUIRE(_dependencyMap[1], '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) {
      RCTVibration.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;
    }

    RCTVibration.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 (Platform.OS === 'android') {
        if (typeof pattern === 'number') {
          RCTVibration.vibrate(pattern);
        } else if (Array.isArray(pattern)) {
          RCTVibration.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') {
          RCTVibration.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 (Platform.OS === 'ios') {
        _vibrating = false;
      } else {
        RCTVibration.cancel();
      }
    }
  };
  module.exports = Vibration;
},504,[168,176],"node_modules/react-native/Libraries/Vibration/Vibration.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  'use strict';

  var RCTVibration = _$$_REQUIRE(_dependencyMap[0], 'NativeModules').Vibration;

  var invariant = _$$_REQUIRE(_dependencyMap[1], 'fbjs/lib/invariant');

  var VibrationIOS = {
    vibrate: function vibrate() {
      invariant(arguments[0] === undefined, 'Vibration patterns not supported.');
      RCTVibration.vibrate();
    }
  };
  module.exports = VibrationIOS;
},505,[168,166],"node_modules/react-native/Libraries/Vibration/VibrationIOS.ios.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  var ReactNative = _$$_REQUIRE(_dependencyMap[0], 'ReactNative');

  var UIManager = _$$_REQUIRE(_dependencyMap[1], 'UIManager');

  module.exports = function takeSnapshot(view, options) {
    if (typeof view !== 'number' && view !== 'window') {
      view = ReactNative.findNodeHandle(view) || 'window';
    }

    return UIManager.__takeSnapshot(view, options);
  };
},506,[261,218],"node_modules/react-native/Libraries/ReactNative/takeSnapshot.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = Util;

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

  function Util() {}

  Util.isPortrait = function () {
    var dim = _reactNative.Dimensions.get("screen");

    return dim.height >= dim.width;
  };

  Util.secondToTime = function (time) {
    return ~~(time / 60) + ":" + (time % 60 < 10 ? "0" : "") + time % 60;
  };

  Util.normalizeSeconds = function (number) {
    var sec_num = parseInt(number, 10);
    var hours = Math.floor(sec_num / 3600);
    var minutes = Math.floor((sec_num - hours * 3600) / 60);
    var seconds = sec_num - hours * 3600 - minutes * 60;

    if (hours < 10) {
      hours = "0" + hours;
    }

    if (minutes < 10) {
      minutes = "0" + minutes;
    }

    if (seconds < 10) {
      seconds = "0" + seconds;
    }

    return hours + ':' + minutes + ':' + seconds;
  };
},507,[165],"Utils.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  Object.defineProperty(exports, "TextTrackType", {
    enumerable: true,
    get: function get() {
      return _TextTrackType.default;
    }
  });
  Object.defineProperty(exports, "FilterType", {
    enumerable: true,
    get: function get() {
      return _FilterType.default;
    }
  });
  exports.default = void 0;

  var _react = _interopRequireWildcard(_$$_REQUIRE(_dependencyMap[0], "react"));

  var _index = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[1], "./../react-transform-hmr/lib/index.js"));

  var _propTypes = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[2], "prop-types"));

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

  var _resolveAssetSource = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[4], "react-native/Libraries/Image/resolveAssetSource"));

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

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

  var _VideoResizeMode = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[7], "./VideoResizeMode.js"));

  var _jsxFileName = "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native-video/Video.js";

  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

  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 _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; }

  function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

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

  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

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

  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 _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); }

  var _components = {
    Video: {
      displayName: "Video"
    }
  };

  var _reactTransformHmrLibIndexJs2 = (0, _index.default)({
    filename: "/Users/amishra/Development/github/react-native-video/examples/embed-and-fullscreen/node_modules/react-native-video/Video.js",
    components: _components,
    locals: [module],
    imports: [_react.default]
  });

  function _wrapComponent(id) {
    return function (Component) {
      return _reactTransformHmrLibIndexJs2(Component, id);
    };
  }

  var styles = _reactNative.StyleSheet.create({
    base: {
      overflow: 'hidden'
    }
  });

  var Video = _wrapComponent("Video")(function (_Component) {
    function Video(props) {
      var _this;

      _classCallCheck(this, Video);

      _this = _possibleConstructorReturn(this, _getPrototypeOf(Video).call(this, props));

      _this.seek = function (time) {
        var tolerance = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 100;
        if (isNaN(time)) throw new Error('Specified time is not a number');

        if (_reactNative.Platform.OS === 'ios') {
          _this.setNativeProps({
            seek: {
              time: time,
              tolerance: tolerance
            }
          });
        } else {
          _this.setNativeProps({
            seek: time
          });
        }
      };

      _this.presentFullscreenPlayer = function () {
        _this.setNativeProps({
          fullscreen: true
        });
      };

      _this.dismissFullscreenPlayer = function () {
        _this.setNativeProps({
          fullscreen: false
        });
      };

      _this.save = function _callee(options) {
        return regeneratorRuntime.async(function _callee$(_context) {
          while (1) {
            switch (_context.prev = _context.next) {
              case 0:
                _context.next = 2;
                return regeneratorRuntime.awrap(_reactNative.NativeModules.VideoManager.save(options, (0, _reactNative.findNodeHandle)(_this._root)));

              case 2:
                return _context.abrupt("return", _context.sent);

              case 3:
              case "end":
                return _context.stop();
            }
          }
        }, null, this);
      };

      _this._assignRoot = function (component) {
        _this._root = component;
      };

      _this._onLoadStart = function (event) {
        if (_this.props.onLoadStart) {
          _this.props.onLoadStart(event.nativeEvent);
        }
      };

      _this._onLoad = function (event) {
        if (_this.props.onLoad) {
          _this.props.onLoad(event.nativeEvent);
        }
      };

      _this._onError = function (event) {
        if (_this.props.onError) {
          _this.props.onError(event.nativeEvent);
        }
      };

      _this._onProgress = function (event) {
        if (_this.props.onProgress) {
          _this.props.onProgress(event.nativeEvent);
        }
      };

      _this._onBandwidthUpdate = function (event) {
        if (_this.props.onBandwidthUpdate) {
          _this.props.onBandwidthUpdate(event.nativeEvent);
        }
      };

      _this._onSeek = function (event) {
        if (_this.state.showPoster && !_this.props.audioOnly) {
          _this.setState({
            showPoster: false
          });
        }

        if (_this.props.onSeek) {
          _this.props.onSeek(event.nativeEvent);
        }
      };

      _this._onEnd = function (event) {
        if (_this.props.onEnd) {
          _this.props.onEnd(event.nativeEvent);
        }
      };

      _this._onTimedMetadata = function (event) {
        if (_this.props.onTimedMetadata) {
          _this.props.onTimedMetadata(event.nativeEvent);
        }
      };

      _this._onFullscreenPlayerWillPresent = function (event) {
        if (_this.props.onFullscreenPlayerWillPresent) {
          _this.props.onFullscreenPlayerWillPresent(event.nativeEvent);
        }
      };

      _this._onFullscreenPlayerDidPresent = function (event) {
        if (_this.props.onFullscreenPlayerDidPresent) {
          _this.props.onFullscreenPlayerDidPresent(event.nativeEvent);
        }
      };

      _this._onFullscreenPlayerWillDismiss = function (event) {
        if (_this.props.onFullscreenPlayerWillDismiss) {
          _this.props.onFullscreenPlayerWillDismiss(event.nativeEvent);
        }
      };

      _this._onFullscreenPlayerDidDismiss = function (event) {
        if (_this.props.onFullscreenPlayerDidDismiss) {
          _this.props.onFullscreenPlayerDidDismiss(event.nativeEvent);
        }
      };

      _this._onReadyForDisplay = function (event) {
        if (_this.props.onReadyForDisplay) {
          _this.props.onReadyForDisplay(event.nativeEvent);
        }
      };

      _this._onPlaybackStalled = function (event) {
        if (_this.props.onPlaybackStalled) {
          _this.props.onPlaybackStalled(event.nativeEvent);
        }
      };

      _this._onPlaybackResume = function (event) {
        if (_this.props.onPlaybackResume) {
          _this.props.onPlaybackResume(event.nativeEvent);
        }
      };

      _this._onPlaybackRateChange = function (event) {
        if (_this.state.showPoster && event.nativeEvent.playbackRate !== 0 && !_this.props.audioOnly) {
          _this.setState({
            showPoster: false
          });
        }

        if (_this.props.onPlaybackRateChange) {
          _this.props.onPlaybackRateChange(event.nativeEvent);
        }
      };

      _this._onExternalPlaybackChange = function (event) {
        if (_this.props.onExternalPlaybackChange) {
          _this.props.onExternalPlaybackChange(event.nativeEvent);
        }
      };

      _this._onAudioBecomingNoisy = function () {
        if (_this.props.onAudioBecomingNoisy) {
          _this.props.onAudioBecomingNoisy();
        }
      };

      _this._onAudioFocusChanged = function (event) {
        if (_this.props.onAudioFocusChanged) {
          _this.props.onAudioFocusChanged(event.nativeEvent);
        }
      };

      _this._onBuffer = function (event) {
        if (_this.props.onBuffer) {
          _this.props.onBuffer(event.nativeEvent);
        }
      };

      _this.state = {
        showPoster: true
      };
      return _this;
    }

    _createClass(Video, [{
      key: "setNativeProps",
      value: function setNativeProps(nativeProps) {
        this._root.setNativeProps(nativeProps);
      }
    }, {
      key: "toTypeString",
      value: function toTypeString(x) {
        switch (typeof x) {
          case "object":
            return x instanceof Date ? x.toISOString() : JSON.stringify(x);

          case "undefined":
            return "";

          default:
            return x.toString();
        }
      }
    }, {
      key: "stringsOnlyObject",
      value: function stringsOnlyObject(obj) {
        var _this2 = this;

        var strObj = {};
        Object.keys(obj).forEach(function (x) {
          strObj[x] = _this2.toTypeString(obj[x]);
        });
        return strObj;
      }
    }, {
      key: "render",
      value: function render() {
        var resizeMode = this.props.resizeMode;
        var source = (0, _resolveAssetSource.default)(this.props.source) || {};
        var uri = source.uri || '';

        if (uri && uri.match(/^\//)) {
          uri = "file://" + uri;
        }

        var isNetwork = !!(uri && uri.match(/^https?:/));
        var isAsset = !!(uri && uri.match(/^(assets-library|ipod-library|file|content|ms-appx|ms-appdata):/));
        var nativeResizeMode;

        if (resizeMode === _VideoResizeMode.default.stretch) {
          nativeResizeMode = _reactNative.NativeModules.UIManager.RCTVideo.Constants.ScaleToFill;
        } else if (resizeMode === _VideoResizeMode.default.contain) {
          nativeResizeMode = _reactNative.NativeModules.UIManager.RCTVideo.Constants.ScaleAspectFit;
        } else if (resizeMode === _VideoResizeMode.default.cover) {
          nativeResizeMode = _reactNative.NativeModules.UIManager.RCTVideo.Constants.ScaleAspectFill;
        } else {
          nativeResizeMode = _reactNative.NativeModules.UIManager.RCTVideo.Constants.ScaleNone;
        }

        var nativeProps = _extends({}, this.props);

        _extends(nativeProps, {
          style: [styles.base, nativeProps.style],
          resizeMode: nativeResizeMode,
          src: {
            uri: uri,
            isNetwork: isNetwork,
            isAsset: isAsset,
            type: source.type || '',
            mainVer: source.mainVer || 0,
            patchVer: source.patchVer || 0,
            requestHeaders: source.headers ? this.stringsOnlyObject(source.headers) : {}
          },
          onVideoLoadStart: this._onLoadStart,
          onVideoLoad: this._onLoad,
          onVideoError: this._onError,
          onVideoProgress: this._onProgress,
          onVideoSeek: this._onSeek,
          onVideoEnd: this._onEnd,
          onVideoBuffer: this._onBuffer,
          onVideoBandwidthUpdate: this._onBandwidthUpdate,
          onTimedMetadata: this._onTimedMetadata,
          onVideoAudioBecomingNoisy: this._onAudioBecomingNoisy,
          onVideoExternalPlaybackChange: this._onExternalPlaybackChange,
          onVideoFullscreenPlayerWillPresent: this._onFullscreenPlayerWillPresent,
          onVideoFullscreenPlayerDidPresent: this._onFullscreenPlayerDidPresent,
          onVideoFullscreenPlayerWillDismiss: this._onFullscreenPlayerWillDismiss,
          onVideoFullscreenPlayerDidDismiss: this._onFullscreenPlayerDidDismiss,
          onReadyForDisplay: this._onReadyForDisplay,
          onPlaybackStalled: this._onPlaybackStalled,
          onPlaybackResume: this._onPlaybackResume,
          onPlaybackRateChange: this._onPlaybackRateChange,
          onAudioFocusChanged: this._onAudioFocusChanged,
          onAudioBecomingNoisy: this._onAudioBecomingNoisy
        });

        var posterStyle = _objectSpread({}, _reactNative.StyleSheet.absoluteFillObject, {
          resizeMode: this.props.posterResizeMode || 'contain'
        });

        return _react.default.createElement(_react.default.Fragment, {
          __source: {
            fileName: _jsxFileName,
            lineNumber: 278
          }
        }, _react.default.createElement(RCTVideo, _extends({
          ref: this._assignRoot
        }, nativeProps, {
          __source: {
            fileName: _jsxFileName,
            lineNumber: 279
          }
        })), this.props.poster && this.state.showPoster && _react.default.createElement(_reactNative.View, {
          style: nativeProps.style,
          __source: {
            fileName: _jsxFileName,
            lineNumber: 282
          }
        }, _react.default.createElement(_reactNative.Image, {
          style: posterStyle,
          source: {
            uri: this.props.poster
          },
          __source: {
            fileName: _jsxFileName,
            lineNumber: 283
          }
        })));
      }
    }]);

    _inherits(Video, _Component);

    return Video;
  }(_react.Component));

  var _default2 = Video;
  exports.default = _default2;
  Video.propTypes = _objectSpread({
    filter: _propTypes.default.oneOf([_FilterType.default.NONE, _FilterType.default.INVERT, _FilterType.default.MONOCHROME, _FilterType.default.POSTERIZE, _FilterType.default.FALSE, _FilterType.default.MAXIMUMCOMPONENT, _FilterType.default.MINIMUMCOMPONENT, _FilterType.default.CHROME, _FilterType.default.FADE, _FilterType.default.INSTANT, _FilterType.default.MONO, _FilterType.default.NOIR, _FilterType.default.PROCESS, _FilterType.default.TONAL, _FilterType.default.TRANSFER, _FilterType.default.SEPIA]),
    filterEnabled: _propTypes.default.bool,
    src: _propTypes.default.object,
    seek: _propTypes.default.oneOfType([_propTypes.default.number, _propTypes.default.object]),
    fullscreen: _propTypes.default.bool,
    onVideoLoadStart: _propTypes.default.func,
    onVideoLoad: _propTypes.default.func,
    onVideoBuffer: _propTypes.default.func,
    onVideoError: _propTypes.default.func,
    onVideoProgress: _propTypes.default.func,
    onVideoBandwidthUpdate: _propTypes.default.func,
    onVideoSeek: _propTypes.default.func,
    onVideoEnd: _propTypes.default.func,
    onTimedMetadata: _propTypes.default.func,
    onVideoAudioBecomingNoisy: _propTypes.default.func,
    onVideoExternalPlaybackChange: _propTypes.default.func,
    onVideoFullscreenPlayerWillPresent: _propTypes.default.func,
    onVideoFullscreenPlayerDidPresent: _propTypes.default.func,
    onVideoFullscreenPlayerWillDismiss: _propTypes.default.func,
    onVideoFullscreenPlayerDidDismiss: _propTypes.default.func,
    source: _propTypes.default.oneOfType([_propTypes.default.shape({
      uri: _propTypes.default.string
    }), _propTypes.default.number]),
    maxBitRate: _propTypes.default.number,
    resizeMode: _propTypes.default.string,
    poster: _propTypes.default.string,
    posterResizeMode: _reactNative.Image.propTypes.resizeMode,
    repeat: _propTypes.default.bool,
    allowsExternalPlayback: _propTypes.default.bool,
    selectedAudioTrack: _propTypes.default.shape({
      type: _propTypes.default.string.isRequired,
      value: _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.number])
    }),
    selectedVideoTrack: _propTypes.default.shape({
      type: _propTypes.default.string.isRequired,
      value: _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.number])
    }),
    selectedTextTrack: _propTypes.default.shape({
      type: _propTypes.default.string.isRequired,
      value: _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.number])
    }),
    textTracks: _propTypes.default.arrayOf(_propTypes.default.shape({
      title: _propTypes.default.string,
      uri: _propTypes.default.string.isRequired,
      type: _propTypes.default.oneOf([_TextTrackType.default.SRT, _TextTrackType.default.TTML, _TextTrackType.default.VTT]),
      language: _propTypes.default.string.isRequired
    })),
    paused: _propTypes.default.bool,
    muted: _propTypes.default.bool,
    volume: _propTypes.default.number,
    bufferConfig: _propTypes.default.shape({
      minBufferMs: _propTypes.default.number,
      maxBufferMs: _propTypes.default.number,
      bufferForPlaybackMs: _propTypes.default.number,
      bufferForPlaybackAfterRebufferMs: _propTypes.default.number
    }),
    stereoPan: _propTypes.default.number,
    rate: _propTypes.default.number,
    playInBackground: _propTypes.default.bool,
    playWhenInactive: _propTypes.default.bool,
    ignoreSilentSwitch: _propTypes.default.oneOf(['ignore', 'obey']),
    reportBandwidth: _propTypes.default.bool,
    disableFocus: _propTypes.default.bool,
    controls: _propTypes.default.bool,
    audioOnly: _propTypes.default.bool,
    currentTime: _propTypes.default.number,
    fullscreenAutorotate: _propTypes.default.bool,
    fullscreenOrientation: _propTypes.default.oneOf(['all', 'landscape', 'portrait']),
    progressUpdateInterval: _propTypes.default.number,
    useTextureView: _propTypes.default.bool,
    hideShutterView: _propTypes.default.bool,
    onLoadStart: _propTypes.default.func,
    onLoad: _propTypes.default.func,
    onBuffer: _propTypes.default.func,
    onError: _propTypes.default.func,
    onProgress: _propTypes.default.func,
    onBandwidthUpdate: _propTypes.default.func,
    onSeek: _propTypes.default.func,
    onEnd: _propTypes.default.func,
    onFullscreenPlayerWillPresent: _propTypes.default.func,
    onFullscreenPlayerDidPresent: _propTypes.default.func,
    onFullscreenPlayerWillDismiss: _propTypes.default.func,
    onFullscreenPlayerDidDismiss: _propTypes.default.func,
    onReadyForDisplay: _propTypes.default.func,
    onPlaybackStalled: _propTypes.default.func,
    onPlaybackResume: _propTypes.default.func,
    onPlaybackRateChange: _propTypes.default.func,
    onAudioFocusChanged: _propTypes.default.func,
    onAudioBecomingNoisy: _propTypes.default.func,
    onExternalPlaybackChange: _propTypes.default.func,
    scaleX: _propTypes.default.number,
    scaleY: _propTypes.default.number,
    translateX: _propTypes.default.number,
    translateY: _propTypes.default.number,
    rotation: _propTypes.default.number
  }, _reactNative.ViewPropTypes);
  var RCTVideo = (0, _reactNative.requireNativeComponent)('RCTVideo', Video, {
    nativeOnly: {
      src: true,
      seek: true,
      fullscreen: true
    }
  });
},508,[1,11,212,165,235,509,510,511],"node_modules/react-native-video/Video.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;
  var _default = {
    SRT: 'application/x-subrip',
    TTML: 'application/ttml+xml',
    VTT: 'text/vtt'
  };
  exports.default = _default;
},509,[],"node_modules/react-native-video/TextTrackType.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;
  var _default = {
    NONE: '',
    INVERT: 'CIColorInvert',
    MONOCHROME: 'CIColorMonochrome',
    POSTERIZE: 'CIColorPosterize',
    FALSE: 'CIFalseColor',
    MAXIMUMCOMPONENT: 'CIMaximumComponent',
    MINIMUMCOMPONENT: 'CIMinimumComponent',
    CHROME: 'CIPhotoEffectChrome',
    FADE: 'CIPhotoEffectFade',
    INSTANT: 'CIPhotoEffectInstant',
    MONO: 'CIPhotoEffectMono',
    NOIR: 'CIPhotoEffectNoir',
    PROCESS: 'CIPhotoEffectProcess',
    TONAL: 'CIPhotoEffectTonal',
    TRANSFER: 'CIPhotoEffectTransfer',
    SEPIA: 'CISepiaTone'
  };
  exports.default = _default;
},510,[],"node_modules/react-native-video/FilterType.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;

  var _keymirror = _interopRequireDefault(_$$_REQUIRE(_dependencyMap[0], "keymirror"));

  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

  var _default = (0, _keymirror.default)({
    contain: null,
    cover: null,
    stretch: null
  });

  exports.default = _default;
},511,[512],"node_modules/react-native-video/VideoResizeMode.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  "use strict";

  var keyMirror = function keyMirror(obj) {
    var ret = {};
    var key;

    if (!(obj instanceof Object && !Array.isArray(obj))) {
      throw new Error('keyMirror(...): Argument must be an object.');
    }

    for (key in obj) {
      if (!obj.hasOwnProperty(key)) {
        continue;
      }

      ret[key] = key;
    }

    return ret;
  };

  module.exports = keyMirror;
},512,[],"node_modules/keymirror/index.js");
__d(function (global, _$$_REQUIRE, module, exports, _dependencyMap) {
  module.exports = _$$_REQUIRE(_dependencyMap[0], "react-native/Libraries/Image/AssetRegistry").registerAsset({
    "__packager_asset": true,
    "httpServerLocation": "/assets",
    "scales": [1],
    "hash": "19584c6683a76683b635cd5c3d966064",
    "name": "broadchurch",
    "type": "mp4"
  });
},513,[236],"broadchurch.mp4");
require(263);
require(0);
//# sourceMappingURL=index.ios.map